dashboard: redesign home, add explore page, import/export settings

- Home page now shows project cards (derived from document project
  fields) with doc counts and last activity dates, plus recent
  activity table below
- New /project/<name> route for per-project activity view
- New Explore page replaces graph as primary way to browse
  connections: topic search with dossier, relationship list,
  related objects, and entity browser with size-weighted chips
- Entities page merged into Explore as browsable entity grid
- Documents and Graph pages use project dropdowns instead of
  free-text input
- Settings page gains Obsidian vault import and markdown export
- Graph page marked as under development with link to Explore
- Template cleanup: inline styles replaced with CSS classes

Author: grayisnotacolor

src/cortex/dashboard/server.py

@@ -183,13 +183,51 @@ async def home(request: Request):
             return RedirectResponse("/login", status_code=302)
 
         stats = await mcp_client.status()
-        recent = await mcp_client.list_objects(limit=10)
         alerts = stats.get("alerts", []) if isinstance(stats, dict) else []
 
+        # Derive projects from document project fields.
+        all_docs = await mcp_client.list_objects(limit=500)
+
+        doc_counts: dict[str, int] = {}
+        last_activity: dict[str, str] = {}
+        for doc in all_docs:
+            proj = doc.get("project", "")
+            if proj:
+                doc_counts[proj] = doc_counts.get(proj, 0) + 1
+                created = doc.get("created_at", "")
+                if created > last_activity.get(proj, ""):
+                    last_activity[proj] = created
+
+        # Build project list sorted by doc count descending.
+        projects = [
+            {
+                "name": name,
+                "doc_count": count,
+                "last_activity": last_activity.get(name, "")[:10],
+            }
+            for name, count in sorted(doc_counts.items(), key=lambda x: -x[1])
+        ]
+
+        recent = all_docs[:10]
+
         return templates.TemplateResponse(
             request,
             "home.html",
-            _ctx(stats=stats, alerts=alerts, recent=recent),
+            _ctx(stats=stats, alerts=alerts, projects=projects, recent=recent),
+        )
+
+    @app.get("/project/{project_name}", response_class=HTMLResponse)
+    async def project_detail(request: Request, project_name: str):
+        session = _require_auth(request)
+        if session is None:
+            return RedirectResponse("/login", status_code=302)
+
+        docs = await mcp_client.list_objects(project=project_name, limit=50)
+
+        return templates.TemplateResponse(
+            request,
+            "project.html",
+            _ctx(project_name=project_name, documents=docs),
         )
 
     @app.get("/documents", response_class=HTMLResponse)
@@ -217,6 +255,10 @@ async def documents_page(
                 limit=50,
             )
 
+        # Get distinct project names for the dropdown.
+        all_docs = await mcp_client.list_objects(limit=500)
+        project_names = sorted({d.get("project", "") for d in all_docs} - {""})
+
         return templates.TemplateResponse(
             request,
             "documents.html",
@@ -225,6 +267,7 @@ async def documents_page(
                 query=q,
                 doc_type=doc_type,
                 project=project,
+                project_names=project_names,
             ),
         )
 
@@ -241,12 +284,111 @@ async def document_detail(request: Request, obj_id: str):
         # Access tracking happens server-side inside cortex_read.
         return templates.TemplateResponse(request, "detail.html", _ctx(doc=doc))
 
+    @app.get("/explore", response_class=HTMLResponse)
+    async def explore_page(
+        request: Request,
+        topic: str = "",
+        entity_type: str = "",
+    ):
+        session = _require_auth(request)
+        if session is None:
+            return RedirectResponse("/login", status_code=302)
+
+        dossier = None
+        connections: list[dict[str, Any]] = []
+
+        if topic:
+            # Fetch dossier for the topic.
+            try:
+                dossier = await mcp_client.dossier(topic)
+            except MCPClientError:
+                dossier = None
+
+            # If dossier found objects, resolve relationships for the
+            # first object to show how it connects.
+            if dossier and dossier.get("objects"):
+                first_id = dossier["objects"][0]["id"]
+                try:
+                    graph_info = await mcp_client.graph(obj_id=first_id)
+                    rels = graph_info.get("relationships", [])
+                    obj_lookup = {
+                        o["id"]: o for o in dossier.get("objects", [])
+                    }
+                    for rel in rels:
+                        other = obj_lookup.get(rel["other_id"])
+                        if other:
+                            connections.append({
+                                "direction": rel["direction"],
+                                "rel_type": rel["rel_type"],
+                                "other_id": rel["other_id"],
+                                "other_title": other.get("title", rel["other_id"][:8]),
+                                "other_type": other.get("type", ""),
+                            })
+                except MCPClientError:
+                    pass
+
+        # Always fetch entities for the browse section.
+        entities = await mcp_client.list_entities(entity_type=entity_type)
+
+        # Compute connection counts per entity from graph data.
+        graph_data = await mcp_client.graph_data(limit=500)
+        edge_counts: dict[str, int] = {}
+        node_lookup: dict[str, str] = {}  # id -> label
+        for node in graph_data.get("nodes", []):
+            d = node.get("data", {})
+            node_lookup[d.get("id", "")] = d.get("label", "")
+        for edge in graph_data.get("edges", []):
+            d = edge.get("data", {})
+            src = node_lookup.get(d.get("source", ""), "")
+            tgt = node_lookup.get(d.get("target", ""), "")
+            if src:
+                edge_counts[src] = edge_counts.get(src, 0) + 1
+            if tgt:
+                edge_counts[tgt] = edge_counts.get(tgt, 0) + 1
+
+        # Attach connection count and size tier to each entity.
+        max_count = max((edge_counts.get(e.get("name", ""), 0) for e in entities), default=1) or 1
+        for ent in entities:
+            count = edge_counts.get(ent.get("name", ""), 0)
+            ent["connection_count"] = count
+            # Size tiers: sm (0-20%), md (20-50%), lg (50-80%), xl (80%+)
+            ratio = count / max_count if max_count else 0
+            if ratio >= 0.8:
+                ent["size"] = "xl"
+            elif ratio >= 0.5:
+                ent["size"] = "lg"
+            elif ratio >= 0.2:
+                ent["size"] = "md"
+            else:
+                ent["size"] = "sm"
+
+        # Sort entities by connection count descending.
+        entities.sort(key=lambda e: e.get("connection_count", 0), reverse=True)
+
+        return templates.TemplateResponse(
+            request,
+            "explore.html",
+            _ctx(
+                topic=topic,
+                dossier=dossier,
+                connections=connections,
+                entities=entities,
+                entity_type=entity_type,
+            ),
+        )
+
     @app.get("/graph", response_class=HTMLResponse)
     async def graph_page(request: Request):
         session = _require_auth(request)
         if session is None:
             return RedirectResponse("/login", status_code=302)
-        return templates.TemplateResponse(request, "graph.html")
+
+        all_docs = await mcp_client.list_objects(limit=500)
+        project_names = sorted({d.get("project", "") for d in all_docs} - {""})
+
+        return templates.TemplateResponse(
+            request, "graph.html", _ctx(project_names=project_names)
+        )
 
     @app.get("/entities", response_class=HTMLResponse)
     async def entities_page(request: Request, entity_type: str = ""):
@@ -301,17 +443,119 @@ async def query_trail(request: Request):
         return templates.TemplateResponse(request, "trail.html", _ctx(logs=logs))
 
     @app.get("/settings", response_class=HTMLResponse)
-    async def settings_page(request: Request):
+    async def settings_page(request: Request, msg: str = "", msg_type: str = "info"):
         session = _require_auth(request)
         if session is None:
             return RedirectResponse("/login", status_code=302)
 
         return templates.TemplateResponse(
             request,
             "settings.html",
-            _ctx(config=config, weights={}),
+            _ctx(config=config, weights={}, msg=msg, msg_type=msg_type),
         )
 
+    @app.post("/settings/import")
+    async def settings_import(request: Request, vault_path: str = Form(...)):
+        """Import an Obsidian vault into Cortex."""
+        session = _require_auth(request)
+        if session is None:
+            return RedirectResponse("/login", status_code=302)
+
+        from pathlib import Path as _Path
+
+        vault = _Path(vault_path).expanduser().resolve()
+        if not vault.is_dir():
+            return RedirectResponse(
+                f"/settings?msg=Directory not found: {vault_path}&msg_type=danger",
+                status_code=302,
+            )
+
+        try:
+            from cortex.db.store import Store
+            from cortex.pipeline.importer import ObsidianImporter
+
+            store = Store(config.data_dir)
+            importer = ObsidianImporter(store, pipeline=None)
+            result = importer.run(vault)
+            store.close()
+
+            imported = result.get("imported", 0)
+            skipped = result.get("skipped", 0)
+            failed = result.get("failed", 0)
+            wiki = result.get("wiki_links_created", 0)
+            msg = (
+                f"Import complete: {imported} imported, {skipped} skipped, "
+                f"{failed} failed, {wiki} wiki-links"
+            )
+            return RedirectResponse(
+                f"/settings?msg={msg}&msg_type=info", status_code=302,
+            )
+        except Exception as e:
+            return RedirectResponse(
+                f"/settings?msg=Import error: {e}&msg_type=danger",
+                status_code=302,
+            )
+
+    @app.post("/settings/export")
+    async def settings_export(request: Request, export_path: str = Form(...)):
+        """Export all Cortex documents as an Obsidian-compatible vault."""
+        session = _require_auth(request)
+        if session is None:
+            return RedirectResponse("/login", status_code=302)
+
+        from pathlib import Path as _Path
+
+        target = _Path(export_path).expanduser().resolve()
+        try:
+            target.mkdir(parents=True, exist_ok=True)
+        except OSError as e:
+            return RedirectResponse(
+                f"/settings?msg=Cannot create directory: {e}&msg_type=danger",
+                status_code=302,
+            )
+
+        try:
+            all_docs = await mcp_client.list_objects(limit=5000)
+            exported = 0
+            for doc in all_docs:
+                obj_id = doc.get("id", "")
+                full = await mcp_client.read(obj_id)
+                if isinstance(full, str) or full is None:
+                    continue
+
+                title = full.get("title", obj_id[:8])
+                # Sanitize filename.
+                safe_name = "".join(
+                    c if c.isalnum() or c in " -_" else "_" for c in title
+                ).strip()[:100]
+                if not safe_name:
+                    safe_name = obj_id[:8]
+
+                # Build markdown with YAML frontmatter.
+                md = "---\n"
+                md += f"id: {obj_id}\n"
+                md += f"type: {full.get('type', '')}\n"
+                md += f"project: {full.get('project', '')}\n"
+                md += f"tags: {full.get('tags', '')}\n"
+                md += f"created: {full.get('created_at', '')}\n"
+                md += "---\n\n"
+                md += f"# {title}\n\n"
+                md += full.get("content", "")
+
+                filepath = target / f"{safe_name}.md"
+                filepath.write_text(md, encoding="utf-8")
+                exported += 1
+
+            msg = f"Exported {exported} documents to {target}"
+            return RedirectResponse(
+                f"/settings?msg={msg}&msg_type=info", status_code=302,
+            )
+        except Exception as e:
+            return RedirectResponse(
+                f"/settings?msg=Export error: {e}&msg_type=danger",
+                status_code=302,
+            )
+
     # ─── API Endpoints (for HTMX/Cytoscape) ───────────────────────
 
     @app.get("/api/graph-data")