feat: système de tags + vue table enrichie pour recherche/filtre workspace

- DB: tables tags + page_tags avec index
- API: CRUD tags (GET/POST/DELETE items/{id}/tags, GET /tags, GET /tags/search)
- Tree endpoint enrichi: size, dates, author, tags par nœud
- Table enrichie: colonnes Name, Path, Size, Modified, Type, Author, Tags
- Tag chips avec compteurs + filtrage par clic
- Ajout/retrait tags inline dans la table
- Filtre Folders + auto-switch table quand recherche active

app/routers/dashboard.py

@@ -581,21 +581,60 @@ def _build_tree_children(conn, parent_id: int | None, ws_id: int) -> list:
     """Recursively build the tree of children for a node."""
     if parent_id is None:
         rows = conn.execute(
-            "SELECT id, title, parent_section, content_format FROM pages "
-            "WHERE parent_id IS NULL AND workspace_id=? ORDER BY created_at DESC",
+            "SELECT id, title, parent_section, content_format, content, "
+            "created_at, updated_at FROM pages "
+            "WHERE parent_id IS NULL AND workspace_id=? AND deleted_at IS NULL "
+            "ORDER BY created_at DESC",
             (ws_id,),
         ).fetchall()
     else:
         rows = conn.execute(
-            "SELECT id, title, parent_section, content_format FROM pages "
-            "WHERE parent_id=? AND workspace_id=? ORDER BY created_at DESC",
+            "SELECT id, title, parent_section, content_format, content, "
+            "created_at, updated_at FROM pages "
+            "WHERE parent_id=? AND workspace_id=? AND deleted_at IS NULL "
+            "ORDER BY created_at DESC",
             (parent_id, ws_id),
         ).fetchall()
     
+    # Get workspace owner name for author display
+    ws_owner = conn.execute(
+        "SELECT u.full_name, u.login FROM workspaces w JOIN users u ON u.id=w.owner_id WHERE w.id=?",
+        (ws_id,),
+    ).fetchone()
+    author = ws_owner["full_name"] or ws_owner["login"] if ws_owner else "—"
+    
+    # Collect all page IDs to fetch tags in one query
+    all_ids = [r["id"] for r in rows]
+    tags_map = {}
+    if all_ids:
+        placeholders = ",".join("?" for _ in all_ids)
+        tag_rows = conn.execute(
+            f"SELECT pt.page_id, t.id, t.name, t.color FROM page_tags pt "
+            f"JOIN tags t ON t.id=pt.tag_id WHERE pt.page_id IN ({placeholders})",
+            all_ids,
+        ).fetchall()
+        for tr in tag_rows:
+            tags_map.setdefault(tr["page_id"], []).append({
+                "id": tr["id"], "name": tr["name"], "color": tr["color"],
+            })
+    
     tree = []
     for r in rows:
         is_folder = r["parent_section"] == "Workspace"
         children = _build_tree_children(conn, r["id"], ws_id)
+        
+        # Compute size
+        size = 0
+        if r["content_format"] == "file":
+            import json as _json
+            try:
+                meta = _json.loads(r["content"])
+                size = meta.get("size", 0)
+            except Exception:
+                size = len(r["content"] or "")
+        else:
+            size = len(r["content"] or "")
+        
         tree.append({
             "id": r["id"],
             "name": r["title"] or "Untitled",
@@ -605,10 +644,27 @@ def _build_tree_children(conn, parent_id: int | None, ws_id: int) -> list:
             "children": children,
             "has_children": len(children) > 0,
             "child_count": len(children),
+            "size": size,
+            "size_display": _format_size(size),
+            "created_at": r["created_at"],
+            "updated_at": r["updated_at"],
+            "author": author,
+            "tags": tags_map.get(r["id"], []),
         })
     return tree
 
 
+def _format_size(size_bytes: int) -> str:
+    """Human-readable file size."""
+    if size_bytes < 1024:
+        return f"{size_bytes} B"
+    elif size_bytes < 1024 * 1024:
+        return f"{size_bytes / 1024:.1f} KB"
+    elif size_bytes < 1024 * 1024 * 1024:
+        return f"{size_bytes / (1024 * 1024):.1f} MB"
+    return f"{size_bytes / (1024 * 1024 * 1024):.2f} GB"
+
+
 def _build_breadcrumb(conn, folder_id: int) -> list:
     """Build breadcrumb trail from root to folder_id."""
     breadcrumb = []
@@ -1022,3 +1078,125 @@ async def select_workspace(request: Request, ws_id: int):
     response = JSONResponse({"status": "ok", "workspace_id": ws_id})
     response.set_cookie(WORKSPACE_COOKIE, str(ws_id), max_age=86400 * 30, httponly=True, path="/")
     return response
+
+
+# ═══════════ Tags API ═══════════
+
+@router.get("/api/local-workspace/tags")
+async def list_tags(request: Request):
+    """List all tags used in the active workspace."""
+    ws = _get_active_workspace(request)
+    ws_id = ws["id"] if ws else None
+    if not ws_id:
+        return {"tags": []}
+    import json
+    with get_conn() as conn:
+        rows = conn.execute(
+            "SELECT DISTINCT t.id, t.name, t.color, COUNT(pt.page_id) as count "
+            "FROM tags t "
+            "JOIN page_tags pt ON pt.tag_id = t.id "
+            "JOIN pages p ON p.id = pt.page_id AND p.workspace_id = ? "
+            "GROUP BY t.id ORDER BY t.name",
+            (ws_id,),
+        ).fetchall()
+    return {"tags": [dict(r) for r in rows]}
+
+
+@router.get("/api/local-workspace/items/{item_id:int}/tags")
+async def get_item_tags(item_id: int):
+    """Get tags for a specific item."""
+    with get_conn() as conn:
+        rows = conn.execute(
+            "SELECT t.id, t.name, t.color FROM tags t "
+            "JOIN page_tags pt ON pt.tag_id = t.id "
+            "WHERE pt.page_id = ? ORDER BY t.name",
+            (item_id,),
+        ).fetchall()
+    return {"tags": [dict(r) for r in rows]}
+
+
+@router.post("/api/local-workspace/items/{item_id:int}/tags")
+async def add_item_tag(request: Request, item_id: int):
+    """Add a tag to an item (creates tag if new)."""
+    import json
+    body = await request.json()
+    tag_name = body.get("name", "").strip().lower()
+    if not tag_name:
+        return {"error": "Tag name required"}, 400
+
+    with get_conn() as conn:
+        # Get or create tag
+        tag = conn.execute("SELECT id, name, color FROM tags WHERE name = ?", (tag_name,)).fetchone()
+        if not tag:
+            cursor = conn.execute(
+                "INSERT INTO tags (name) VALUES (?)", (tag_name,)
+            )
+            conn.commit()
+            tag_id = cursor.lastrowid
+            tag = {"id": tag_id, "name": tag_name, "color": "#787774"}
+        else:
+            tag_id = tag["id"]
+
+        # Link tag to page (ignore duplicate)
+        try:
+            conn.execute(
+                "INSERT OR IGNORE INTO page_tags (page_id, tag_id) VALUES (?, ?)",
+                (item_id, tag_id),
+            )
+            conn.commit()
+        except Exception:
+            pass
+
+    return {"tag": {"id": tag["id"], "name": tag["name"], "color": tag["color"]}}
+
+
+@router.delete("/api/local-workspace/items/{item_id:int}/tags/{tag_id:int}")
+async def remove_item_tag(item_id: int, tag_id: int):
+    """Remove a tag from an item."""
+    with get_conn() as conn:
+        conn.execute(
+            "DELETE FROM page_tags WHERE page_id = ? AND tag_id = ?",
+            (item_id, tag_id),
+        )
+        conn.commit()
+    return {"status": "ok"}
+
+
+@router.get("/api/local-workspace/tags/search")
+async def search_by_tags(request: Request, tags: str = ""):
+    """Search items by tags (comma-separated)."""
+    ws = _get_active_workspace(request)
+    ws_id = ws["id"] if ws else None
+    if not ws_id:
+        return {"items": []}
+    import json
+    tag_names = [t.strip().lower() for t in tags.split(",") if t.strip()]
+    if not tag_names:
+        return {"items": []}
+    with get_conn() as conn:
+        placeholders = ",".join("?" for _ in tag_names)
+        rows = conn.execute(
+            f"SELECT DISTINCT p.id, p.title, p.content_format, p.parent_section, "
+            f"p.content, p.created_at, p.updated_at "
+            f"FROM pages p "
+            f"JOIN page_tags pt ON pt.page_id = p.id "
+            f"JOIN tags t ON t.id = pt.tag_id "
+            f"WHERE t.name IN ({placeholders}) AND p.workspace_id = ? AND p.deleted_at IS NULL "
+            f"ORDER BY p.updated_at DESC",
+            tag_names + [ws_id],
+        ).fetchall()
+    items = []
+    for r in rows:
+        is_folder = r["parent_section"] == "Workspace"
+        size = len(r["content"] or "")
+        items.append({
+            "id": r["id"],
+            "name": r["title"] or "Untitled",
+            "is_folder": is_folder,
+            "content_format": r["content_format"],
+            "created_at": r["created_at"],
+            "updated_at": r["updated_at"],
+            "size": size,
+            "size_display": _format_size(size),
+        })
+    return {"items": items}