bluelens-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,3875 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join5, dirname } from "path";
+import { fileURLToPath } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/workspaces.ts
+import { z } from "zod";
+
+// src/storage.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function getDataDir() {
+  return process.env.BLUELENS_DATA_DIR ?? join(homedir(), ".bluelens");
+}
+function dbPath() {
+  return join(getDataDir(), "db.json");
+}
+function codegraphsDir() {
+  return join(getDataDir(), "codegraphs");
+}
+function codegraphIndexPath() {
+  return join(codegraphsDir(), "index.json");
+}
+function codegraphFilePath(id) {
+  return join(codegraphsDir(), `${id}.json`);
+}
+async function ensureDir(path) {
+  if (!existsSync(path)) await mkdir(path, { recursive: true });
+}
+async function readDB() {
+  await ensureDir(getDataDir());
+  if (!existsSync(dbPath())) return { version: 1, workspaces: [], folders: [], diagrams: [] };
+  return JSON.parse(await readFile(dbPath(), "utf-8"));
+}
+async function writeDB(db) {
+  await ensureDir(getDataDir());
+  await writeFile(dbPath(), JSON.stringify(db, null, 2), "utf-8");
+}
+async function readCodeGraphIndex() {
+  await ensureDir(codegraphsDir());
+  if (!existsSync(codegraphIndexPath())) return [];
+  return JSON.parse(await readFile(codegraphIndexPath(), "utf-8"));
+}
+async function writeCodeGraphIndex(index) {
+  await ensureDir(codegraphsDir());
+  await writeFile(codegraphIndexPath(), JSON.stringify(index, null, 2), "utf-8");
+}
+function uid() {
+  return Math.random().toString(36).slice(2, 11);
+}
+var storage = {
+  async listWorkspaces() {
+    return (await readDB()).workspaces;
+  },
+  async createWorkspace(name) {
+    const db = await readDB();
+    const workspace = { id: uid(), name, createdAt: Date.now() };
+    db.workspaces.push(workspace);
+    await writeDB(db);
+    return workspace;
+  },
+  async deleteWorkspace(id) {
+    const db = await readDB();
+    db.workspaces = db.workspaces.filter((w) => w.id !== id);
+    db.folders = db.folders.filter((f) => f.workspaceId !== id);
+    db.diagrams = db.diagrams.filter((d) => d.workspaceId !== id);
+    await writeDB(db);
+  },
+  async listFolders(workspaceId) {
+    return (await readDB()).folders.filter((f) => f.workspaceId === workspaceId);
+  },
+  async createFolder(workspaceId, name, parentId = null) {
+    const db = await readDB();
+    const folder = { id: uid(), name, workspaceId, parentId };
+    db.folders.push(folder);
+    await writeDB(db);
+    return folder;
+  },
+  async deleteFolder(id) {
+    const db = await readDB();
+    db.folders = db.folders.filter((f) => f.id !== id);
+    db.diagrams = db.diagrams.map((d) => d.folderId === id ? { ...d, folderId: null } : d);
+    await writeDB(db);
+  },
+  async listDiagrams(workspaceId, folderId) {
+    const db = await readDB();
+    return db.diagrams.filter((d) => {
+      if (d.workspaceId !== workspaceId) return false;
+      if (folderId !== void 0) return d.folderId === folderId;
+      return true;
+    });
+  },
+  async getDiagram(id) {
+    return (await readDB()).diagrams.find((d) => d.id === id) ?? null;
+  },
+  async createDiagram(workspaceId, name, code, folderId = null, description) {
+    const db = await readDB();
+    const diagram = {
+      id: uid(),
+      name,
+      code,
+      description,
+      lastModified: Date.now(),
+      workspaceId,
+      folderId,
+      nodeLinks: []
+    };
+    db.diagrams.push(diagram);
+    await writeDB(db);
+    return diagram;
+  },
+  async updateDiagram(id, updates) {
+    const db = await readDB();
+    const idx = db.diagrams.findIndex((d) => d.id === id);
+    if (idx === -1) return null;
+    db.diagrams[idx] = { ...db.diagrams[idx], ...updates, lastModified: Date.now() };
+    await writeDB(db);
+    return db.diagrams[idx];
+  },
+  async deleteDiagram(id) {
+    const db = await readDB();
+    db.diagrams = db.diagrams.filter((d) => d.id !== id);
+    await writeDB(db);
+  },
+  async listCodeGraphs(workspaceId) {
+    const index = await readCodeGraphIndex();
+    return workspaceId ? index.filter((e) => e.workspaceId === workspaceId) : index;
+  },
+  async getCodeGraph(id) {
+    const path = codegraphFilePath(id);
+    if (!existsSync(path)) return null;
+    return JSON.parse(await readFile(path, "utf-8"));
+  },
+  async saveCodeGraph(graph) {
+    await ensureDir(codegraphsDir());
+    await writeFile(codegraphFilePath(graph.id), JSON.stringify(graph, null, 2), "utf-8");
+    const index = await readCodeGraphIndex();
+    const entry = {
+      id: graph.id,
+      name: graph.name,
+      repoId: graph.repoId,
+      workspaceId: graph.workspaceId,
+      createdAt: graph.createdAt,
+      nodeCount: Object.keys(graph.nodes).length,
+      relationCount: graph.relations.length
+    };
+    const existing = index.findIndex((e) => e.id === graph.id);
+    if (existing >= 0) index[existing] = entry;
+    else index.push(entry);
+    await writeCodeGraphIndex(index);
+  },
+  async deleteCodeGraph(id) {
+    const { unlink } = await import("fs/promises");
+    const path = codegraphFilePath(id);
+    if (existsSync(path)) await unlink(path);
+    await writeCodeGraphIndex((await readCodeGraphIndex()).filter((e) => e.id !== id));
+  }
+};
+
+// src/tools/workspaces.ts
+function registerWorkspaceTools(server2) {
+  server2.tool(
+    "list_workspaces",
+    "List all Bluelens workspaces",
+    {},
+    async () => {
+      const workspaces = await storage.listWorkspaces();
+      return {
+        content: [{
+          type: "text",
+          text: workspaces.length === 0 ? "No workspaces found. Use create_workspace to create one." : JSON.stringify(workspaces, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "create_workspace",
+    "Create a new Bluelens workspace",
+    { name: z.string().min(1).describe("Workspace name") },
+    async ({ name }) => {
+      const workspace = await storage.createWorkspace(name);
+      return {
+        content: [{ type: "text", text: JSON.stringify(workspace, null, 2) }]
+      };
+    }
+  );
+  server2.tool(
+    "delete_workspace",
+    "Delete a workspace and all its folders and diagrams",
+    { workspace_id: z.string().describe("Workspace ID to delete") },
+    async ({ workspace_id }) => {
+      const workspaces = await storage.listWorkspaces();
+      if (!workspaces.find((w) => w.id === workspace_id)) {
+        return { content: [{ type: "text", text: `Workspace "${workspace_id}" not found` }], isError: true };
+      }
+      await storage.deleteWorkspace(workspace_id);
+      return { content: [{ type: "text", text: `Workspace "${workspace_id}" deleted` }] };
+    }
+  );
+  server2.tool(
+    "list_folders",
+    "List all folders in a workspace",
+    { workspace_id: z.string().describe("Workspace ID") },
+    async ({ workspace_id }) => {
+      const folders = await storage.listFolders(workspace_id);
+      return {
+        content: [{
+          type: "text",
+          text: folders.length === 0 ? "No folders in this workspace." : JSON.stringify(folders, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "create_folder",
+    "Create a folder inside a workspace",
+    {
+      workspace_id: z.string().describe("Workspace ID"),
+      name: z.string().min(1).describe("Folder name"),
+      parent_id: z.string().optional().describe("Parent folder ID (omit for root-level folder)")
+    },
+    async ({ workspace_id, name, parent_id }) => {
+      const folder = await storage.createFolder(workspace_id, name, parent_id ?? null);
+      return { content: [{ type: "text", text: JSON.stringify(folder, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "delete_folder",
+    "Delete a folder (diagrams inside are moved to workspace root)",
+    { folder_id: z.string().describe("Folder ID to delete") },
+    async ({ folder_id }) => {
+      await storage.deleteFolder(folder_id);
+      return { content: [{ type: "text", text: `Folder "${folder_id}" deleted` }] };
+    }
+  );
+}
+
+// src/tools/diagrams.ts
+import { z as z2 } from "zod";
+import { writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_DIAGRAM = `flowchart TD
+    Start([Start]) --> Decision{Decision}
+    Decision -->|Yes| Action[Action]
+    Decision -->|No| End([End])
+    Action --> End`;
+function registerDiagramTools(server2) {
+  server2.tool(
+    "list_diagrams",
+    "List diagrams in a workspace, optionally filtered by folder",
+    {
+      workspace_id: z2.string().describe("Workspace ID"),
+      folder_id: z2.string().optional().describe("Filter by folder ID. Omit to list all diagrams in the workspace")
+    },
+    async ({ workspace_id, folder_id }) => {
+      const diagrams = await storage.listDiagrams(workspace_id, folder_id);
+      if (diagrams.length === 0) {
+        return { content: [{ type: "text", text: "No diagrams found." }] };
+      }
+      const summary = diagrams.map((d) => ({
+        id: d.id,
+        name: d.name,
+        description: d.description,
+        folderId: d.folderId,
+        lastModified: new Date(d.lastModified).toISOString(),
+        linesOfCode: d.code.split("\n").length,
+        nodeLinks: d.nodeLinks.length
+      }));
+      return { content: [{ type: "text", text: JSON.stringify(summary, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "get_diagram",
+    "Get a diagram with its full Mermaid code",
+    { diagram_id: z2.string().describe("Diagram ID") },
+    async ({ diagram_id }) => {
+      const diagram = await storage.getDiagram(diagram_id);
+      if (!diagram) {
+        return { content: [{ type: "text", text: `Diagram "${diagram_id}" not found` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(diagram, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "create_diagram",
+    "Create a new Mermaid diagram in a workspace",
+    {
+      workspace_id: z2.string().describe("Workspace ID"),
+      name: z2.string().min(1).describe("Diagram name"),
+      code: z2.string().optional().describe("Mermaid diagram code. Defaults to a flowchart template if omitted"),
+      folder_id: z2.string().optional().describe("Folder ID to place the diagram in"),
+      description: z2.string().optional().describe("Optional description")
+    },
+    async ({ workspace_id, name, code, folder_id, description }) => {
+      const diagram = await storage.createDiagram(
+        workspace_id,
+        name,
+        code ?? DEFAULT_DIAGRAM,
+        folder_id ?? null,
+        description
+      );
+      return { content: [{ type: "text", text: JSON.stringify(diagram, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "update_diagram",
+    "Update a diagram's name, code, or description",
+    {
+      diagram_id: z2.string().describe("Diagram ID"),
+      name: z2.string().optional().describe("New name"),
+      code: z2.string().optional().describe("New Mermaid code"),
+      description: z2.string().optional().describe("New description"),
+      folder_id: z2.string().nullable().optional().describe("Move to folder (null to move to workspace root)")
+    },
+    async ({ diagram_id, name, code, description, folder_id }) => {
+      const updates = {};
+      if (name !== void 0) updates.name = name;
+      if (code !== void 0) updates.code = code;
+      if (description !== void 0) updates.description = description;
+      if (folder_id !== void 0) updates.folderId = folder_id;
+      const diagram = await storage.updateDiagram(diagram_id, updates);
+      if (!diagram) {
+        return { content: [{ type: "text", text: `Diagram "${diagram_id}" not found` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(diagram, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "delete_diagram",
+    "Delete a diagram permanently",
+    { diagram_id: z2.string().describe("Diagram ID to delete") },
+    async ({ diagram_id }) => {
+      const existing = await storage.getDiagram(diagram_id);
+      if (!existing) {
+        return { content: [{ type: "text", text: `Diagram "${diagram_id}" not found` }], isError: true };
+      }
+      await storage.deleteDiagram(diagram_id);
+      return { content: [{ type: "text", text: `Diagram "${diagram_id}" ("${existing.name}") deleted` }] };
+    }
+  );
+  server2.tool(
+    "search_diagrams",
+    "Search diagrams by name or content across all workspaces",
+    {
+      query: z2.string().min(1).describe("Search query (matches diagram name, description, or Mermaid code)"),
+      workspace_id: z2.string().optional().describe("Limit search to this workspace")
+    },
+    async ({ query, workspace_id }) => {
+      const workspaces = workspace_id ? [{ id: workspace_id }] : await storage.listWorkspaces();
+      const results = [];
+      const q = query.toLowerCase();
+      for (const ws of workspaces) {
+        const diagrams = await storage.listDiagrams(ws.id);
+        for (const d of diagrams) {
+          const matchIn = [];
+          if (d.name.toLowerCase().includes(q)) matchIn.push("name");
+          if (d.description?.toLowerCase().includes(q)) matchIn.push("description");
+          if (d.code.toLowerCase().includes(q)) matchIn.push("code");
+          if (matchIn.length > 0) {
+            results.push({ id: d.id, name: d.name, workspaceId: d.workspaceId, matchIn: matchIn.join(", ") });
+          }
+        }
+      }
+      if (results.length === 0) {
+        return { content: [{ type: "text", text: `No diagrams found matching "${query}"` }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "add_node_link",
+    'Link a Mermaid node in a diagram to another diagram (enables drill-down navigation in the Bluelens UI). node_id must match the exact node identifier used in the Mermaid code (e.g. "UserService", "A", "DB").',
+    {
+      diagram_id: z2.string().describe("Diagram containing the node"),
+      node_id: z2.string().describe("Mermaid node identifier as written in the diagram code (case-sensitive)"),
+      target_diagram_id: z2.string().describe("Diagram to navigate to when the node is clicked"),
+      label: z2.string().optional().describe("Optional label for the link")
+    },
+    async ({ diagram_id, node_id, target_diagram_id, label }) => {
+      const diagram = await storage.getDiagram(diagram_id);
+      if (!diagram) return { content: [{ type: "text", text: `Diagram "${diagram_id}" not found` }], isError: true };
+      const target = await storage.getDiagram(target_diagram_id);
+      if (!target) return { content: [{ type: "text", text: `Target diagram "${target_diagram_id}" not found` }], isError: true };
+      const existing = diagram.nodeLinks.findIndex((l) => l.nodeId === node_id);
+      const updatedLinks = existing !== -1 ? diagram.nodeLinks.map((l, i) => i === existing ? { nodeId: node_id, targetDiagramId: target_diagram_id, label } : l) : [...diagram.nodeLinks, { nodeId: node_id, targetDiagramId: target_diagram_id, label }];
+      const updated = await storage.updateDiagram(diagram_id, { nodeLinks: updatedLinks });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            message: existing !== -1 ? `Node link updated` : `Node link added`,
+            nodeId: node_id,
+            targetDiagram: { id: target.id, name: target.name },
+            totalLinks: updated.nodeLinks.length
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "remove_node_link",
+    "Remove the drill-down link from a Mermaid node in a diagram.",
+    {
+      diagram_id: z2.string().describe("Diagram containing the node"),
+      node_id: z2.string().describe("Mermaid node identifier whose link should be removed")
+    },
+    async ({ diagram_id, node_id }) => {
+      const diagram = await storage.getDiagram(diagram_id);
+      if (!diagram) return { content: [{ type: "text", text: `Diagram "${diagram_id}" not found` }], isError: true };
+      const before = diagram.nodeLinks.length;
+      const updatedLinks = diagram.nodeLinks.filter((l) => l.nodeId !== node_id);
+      if (updatedLinks.length === before) {
+        return { content: [{ type: "text", text: `No link found for node "${node_id}" in diagram "${diagram_id}"` }], isError: true };
+      }
+      await storage.updateDiagram(diagram_id, { nodeLinks: updatedLinks });
+      return { content: [{ type: "text", text: `Link removed from node "${node_id}"` }] };
+    }
+  );
+  server2.tool(
+    "export_for_bluelens",
+    "Export MCP data as a BlueprintExport JSON file importable directly into the Bluelens web app via the Sidebar import button. Saves the file to disk and returns the path.",
+    {
+      workspace_id: z2.string().optional().describe("Export only this workspace (omit to export everything)"),
+      output_path: z2.string().optional().describe("Where to save the file (default: ~/bluelens-export.bluelens)")
+    },
+    async ({ workspace_id, output_path }) => {
+      const allWorkspaces = await storage.listWorkspaces();
+      const targetWorkspaces = workspace_id ? allWorkspaces.filter((w) => w.id === workspace_id) : allWorkspaces;
+      if (workspace_id && targetWorkspaces.length === 0) {
+        return { content: [{ type: "text", text: `Workspace "${workspace_id}" not found` }], isError: true };
+      }
+      const folders = (await Promise.all(targetWorkspaces.map((w) => storage.listFolders(w.id)))).flat();
+      const diagrams = (await Promise.all(targetWorkspaces.map((w) => storage.listDiagrams(w.id)))).flat();
+      const graphIndex = (await Promise.all(targetWorkspaces.map((w) => storage.listCodeGraphs(w.id)))).flat();
+      const codeGraphs = (await Promise.all(graphIndex.map((e) => storage.getCodeGraph(e.id)))).filter((g) => g !== null);
+      const blueprint = {
+        version: 1,
+        exportType: workspace_id ? "workspace" : "all",
+        exportDate: (/* @__PURE__ */ new Date()).toISOString(),
+        workspaces: targetWorkspaces,
+        folders,
+        diagrams,
+        codeGraphs
+      };
+      const dest = output_path ?? join2(homedir2(), "bluelens-export.bluelens");
+      await writeFile2(dest, JSON.stringify(blueprint, null, 2), "utf-8");
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            message: "Export ready. Open Bluelens \u2192 Sidebar \u2192 Import and select this file.",
+            file: dest,
+            workspaces: targetWorkspaces.length,
+            folders: folders.length,
+            diagrams: diagrams.length,
+            codeGraphs: codeGraphs.length
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/codegraph.ts
+import { z as z3 } from "zod";
+import { existsSync as existsSync2 } from "fs";
+
+// src/services/nodeFs.ts
+import { readdir, readFile as readFile2 } from "fs/promises";
+import { join as join3 } from "path";
+
+// ../services/IFileSystemProvider.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".rs",
+  ".go",
+  ".java",
+  ".kt",
+  ".rb",
+  ".php",
+  ".cs",
+  ".cpp",
+  ".cc",
+  ".c",
+  ".h",
+  ".hpp",
+  ".swift",
+  ".dart"
+]);
+var EXTENSION_LANGUAGE_MAP = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".rs": "rust",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".rb": "ruby",
+  ".php": "php",
+  ".cs": "csharp",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".h": "cpp",
+  ".hpp": "cpp",
+  ".c": "c",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".json": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "toml",
+  ".xml": "xml",
+  ".html": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sql": "sql",
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".md": "markdown",
+  ".dockerfile": "dockerfile"
+};
+function getLanguage(filename) {
+  const ext = filename.substring(filename.lastIndexOf(".")).toLowerCase();
+  return EXTENSION_LANGUAGE_MAP[ext] || "plaintext";
+}
+
+// src/services/nodeFs.ts
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".svn",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  "venv",
+  ".venv",
+  "env",
+  "target",
+  "vendor",
+  ".cargo",
+  "coverage",
+  ".nyc_output",
+  ".turbo"
+]);
+var NodeFileSystemProvider = class {
+  constructor(rootPath) {
+    this.rootPath = rootPath;
+  }
+  rootPath;
+  async listDirectory(relPath) {
+    const absPath = relPath ? join3(this.rootPath, relPath) : this.rootPath;
+    const entries = await readdir(absPath, { withFileTypes: true });
+    return entries.filter((e) => !e.name.startsWith(".") || e.name === ".env").filter((e) => !(e.isDirectory() && IGNORED_DIRS.has(e.name))).map((e) => ({
+      name: e.name,
+      kind: e.isDirectory() ? "directory" : "file",
+      path: relPath ? `${relPath}/${e.name}` : e.name
+    }));
+  }
+  async readFile(relPath) {
+    return readFile2(join3(this.rootPath, relPath), "utf-8");
+  }
+};
+
+// ../services/codeParserService.ts
+var TS_JS_PATTERNS = [
+  { regex: /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/gm, kind: "class" },
+  { regex: /^(?:export\s+)?interface\s+(\w+)/gm, kind: "interface" },
+  { regex: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/gm, kind: "function" },
+  { regex: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/gm, kind: "function" },
+  { regex: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[a-zA-Z_]\w*)\s*=>/gm, kind: "function" }
+];
+var PYTHON_PATTERNS = [
+  { regex: /^class\s+(\w+)/gm, kind: "class" },
+  { regex: /^(?:async\s+)?def\s+(\w+)/gm, kind: "function" }
+];
+var CPP_PATTERNS = [
+  { regex: /^(?:template\s*<[^>]*>\s*)?(?:class|struct)\s+(\w+)/gm, kind: "class" },
+  // Function definitions (ending with `{`)
+  { regex: /^(?!\s*(?:if|for|while|switch|else|do|return|throw|delete|new)\b)[\w:*&<>~\t ]+?\b(\w+)\s*\([^)]*\)\s*(?:const\s*)?(?:noexcept\s*)?(?:override\s*)?\s*\{/gm, kind: "function" },
+  // Function declarations in headers (ending with `;`)
+  { regex: /^(?:(?:virtual|static|inline|explicit|constexpr)\s+)*(?:[\w:*&<>~]+\s+)+(\w+)\s*\([^)]*\)\s*(?:const\s*)?(?:noexcept\s*)?(?:= *0\s*)?\s*;/gm, kind: "function" }
+];
+var C_PATTERNS = [
+  { regex: /^(?:struct|typedef\s+struct)\s+(\w+)/gm, kind: "class" },
+  { regex: /^(?!\s*(?:if|for|while|switch|else|do|return)\b)[\w*\t ]+?\b(\w+)\s*\([^)]*\)\s*\{/gm, kind: "function" }
+];
+function getPatterns(language) {
+  switch (language) {
+    case "typescript":
+    case "javascript":
+      return TS_JS_PATTERNS;
+    case "python":
+      return PYTHON_PATTERNS;
+    case "cpp":
+      return CPP_PATTERNS;
+    case "c":
+      return C_PATTERNS;
+    default:
+      return [];
+  }
+}
+function estimateEnd(lines, startLine) {
+  const startIndent = lines[startLine]?.search(/\S/) ?? 0;
+  for (let i = startLine + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    const indent = line.search(/\S/);
+    if (indent <= startIndent && i > startLine + 1) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+function isExternalImport(source) {
+  return !source.startsWith(".") && !source.startsWith("/") && !source.startsWith("@/");
+}
+function extractTSJSImports(code) {
+  const imports = [];
+  const defaultRe = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+  let m;
+  while ((m = defaultRe.exec(code)) !== null) {
+    imports.push({ name: m[1], source: m[2], isDefault: true, isExternal: isExternalImport(m[2]) });
+  }
+  const namedRe = /import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/g;
+  while ((m = namedRe.exec(code)) !== null) {
+    const names = m[1].split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+    for (const name of names) {
+      imports.push({ name, source: m[2], isDefault: false, isExternal: isExternalImport(m[2]) });
+    }
+  }
+  const starRe = /import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+  while ((m = starRe.exec(code)) !== null) {
+    imports.push({ name: m[1], source: m[2], isDefault: true, isExternal: isExternalImport(m[2]) });
+  }
+  const requireRe = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((m = requireRe.exec(code)) !== null) {
+    imports.push({ name: m[1].split("/").pop() || m[1], source: m[1], isDefault: true, isExternal: isExternalImport(m[1]) });
+  }
+  return imports;
+}
+function extractPythonImports(code) {
+  const imports = [];
+  let m;
+  const fromRe = /^from\s+([\w.]+)\s+import\s+(.+)$/gm;
+  while ((m = fromRe.exec(code)) !== null) {
+    const source = m[1];
+    const names = m[2].split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+    for (const name of names) {
+      imports.push({ name, source, isDefault: false, isExternal: !source.startsWith(".") });
+    }
+  }
+  const importRe = /^import\s+([\w.]+(?:\s*,\s*[\w.]+)*)/gm;
+  while ((m = importRe.exec(code)) !== null) {
+    const names = m[1].split(",").map((s) => s.trim().split(/\s+as\s+/)[0].trim()).filter(Boolean);
+    for (const name of names) {
+      imports.push({ name: name.split(".").pop() || name, source: name, isDefault: true, isExternal: !name.startsWith(".") });
+    }
+  }
+  return imports;
+}
+function extractCppImports(code) {
+  const imports = [];
+  let m;
+  const sysRe = /^#include\s*<([^>]+)>/gm;
+  while ((m = sysRe.exec(code)) !== null) {
+    const name = m[1].split("/").pop()?.replace(/\.\w+$/, "") || m[1];
+    imports.push({ name, source: m[1], isDefault: true, isExternal: true });
+  }
+  const localRe = /^#include\s*"([^"]+)"/gm;
+  while ((m = localRe.exec(code)) !== null) {
+    const name = m[1].split("/").pop()?.replace(/\.\w+$/, "") || m[1];
+    imports.push({ name, source: m[1], isDefault: true, isExternal: false });
+  }
+  return imports;
+}
+function extractTSJSClassHierarchy(code) {
+  const results = [];
+  const re = /^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w\s,]+))?\s*\{/gm;
+  let m;
+  const lines = code.split("\n");
+  while ((m = re.exec(code)) !== null) {
+    const charsBefore = code.substring(0, m.index);
+    const lineStart = charsBefore.split("\n").length;
+    const entry = {
+      name: m[1],
+      lineStart,
+      implements: []
+    };
+    if (m[2]) entry.extends = m[2];
+    if (m[3]) entry.implements = m[3].split(",").map((s) => s.trim()).filter(Boolean);
+    results.push(entry);
+  }
+  return results;
+}
+function extractPythonClassHierarchy(code) {
+  const results = [];
+  const re = /^class\s+(\w+)(?:\(([^)]*)\))?\s*:/gm;
+  let m;
+  while ((m = re.exec(code)) !== null) {
+    const charsBefore = code.substring(0, m.index);
+    const lineStart = charsBefore.split("\n").length;
+    const entry = {
+      name: m[1],
+      lineStart,
+      implements: []
+    };
+    if (m[2]) {
+      const bases = m[2].split(",").map((s) => s.trim()).filter((s) => s && s !== "object");
+      if (bases.length > 0) entry.extends = bases[0];
+      if (bases.length > 1) entry.implements = bases.slice(1);
+    }
+    results.push(entry);
+  }
+  return results;
+}
+function extractCppClassHierarchy(code) {
+  const results = [];
+  const re = /^(?:class|struct)\s+(\w+)\s*(?:final\s*)?:\s*([\w\s,]+?)(?:\s*\{|$)/gm;
+  let m;
+  while ((m = re.exec(code)) !== null) {
+    const charsBefore = code.substring(0, m.index);
+    const lineStart = charsBefore.split("\n").length;
+    const bases = m[2].split(",").map((s) => s.trim().replace(/^(?:public|private|protected)\s+/, "").trim()).filter(Boolean);
+    const entry = { name: m[1], lineStart, implements: [] };
+    if (bases.length > 0) entry.extends = bases[0];
+    if (bases.length > 1) entry.implements = bases.slice(1);
+    results.push(entry);
+  }
+  return results;
+}
+function extractCallRefsFromCode(code, language, knownSymbols) {
+  if (knownSymbols.length === 0) return [];
+  const results = [];
+  const lines = code.split("\n");
+  const symbolSet = new Set(knownSymbols);
+  const symbolPattern = new RegExp(`\\b(${knownSymbols.map((s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\s*\\(`, "g");
+  let currentScope = null;
+  const scopeRe = language === "python" ? /^(?:class|(?:async\s+)?def)\s+(\w+)/ : language === "cpp" || language === "c" ? /^(?!\s*(?:if|for|while|switch|else|do|return|throw)\b)(?:[\w:*&<>~\t ]+?\b)(\w+)\s*\([^)]*\)\s*(?:const\s*)?(?:noexcept\s*)?\s*\{/ : /^(?:export\s+)?(?:(?:async\s+)?function\s+(\w+)|(?:const|let|var)\s+(\w+)\s*=|(?:abstract\s+)?class\s+(\w+))/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const scopeMatch = scopeRe.exec(line);
+    if (scopeMatch) {
+      currentScope = scopeMatch[1] || scopeMatch[2] || scopeMatch[3] || null;
+    }
+    if (!currentScope) continue;
+    let m;
+    symbolPattern.lastIndex = 0;
+    while ((m = symbolPattern.exec(line)) !== null) {
+      const callee = m[1];
+      if (callee !== currentScope && symbolSet.has(callee)) {
+        results.push({ caller: currentScope, callee });
+      }
+    }
+  }
+  return results;
+}
+async function computeContentHash(content) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(content);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var codeParserService = {
+  extractImports(code, language) {
+    switch (language) {
+      case "typescript":
+      case "javascript":
+        return extractTSJSImports(code);
+      case "python":
+        return extractPythonImports(code);
+      case "cpp":
+      case "c":
+        return extractCppImports(code);
+      default:
+        return [];
+    }
+  },
+  extractExports(code, language) {
+    const exports = [];
+    let m;
+    if (language === "typescript" || language === "javascript") {
+      const namedRe = /^export\s+(?:default\s+)?(?:const|let|var|function|class|interface|type|enum|abstract\s+class)\s+(\w+)/gm;
+      while ((m = namedRe.exec(code)) !== null) {
+        exports.push(m[1]);
+      }
+      const defaultRe = /^export\s+default\s+(\w+)\s*;/gm;
+      while ((m = defaultRe.exec(code)) !== null) {
+        if (!["function", "class", "const", "let", "var", "interface", "type", "enum", "abstract"].includes(m[1])) {
+          exports.push(m[1]);
+        }
+      }
+      const braceRe = /^export\s*\{([^}]+)\}/gm;
+      while ((m = braceRe.exec(code)) !== null) {
+        const names = m[1].split(",").map((s) => {
+          const parts = s.trim().split(/\s+as\s+/);
+          return (parts[1] || parts[0]).trim();
+        }).filter(Boolean);
+        exports.push(...names);
+      }
+    } else if (language === "python") {
+      const allRe = /__all__\s*=\s*\[([^\]]+)\]/;
+      const allMatch = allRe.exec(code);
+      if (allMatch) {
+        const names = allMatch[1].match(/['"](\w+)['"]/g);
+        if (names) {
+          exports.push(...names.map((n) => n.replace(/['"]/g, "")));
+        }
+      }
+    } else if (language === "cpp" || language === "c") {
+      const declRe = /^(?:(?:extern|static|inline)\s+)*(?:[\w:*&<>~]+\s+)+(\w+)\s*\([^)]*\)\s*(?:const\s*)?\s*;/gm;
+      while ((m = declRe.exec(code)) !== null) {
+        const name = m[1];
+        if (!["if", "for", "while", "switch", "return", "throw", "delete", "new"].includes(name)) {
+          exports.push(name);
+        }
+      }
+    }
+    return exports;
+  },
+  extractSymbols(code, language) {
+    const patterns = getPatterns(language);
+    if (patterns.length === 0) return [];
+    const lines = code.split("\n");
+    const symbols = [];
+    for (const { regex, kind } of patterns) {
+      regex.lastIndex = 0;
+      let match;
+      while ((match = regex.exec(code)) !== null) {
+        const name = match[1];
+        const charsBefore = code.substring(0, match.index);
+        const lineStart = charsBefore.split("\n").length;
+        const lineEnd = estimateEnd(lines, lineStart - 1);
+        symbols.push({ name, kind, lineStart, lineEnd });
+      }
+    }
+    symbols.sort((a, b) => a.lineStart - b.lineStart);
+    return symbols;
+  },
+  extractClassHierarchy(code, language) {
+    switch (language) {
+      case "typescript":
+      case "javascript":
+        return extractTSJSClassHierarchy(code);
+      case "python":
+        return extractPythonClassHierarchy(code);
+      case "cpp":
+      case "c":
+        return extractCppClassHierarchy(code);
+      default:
+        return [];
+    }
+  },
+  extractCallReferences(code, language, knownSymbols) {
+    return extractCallRefsFromCode(code, language, knownSymbols);
+  },
+  computeContentHash
+};
+
+// ../services/codebaseAnalyzerService.ts
+var ENTRY_POINT_NAMES = /* @__PURE__ */ new Set([
+  "index.ts",
+  "index.tsx",
+  "index.js",
+  "index.jsx",
+  "main.ts",
+  "main.tsx",
+  "main.js",
+  "main.jsx",
+  "main.py",
+  "app.ts",
+  "app.tsx",
+  "app.js",
+  "app.jsx",
+  "app.py",
+  "App.ts",
+  "App.tsx",
+  "App.js",
+  "App.jsx",
+  "server.ts",
+  "server.js",
+  "server.py",
+  "mod.rs",
+  "lib.rs",
+  "main.rs",
+  "setup.py",
+  "__main__.py",
+  "main.cpp",
+  "main.cc",
+  "main.c"
+]);
+function matchesGlob(path, pattern) {
+  const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regexStr}$`).test(path);
+}
+function shouldIncludeFile(filePath, config) {
+  if (!config) return true;
+  if (config.includePaths.length > 0) {
+    const included = config.includePaths.some((p) => matchesGlob(filePath, p));
+    if (!included) return false;
+  }
+  if (config.excludePaths.length > 0) {
+    const excluded = config.excludePaths.some((p) => matchesGlob(filePath, p));
+    if (excluded) return false;
+  }
+  return true;
+}
+function isCodeFile(name) {
+  const ext = name.substring(name.lastIndexOf("."));
+  return CODE_EXTENSIONS.has(ext.toLowerCase());
+}
+async function listAllFiles(provider, basePath = "", config) {
+  const entries = await provider.listDirectory(basePath);
+  const files = [];
+  for (const entry of entries) {
+    if (entry.kind === "directory") {
+      const subFiles = await listAllFiles(provider, entry.path, config);
+      files.push(...subFiles);
+    } else if (isCodeFile(entry.name)) {
+      if (shouldIncludeFile(entry.path, config)) {
+        files.push(entry.path);
+      }
+    }
+  }
+  return files;
+}
+function resolveImportPath(importSource, currentFile, allFiles) {
+  if (!importSource.startsWith(".")) return null;
+  const currentDir = currentFile.substring(0, currentFile.lastIndexOf("/"));
+  const parts = importSource.split("/");
+  let resolved = currentDir;
+  for (const part of parts) {
+    if (part === ".") continue;
+    if (part === "..") {
+      resolved = resolved.substring(0, resolved.lastIndexOf("/"));
+    } else {
+      resolved = resolved ? `${resolved}/${part}` : part;
+    }
+  }
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ".py", ""];
+  const indexFiles = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+  for (const ext of extensions) {
+    const candidate = resolved + ext;
+    if (allFiles.includes(candidate)) return candidate;
+  }
+  for (const idx of indexFiles) {
+    const candidate = resolved + idx;
+    if (allFiles.includes(candidate)) return candidate;
+  }
+  return null;
+}
+function getModuleName(filePath) {
+  const parts = filePath.split("/");
+  if (parts.length === 1) return "(root)";
+  return parts[0];
+}
+function groupIntoModules(files, allFilePaths) {
+  const moduleMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const moduleName = getModuleName(file.filePath);
+    if (!moduleMap.has(moduleName)) {
+      moduleMap.set(moduleName, []);
+    }
+    moduleMap.get(moduleName).push(file);
+  }
+  const modules = [];
+  for (const [name, moduleFiles] of moduleMap) {
+    const depSet = /* @__PURE__ */ new Set();
+    for (const file of moduleFiles) {
+      for (const imp of file.imports) {
+        if (imp.isExternal) continue;
+        const resolved = resolveImportPath(imp.source, file.filePath, allFilePaths);
+        if (resolved) {
+          const depModule = getModuleName(resolved);
+          if (depModule !== name) {
+            depSet.add(depModule);
+          }
+        }
+      }
+    }
+    modules.push({
+      name,
+      path: name === "(root)" ? "" : name,
+      files: moduleFiles,
+      dependencies: Array.from(depSet)
+    });
+  }
+  modules.sort((a, b) => {
+    if (a.name === "(root)") return -1;
+    if (b.name === "(root)") return 1;
+    return a.name.localeCompare(b.name);
+  });
+  return modules;
+}
+var codebaseAnalyzerService = {
+  /**
+   * Analyse un codebase complet via un IFileSystemProvider.
+   *
+   * @param provider   Accès aux fichiers — peut être local (LocalFileSystemProvider)
+   *                   ou historique (GitFileSystemProvider) sans modifier cette fonction.
+   * @param scanConfig Filtres include/exclude optionnels.
+   * @param onProgress Callback de progression (filesScanned, totalFiles).
+   */
+  async analyzeCodebase(provider, scanConfig, onProgress) {
+    const allFilePaths = await listAllFiles(provider, "", scanConfig);
+    const analyzedFiles = [];
+    const externalDeps = /* @__PURE__ */ new Set();
+    const entryPoints = [];
+    let totalSymbols = 0;
+    for (let i = 0; i < allFilePaths.length; i++) {
+      const filePath = allFilePaths[i];
+      onProgress?.(i + 1, allFilePaths.length);
+      try {
+        const content = await provider.readFile(filePath);
+        const language = getLanguage(filePath);
+        const symbols = codeParserService.extractSymbols(content, language);
+        const imports = codeParserService.extractImports(content, language);
+        const exportedSymbols = codeParserService.extractExports(content, language);
+        for (const imp of imports) {
+          if (imp.isExternal) {
+            const pkgName = imp.source.startsWith("@") ? imp.source.split("/").slice(0, 2).join("/") : imp.source.split("/")[0];
+            externalDeps.add(pkgName);
+          }
+        }
+        const scannedSymbols = symbols.map((s) => ({
+          name: s.name,
+          kind: s.kind,
+          filePath,
+          lineStart: s.lineStart,
+          lineEnd: s.lineEnd,
+          repoId: ""
+        }));
+        totalSymbols += symbols.length;
+        analyzedFiles.push({
+          filePath,
+          language,
+          symbols: scannedSymbols || [],
+          imports: imports || [],
+          exportedSymbols: exportedSymbols || [],
+          size: content.length
+        });
+        const fileName = filePath.split("/").pop() || "";
+        if (ENTRY_POINT_NAMES.has(fileName)) {
+          entryPoints.push(filePath);
+        }
+      } catch {
+      }
+    }
+    const modules = groupIntoModules(analyzedFiles, allFilePaths);
+    return {
+      modules,
+      externalDeps: Array.from(externalDeps).sort(),
+      entryPoints,
+      totalFiles: analyzedFiles.length,
+      totalSymbols
+    };
+  }
+};
+
+// ../services/codeGraphModelService.ts
+var generateId = () => Math.random().toString(36).substr(2, 9);
+function getDefaultLenses() {
+  const componentLens = {
+    id: "lens-component",
+    name: "Component",
+    type: "component",
+    nodeFilter: {
+      kinds: ["system", "package", "module", "class", "interface", "function", "method", "variable", "field"],
+      minDepth: 0,
+      maxDepth: 3
+    },
+    relationFilter: {
+      types: ["contains", "depends_on", "implements", "inherits"]
+    },
+    styleRules: [
+      { match: { kind: ["system"] }, shape: "rounded", style: "fill:#1e3a5f,stroke:#3b82f6,color:#93c5fd" },
+      { match: { kind: ["package"] }, shape: "rounded", style: "fill:#1e3a2f,stroke:#22c55e,color:#86efac" },
+      { match: { kind: ["module"] }, shape: "default", style: "fill:#2d2d3d,stroke:#8b5cf6,color:#c4b5fd" },
+      { match: { kind: ["class", "interface"] }, shape: "stadium", style: "fill:#3d2d2d,stroke:#f97316,color:#fdba74" }
+    ],
+    layoutHint: "TD"
+  };
+  const flowLens = {
+    id: "lens-flow",
+    name: "Flow",
+    type: "flow",
+    nodeFilter: {
+      kinds: ["package", "module", "class", "function"],
+      minDepth: 1,
+      maxDepth: 3
+    },
+    relationFilter: {
+      types: ["calls", "emits", "subscribes", "depends_on"]
+    },
+    styleRules: [
+      { match: { kind: ["function"] }, shape: "stadium", style: "fill:#1e3a5f,stroke:#3b82f6,color:#93c5fd" },
+      { match: { kind: ["class"] }, shape: "rounded", style: "fill:#3d2d2d,stroke:#f97316,color:#fdba74" }
+    ],
+    layoutHint: "LR"
+  };
+  const domainLens = {
+    id: "lens-domain",
+    name: "Domain",
+    type: "domain",
+    nodeFilter: {
+      minDepth: 0,
+      maxDepth: 4
+    },
+    relationFilter: {},
+    styleRules: [
+      { match: { kind: ["system"] }, shape: "rounded", style: "fill:#1e3a5f,stroke:#60a5fa,color:#93c5fd" }
+    ],
+    layoutHint: "TD"
+  };
+  return [componentLens, flowLens, domainLens];
+}
+function createEmptyGraph(workspaceId, repoId, name) {
+  const lenses = getDefaultLenses();
+  const rootId = generateId();
+  const now = Date.now();
+  const rootNode = {
+    id: rootId,
+    name,
+    kind: "system",
+    depth: 0,
+    parentId: null,
+    children: [],
+    sourceRef: null,
+    tags: [],
+    lensConfig: {},
+    domainProjections: []
+  };
+  return {
+    id: generateId(),
+    name,
+    workspaceId,
+    repoId,
+    createdAt: now,
+    updatedAt: now,
+    nodes: { [rootId]: rootNode },
+    relations: {},
+    domainNodes: {},
+    domainRelations: {},
+    flows: {},
+    lenses,
+    activeLensId: lenses[0].id,
+    syncLock: {},
+    rootNodeId: rootId
+  };
+}
+function addNode(graph, node) {
+  const nodeId = node.id || generateId();
+  const newNode = { ...node, id: nodeId };
+  const nodes = { ...graph.nodes, [nodeId]: newNode };
+  if (newNode.parentId && nodes[newNode.parentId]) {
+    const parent = nodes[newNode.parentId];
+    nodes[newNode.parentId] = {
+      ...parent,
+      children: [...parent.children, nodeId]
+    };
+  }
+  return {
+    graph: { ...graph, nodes, updatedAt: Date.now() },
+    nodeId
+  };
+}
+function removeNode(graph, nodeId) {
+  const node = graph.nodes[nodeId];
+  if (!node) return graph;
+  const toRemove = /* @__PURE__ */ new Set();
+  const collect = (id) => {
+    toRemove.add(id);
+    const n = graph.nodes[id];
+    if (n) n.children.forEach(collect);
+  };
+  collect(nodeId);
+  const nodes = { ...graph.nodes };
+  for (const id of toRemove) {
+    delete nodes[id];
+  }
+  if (node.parentId && nodes[node.parentId]) {
+    const parent = nodes[node.parentId];
+    nodes[node.parentId] = {
+      ...parent,
+      children: parent.children.filter((c) => c !== nodeId)
+    };
+  }
+  const relations = { ...graph.relations };
+  for (const [relId, rel] of Object.entries(relations)) {
+    if (toRemove.has(rel.sourceId) || toRemove.has(rel.targetId)) {
+      delete relations[relId];
+    }
+  }
+  const syncLock = { ...graph.syncLock };
+  for (const id of toRemove) {
+    delete syncLock[id];
+  }
+  return { ...graph, nodes, relations, syncLock, updatedAt: Date.now() };
+}
+function addRelation(graph, sourceId, targetId, type, label) {
+  const relationId = generateId();
+  const lensVisibility = {};
+  for (const lens of graph.lenses) {
+    lensVisibility[lens.id] = true;
+  }
+  const relation = {
+    id: relationId,
+    sourceId,
+    targetId,
+    type,
+    label,
+    lensVisibility
+  };
+  return {
+    graph: {
+      ...graph,
+      relations: { ...graph.relations, [relationId]: relation },
+      updatedAt: Date.now()
+    },
+    relationId
+  };
+}
+function removeRelation(graph, relationId) {
+  const relations = { ...graph.relations };
+  delete relations[relationId];
+  return { ...graph, relations, updatedAt: Date.now() };
+}
+function getChildren(graph, nodeId) {
+  const node = graph.nodes[nodeId];
+  if (!node) return [];
+  return node.children.map((id) => graph.nodes[id]).filter(Boolean);
+}
+function getDescendants(graph, nodeId) {
+  const result = [];
+  const visit = (id) => {
+    const node = graph.nodes[id];
+    if (!node) return;
+    for (const childId of node.children) {
+      const child = graph.nodes[childId];
+      if (child) {
+        result.push(child);
+        visit(childId);
+      }
+    }
+  };
+  visit(nodeId);
+  return result;
+}
+function getAncestors(graph, nodeId) {
+  const result = [];
+  let current = graph.nodes[nodeId];
+  while (current?.parentId) {
+    const parent = graph.nodes[current.parentId];
+    if (!parent) break;
+    result.push(parent);
+    current = parent;
+  }
+  return result;
+}
+function getVisibleNodes(graph, lens, focusNodeId, depth) {
+  const allNodes = Object.values(graph.nodes);
+  if (lens.type === "domain") {
+    return allNodes;
+  }
+  return allNodes.filter((node) => {
+    const override = node.lensConfig[lens.id];
+    if (override?.visible === false) return false;
+    if (lens.nodeFilter.kinds && !lens.nodeFilter.kinds.includes(node.kind)) return false;
+    const minD = depth?.min ?? lens.nodeFilter.minDepth ?? 0;
+    const maxD = depth?.max ?? lens.nodeFilter.maxDepth ?? 4;
+    if (node.depth < minD || node.depth > maxD) return false;
+    if (lens.nodeFilter.tags && lens.nodeFilter.tags.length > 0) {
+      if (!lens.nodeFilter.tags.some((tag) => node.tags.includes(tag))) return false;
+    }
+    if (focusNodeId && focusNodeId !== graph.rootNodeId) {
+      const focusNode = graph.nodes[focusNodeId];
+      if (!focusNode) return true;
+      if (node.id === focusNodeId) return true;
+      const ancestors = getAncestors(graph, focusNodeId);
+      if (ancestors.some((a) => a.id === node.id)) return true;
+      const descendants = getDescendants(graph, focusNodeId);
+      if (descendants.some((d) => d.id === node.id)) return true;
+      return false;
+    }
+    return true;
+  });
+}
+function getVisibleRelations(graph, lens, visibleNodeIds) {
+  return Object.values(graph.relations).filter((rel) => {
+    if (!visibleNodeIds.has(rel.sourceId) || !visibleNodeIds.has(rel.targetId)) return false;
+    if (rel.lensVisibility[lens.id] === false) return false;
+    if (lens.relationFilter.types && !lens.relationFilter.types.includes(rel.type)) return false;
+    return true;
+  });
+}
+function validateGraph(graph) {
+  const anomalies = [];
+  const nodes = Object.values(graph.nodes);
+  const relations = Object.values(graph.relations);
+  for (const node of nodes) {
+    if (node.id === graph.rootNodeId) continue;
+    if (!node.parentId || !graph.nodes[node.parentId]) {
+      anomalies.push({
+        type: "orphan_node",
+        severity: "warning",
+        message: `Node "${node.name}" has no valid parent`,
+        nodeIds: [node.id]
+      });
+    }
+  }
+  for (const rel of relations) {
+    if (!graph.nodes[rel.sourceId] || !graph.nodes[rel.targetId]) {
+      anomalies.push({
+        type: "broken_reference",
+        severity: "error",
+        message: `Relation "${rel.type}" references missing node(s)`,
+        nodeIds: [rel.sourceId, rel.targetId].filter((id) => !graph.nodes[id]),
+        relationIds: [rel.id]
+      });
+    }
+  }
+  const depEdges = relations.filter((r) => r.type !== "contains");
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  function dfs(nodeId, path) {
+    if (inStack.has(nodeId)) {
+      const cycleStart = path.indexOf(nodeId);
+      const cycle = path.slice(cycleStart);
+      anomalies.push({
+        type: "circular_dependency",
+        severity: "warning",
+        message: `Circular dependency: ${cycle.map((id) => graph.nodes[id]?.name || id).join(" \u2192 ")}`,
+        nodeIds: cycle
+      });
+      return;
+    }
+    if (visited.has(nodeId)) return;
+    visited.add(nodeId);
+    inStack.add(nodeId);
+    const outgoing = depEdges.filter((e) => e.sourceId === nodeId);
+    for (const edge of outgoing) {
+      dfs(edge.targetId, [...path, nodeId]);
+    }
+    inStack.delete(nodeId);
+  }
+  for (const node of nodes) {
+    if (!visited.has(node.id)) {
+      dfs(node.id, []);
+    }
+  }
+  for (const node of nodes) {
+    const fanOut = depEdges.filter((e) => e.sourceId === node.id).length;
+    if (fanOut > 8) {
+      anomalies.push({
+        type: "high_coupling",
+        severity: "warning",
+        message: `Node "${node.name}" has high fan-out (${fanOut} dependencies)`,
+        nodeIds: [node.id]
+      });
+    }
+  }
+  for (const node of nodes) {
+    const fanIn = depEdges.filter((e) => e.targetId === node.id).length;
+    if (fanIn > 10) {
+      anomalies.push({
+        type: "god_node",
+        severity: "warning",
+        message: `Node "${node.name}" has high fan-in (${fanIn} dependents) \u2014 potential god node`,
+        nodeIds: [node.id]
+      });
+    }
+  }
+  return anomalies;
+}
+function getDirectChildrenForDisplay(graph, lens, focusNodeId) {
+  const contextNodeId = focusNodeId || graph.rootNodeId;
+  const contextNode = graph.nodes[contextNodeId];
+  if (!contextNode) return [];
+  return contextNode.children.map((id) => graph.nodes[id]).filter((node) => {
+    if (!node) return false;
+    const override = node.lensConfig[lens.id];
+    if (override?.visible === false) return false;
+    if (lens.nodeFilter.kinds && !lens.nodeFilter.kinds.includes(node.kind)) return false;
+    if (lens.nodeFilter.tags?.length) {
+      if (!lens.nodeFilter.tags.some((tag) => node.tags.includes(tag))) return false;
+    }
+    return true;
+  });
+}
+var codeGraphModelService = {
+  createEmptyGraph,
+  addNode,
+  removeNode,
+  addRelation,
+  removeRelation,
+  getChildren,
+  getDescendants,
+  getAncestors,
+  getVisibleNodes,
+  getDirectChildrenForDisplay,
+  getVisibleRelations,
+  validateGraph,
+  getDefaultLenses
+};
+
+// src/services/codeToGraph.ts
+var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".py", ""];
+var INDEX_SUFFIXES = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+function resolveImportToFile(importSource, currentFile, allFiles) {
+  if (!importSource.startsWith(".") && !importSource.startsWith("@/")) return null;
+  let basePath;
+  if (importSource.startsWith(".")) {
+    const currentDir = currentFile.substring(0, currentFile.lastIndexOf("/"));
+    const parts = importSource.split("/");
+    let resolved = currentDir;
+    for (const part of parts) {
+      if (part === ".") continue;
+      if (part === "..") {
+        const idx = resolved.lastIndexOf("/");
+        resolved = idx >= 0 ? resolved.substring(0, idx) : "";
+      } else {
+        resolved = resolved ? `${resolved}/${part}` : part;
+      }
+    }
+    basePath = resolved;
+  } else {
+    basePath = importSource.slice(2);
+  }
+  for (const ext of RESOLVE_EXTENSIONS) {
+    if (allFiles.includes(basePath + ext)) return basePath + ext;
+  }
+  for (const idx of INDEX_SUFFIXES) {
+    if (allFiles.includes(basePath + idx)) return basePath + idx;
+  }
+  return null;
+}
+function symbolKindToNodeKind(kind) {
+  switch (kind) {
+    case "class":
+      return "class";
+    case "function":
+      return "function";
+    case "interface":
+      return "interface";
+    case "variable":
+      return "variable";
+    default:
+      return "function";
+  }
+}
+async function parseCodebaseToGraph(analysis, repoId, repoName, workspaceId, provider, onProgress) {
+  let graph = codeGraphModelService.createEmptyGraph(workspaceId, repoId, repoName);
+  const rootId = graph.rootNodeId;
+  const totalFiles = analysis.modules.reduce((sum, m) => sum + m.files.length, 0);
+  const moduleIdMap = /* @__PURE__ */ new Map();
+  const fileIdMap = /* @__PURE__ */ new Map();
+  for (const mod of analysis.modules) {
+    const result = codeGraphModelService.addNode(graph, {
+      name: mod.name,
+      description: mod.description,
+      kind: "package",
+      depth: 1,
+      parentId: rootId,
+      children: [],
+      sourceRef: null,
+      tags: [],
+      lensConfig: {},
+      domainProjections: []
+    });
+    graph = result.graph;
+    moduleIdMap.set(mod.name, result.nodeId);
+  }
+  let fileIdx = 0;
+  for (const mod of analysis.modules) {
+    const moduleNodeId = moduleIdMap.get(mod.name);
+    for (const file of mod.files) {
+      fileIdx++;
+      onProgress?.(`Parsing ${file.filePath}`, fileIdx, totalFiles);
+      let contentHash = "";
+      if (provider) {
+        try {
+          const content = await provider.readFile(file.filePath);
+          contentHash = await codeParserService.computeContentHash(content);
+        } catch {
+        }
+      }
+      const fileResult = codeGraphModelService.addNode(graph, {
+        name: file.filePath.split("/").pop() ?? file.filePath,
+        kind: "module",
+        depth: 2,
+        parentId: moduleNodeId,
+        children: [],
+        sourceRef: contentHash ? { filePath: file.filePath, lineStart: 1, lineEnd: Math.max(...file.symbols.map((s) => s.lineEnd), 1), contentHash } : null,
+        tags: [file.language],
+        lensConfig: {},
+        domainProjections: []
+      });
+      graph = fileResult.graph;
+      fileIdMap.set(file.filePath, fileResult.nodeId);
+      for (const symbol of file.symbols) {
+        const symResult = codeGraphModelService.addNode(graph, {
+          name: symbol.name,
+          kind: symbolKindToNodeKind(symbol.kind),
+          depth: 3,
+          parentId: fileResult.nodeId,
+          children: [],
+          sourceRef: contentHash ? { filePath: file.filePath, lineStart: symbol.lineStart, lineEnd: symbol.lineEnd, contentHash } : null,
+          tags: [],
+          lensConfig: {},
+          domainProjections: []
+        });
+        graph = symResult.graph;
+      }
+    }
+  }
+  const allFiles = analysis.modules.flatMap((m) => m.files.map((f) => f.filePath));
+  for (const mod of analysis.modules) {
+    for (const file of mod.files) {
+      const sourceFileId = fileIdMap.get(file.filePath);
+      if (!sourceFileId) continue;
+      for (const imp of file.imports) {
+        if (imp.isExternal) continue;
+        const resolved = resolveImportToFile(imp.source, file.filePath, allFiles);
+        if (!resolved) continue;
+        const targetFileId = fileIdMap.get(resolved);
+        if (!targetFileId || targetFileId === sourceFileId) continue;
+        const relResult = codeGraphModelService.addRelation(graph, sourceFileId, targetFileId, "depends_on");
+        graph = relResult.graph;
+      }
+    }
+  }
+  for (const mod of analysis.modules) {
+    const sourceModId = moduleIdMap.get(mod.name);
+    if (!sourceModId) continue;
+    for (const dep of mod.dependencies) {
+      const targetModId = moduleIdMap.get(dep);
+      if (!targetModId || targetModId === sourceModId) continue;
+      const relResult = codeGraphModelService.addRelation(graph, sourceModId, targetModId, "depends_on");
+      graph = relResult.graph;
+    }
+  }
+  return graph;
+}
+
+// ../services/llmService.ts
+import { GoogleGenAI, Type as GeminiType } from "@google/genai";
+import OpenAI from "openai";
+var MAX_AGENT_ITERATIONS = 20;
+var LLMConfigError = class _LLMConfigError extends Error {
+  name = "LLMConfigError";
+  constructor(message = "No AI API key configured. Open AI Settings to add one.") {
+    super(message);
+    Object.setPrototypeOf(this, _LLMConfigError.prototype);
+  }
+};
+var LLMRateLimitError = class _LLMRateLimitError extends Error {
+  name = "LLMRateLimitError";
+  constructor(provider) {
+    super(`${provider} quota or rate limit exceeded. Wait a moment then try again.`);
+    Object.setPrototypeOf(this, _LLMRateLimitError.prototype);
+  }
+};
+var DEFAULT_MODELS = {
+  gemini: "gemini-3.1-flash-lite-preview",
+  openai: "gpt-4o-mini",
+  anthropic: "claude-sonnet-4-6"
+};
+async function sendGemini(messages, systemPrompt, config, signal) {
+  const ai = new GoogleGenAI({ apiKey: config.apiKey });
+  const model = config.model || DEFAULT_MODELS.gemini;
+  const contents = messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: [{ text: m.content }]
+  }));
+  try {
+    const response = await ai.models.generateContent({
+      model,
+      contents,
+      config: {
+        systemInstruction: systemPrompt,
+        temperature: 0.3,
+        abortSignal: signal
+      }
+    });
+    const text = response.text;
+    if (!text) throw new Error("No response from Gemini");
+    const meta = response.usageMetadata;
+    const usage = meta ? {
+      inputTokens: meta.promptTokenCount ?? 0,
+      outputTokens: meta.candidatesTokenCount ?? 0,
+      totalTokens: meta.totalTokenCount ?? 0
+    } : void 0;
+    return { content: text, provider: "gemini", model, usage };
+  } catch (err) {
+    if (err instanceof LLMConfigError || err instanceof LLMRateLimitError) throw err;
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("429") || msg.includes("RESOURCE_EXHAUSTED") || msg.includes("quota") || msg.includes("503") || msg.includes("UNAVAILABLE")) {
+      throw new LLMRateLimitError("Gemini");
+    }
+    if (msg.includes("401") || msg.includes("403") || msg.includes("API_KEY_INVALID") || msg.includes("permission")) {
+      throw new LLMConfigError(`Gemini API key is invalid or missing permissions. Open AI Settings.`);
+    }
+    throw err;
+  }
+}
+async function sendOpenAI(messages, systemPrompt, config, signal) {
+  const client = new OpenAI({
+    apiKey: config.apiKey,
+    dangerouslyAllowBrowser: true
+  });
+  const model = config.model || DEFAULT_MODELS.openai;
+  try {
+    const response = await client.chat.completions.create({
+      model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        ...messages.map((m) => ({
+          role: m.role,
+          content: m.content
+        }))
+      ],
+      temperature: 0.3
+    }, { signal });
+    const text = response.choices[0]?.message?.content;
+    if (!text) throw new Error("No response from OpenAI");
+    const usage = response.usage ? {
+      inputTokens: response.usage.prompt_tokens,
+      outputTokens: response.usage.completion_tokens,
+      totalTokens: response.usage.total_tokens
+    } : void 0;
+    return { content: text, provider: "openai", model, usage };
+  } catch (err) {
+    if (err instanceof LLMConfigError || err instanceof LLMRateLimitError) throw err;
+    const status = err instanceof OpenAI.APIError ? err.status : void 0;
+    if (status === 429) throw new LLMRateLimitError("OpenAI");
+    if (status === 401 || status === 403) throw new LLMConfigError(`OpenAI API key is invalid. Open AI Settings.`);
+    throw err;
+  }
+}
+async function sendAnthropic(messages, systemPrompt, config, signal) {
+  const model = config.model || DEFAULT_MODELS.anthropic;
+  const baseUrl = config.proxyUrl || "https://api.anthropic.com";
+  const response = await fetch(`${baseUrl}/v1/messages`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "x-api-key": config.apiKey,
+      "anthropic-version": "2023-06-01"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: messages.map((m) => ({ role: m.role, content: m.content }))
+    }),
+    signal
+  });
+  if (!response.ok) {
+    const errorText = await response.text().catch(() => "Unknown error");
+    if (response.status === 429) throw new LLMRateLimitError("Anthropic");
+    if (response.status === 401 || response.status === 403) {
+      throw new LLMConfigError(`Anthropic API key is invalid. Open AI Settings.`);
+    }
+    if (response.status === 0 || errorText.includes("CORS") || errorText.includes("Failed to fetch")) {
+      throw new Error(
+        "CORS error: The Anthropic API does not allow direct browser requests. Please configure a CORS proxy URL in AI Settings."
+      );
+    }
+    throw new Error(`Anthropic API error (${response.status}): ${errorText}`);
+  }
+  const data = await response.json();
+  const text = data.content?.[0]?.text;
+  if (!text) throw new Error("No response from Anthropic");
+  const usage = data.usage ? {
+    inputTokens: data.usage.input_tokens,
+    outputTokens: data.usage.output_tokens,
+    totalTokens: data.usage.input_tokens + data.usage.output_tokens
+  } : void 0;
+  return { content: text, provider: "anthropic", model, usage };
+}
+async function runAgentLoopGemini(messages, systemPrompt, tools, executor, config, continuationContext, signal) {
+  const ai = new GoogleGenAI({ apiKey: config.apiKey });
+  const model = config.model || DEFAULT_MODELS.gemini;
+  const toolSteps = [];
+  const contents = continuationContext ? [...continuationContext] : messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: [{ text: m.content }]
+  }));
+  let totalInput = 0, totalOutput = 0;
+  const geminiTypeMap = {
+    string: GeminiType.STRING,
+    number: GeminiType.NUMBER,
+    boolean: GeminiType.BOOLEAN
+  };
+  const functionDeclarations = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    parameters: {
+      type: GeminiType.OBJECT,
+      properties: Object.fromEntries(
+        Object.entries(t.parameters.properties).map(([key, param]) => [
+          key,
+          { ...param, type: geminiTypeMap[param.type] ?? GeminiType.STRING }
+        ])
+      ),
+      required: t.parameters.required
+    }
+  }));
+  for (let i = 0; i < MAX_AGENT_ITERATIONS; i++) {
+    signal?.throwIfAborted();
+    const response = await ai.models.generateContent({
+      model,
+      contents,
+      config: {
+        systemInstruction: systemPrompt,
+        temperature: 0.3,
+        tools: [{ functionDeclarations }],
+        abortSignal: signal
+      }
+    });
+    const candidate = response.candidates?.[0];
+    if (!candidate?.content?.parts) throw new Error("No response from Gemini");
+    const meta = response.usageMetadata;
+    if (meta) {
+      totalInput += meta.promptTokenCount ?? 0;
+      totalOutput += meta.candidatesTokenCount ?? 0;
+    }
+    const parts = candidate.content.parts;
+    const fnParts = parts.filter((p) => p.functionCall != null);
+    const textParts = parts.filter((p) => p.text != null);
+    if (fnParts.length === 0) {
+      const usage2 = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: totalInput + totalOutput };
+      return { content: textParts.map((p) => p.text ?? "").join(""), toolSteps, usage: usage2 };
+    }
+    contents.push({ role: "model", parts });
+    const fnResponses = await Promise.all(fnParts.map(async (part) => {
+      const { name, args } = part.functionCall;
+      if (!name) throw new Error("Gemini returned a function call with no name");
+      const step = await executor(name, args ?? {});
+      toolSteps.push(step);
+      return { functionResponse: { name, response: { output: step.result } } };
+    }));
+    contents.push({ role: "user", parts: fnResponses });
+  }
+  const usage = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: totalInput + totalOutput };
+  return { content: "", toolSteps, interrupted: true, continuationContext: [...contents], usage };
+}
+async function runAgentLoopOpenAI(messages, systemPrompt, tools, executor, config, continuationContext, signal) {
+  const client = new OpenAI({ apiKey: config.apiKey, dangerouslyAllowBrowser: true });
+  const model = config.model || DEFAULT_MODELS.openai;
+  const toolSteps = [];
+  const openAITools = tools.map((t) => ({
+    type: "function",
+    function: { name: t.name, description: t.description, parameters: t.parameters }
+  }));
+  const conv = continuationContext ? [...continuationContext] : [
+    { role: "system", content: systemPrompt },
+    ...messages.map((m) => ({ role: m.role, content: m.content }))
+  ];
+  let totalInput = 0, totalOutput = 0;
+  for (let i = 0; i < MAX_AGENT_ITERATIONS; i++) {
+    signal?.throwIfAborted();
+    const response = await client.chat.completions.create({
+      model,
+      messages: conv,
+      tools: openAITools,
+      tool_choice: "auto",
+      temperature: 0.3
+    }, { signal });
+    const msg = response.choices[0]?.message;
+    if (!msg) throw new Error("No response from OpenAI");
+    if (response.usage) {
+      totalInput += response.usage.prompt_tokens;
+      totalOutput += response.usage.completion_tokens;
+    }
+    conv.push(msg);
+    if (!msg.tool_calls?.length) {
+      const usage2 = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: totalInput + totalOutput };
+      return { content: msg.content ?? "", toolSteps, usage: usage2 };
+    }
+    const toolMessages = await Promise.all(msg.tool_calls.filter((tc) => tc.type === "function").map(async (tc) => {
+      const args = JSON.parse(tc.function.arguments || "{}");
+      const step = await executor(tc.function.name, args);
+      toolSteps.push(step);
+      return { role: "tool", tool_call_id: tc.id, content: step.result };
+    }));
+    toolMessages.forEach((m) => conv.push(m));
+  }
+  const usage = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: totalInput + totalOutput };
+  return { content: "", toolSteps, interrupted: true, continuationContext: [...conv], usage };
+}
+async function runAgentLoopAnthropic(messages, systemPrompt, tools, executor, config, continuationContext, signal) {
+  const model = config.model || DEFAULT_MODELS.anthropic;
+  const baseUrl = config.proxyUrl || "https://api.anthropic.com";
+  const toolSteps = [];
+  const anthropicTools = tools.map((t) => ({
+    name: t.name,
+    description: t.description,
+    input_schema: t.parameters
+  }));
+  const conv = continuationContext ? [...continuationContext] : messages.map((m) => ({ role: m.role, content: m.content }));
+  let totalInput = 0, totalOutput = 0;
+  for (let i = 0; i < MAX_AGENT_ITERATIONS; i++) {
+    signal?.throwIfAborted();
+    const res = await fetch(`${baseUrl}/v1/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": config.apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        max_tokens: 4096,
+        system: systemPrompt,
+        tools: anthropicTools,
+        messages: conv
+      }),
+      signal
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      if (res.status === 429) throw new LLMRateLimitError("Anthropic");
+      if (res.status === 401 || res.status === 403) throw new LLMConfigError("Anthropic API key is invalid. Open AI Settings.");
+      throw new Error(`Anthropic error (${res.status}): ${text}`);
+    }
+    const data = await res.json();
+    const content = data.content ?? [];
+    const stopReason = data.stop_reason;
+    if (data.usage) {
+      totalInput += data.usage.input_tokens;
+      totalOutput += data.usage.output_tokens;
+    }
+    conv.push({ role: "assistant", content });
+    if (stopReason !== "tool_use") {
+      const text = content.filter((b) => b.type === "text").map((b) => b.text ?? "").join("");
+      const usage2 = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: totalInput + totalOutput };
+      return { content: text, toolSteps, usage: usage2 };
+    }
+    const toolUseBlocks = content.filter((b) => b.type === "tool_use");
+    const toolResults = await Promise.all(toolUseBlocks.map(async (block) => {
+      const step = await executor(block.name, block.input ?? {});
+      toolSteps.push(step);
+      return { type: "tool_result", tool_use_id: block.id, content: step.result };
+    }));
+    conv.push({ role: "user", content: toolResults });
+  }
+  const usage = { inputTokens: totalInput, outputTokens: totalOutput, totalTokens: totalInput + totalOutput };
+  return { content: "", toolSteps, interrupted: true, continuationContext: [...conv], usage };
+}
+var _usageListener = null;
+function notifyUsage(usage, provider, model, source) {
+  if (usage && usage.totalTokens > 0 && _usageListener) {
+    _usageListener(usage, provider, model, source);
+  }
+}
+var llmService = {
+  async sendMessage(messages, systemPrompt, settings, options) {
+    const config = settings.providers[settings.activeProvider];
+    if (!config?.apiKey) {
+      throw new LLMConfigError(
+        `No API key configured for ${settings.activeProvider}. Open AI Settings to configure.`
+      );
+    }
+    const signal = options instanceof AbortSignal ? options : options?.signal;
+    const source = options instanceof AbortSignal ? "unknown" : options?.source ?? "unknown";
+    let response;
+    switch (settings.activeProvider) {
+      case "gemini":
+        response = await sendGemini(messages, systemPrompt, config, signal);
+        break;
+      case "openai":
+        response = await sendOpenAI(messages, systemPrompt, config, signal);
+        break;
+      case "anthropic":
+        response = await sendAnthropic(messages, systemPrompt, config, signal);
+        break;
+      default:
+        throw new Error(`Unknown provider: ${settings.activeProvider}`);
+    }
+    notifyUsage(response.usage, settings.activeProvider, config.model, source);
+    return response;
+  },
+  async runAgentLoop(messages, systemPrompt, tools, executor, settings, options) {
+    const config = settings.providers[settings.activeProvider];
+    if (!config?.apiKey) {
+      throw new LLMConfigError(`No API key configured for ${settings.activeProvider}. Open AI Settings to configure.`);
+    }
+    const ctx = options?.continuationContext;
+    const sig = options?.signal;
+    const source = options?.source ?? "unknown";
+    let result;
+    switch (settings.activeProvider) {
+      case "gemini":
+        result = await runAgentLoopGemini(messages, systemPrompt, tools, executor, config, ctx, sig);
+        break;
+      case "openai":
+        result = await runAgentLoopOpenAI(messages, systemPrompt, tools, executor, config, ctx, sig);
+        break;
+      case "anthropic":
+        result = await runAgentLoopAnthropic(messages, systemPrompt, tools, executor, config, ctx, sig);
+        break;
+      default:
+        throw new Error(`Unknown provider: ${settings.activeProvider}`);
+    }
+    notifyUsage(result.usage, settings.activeProvider, config.model, source);
+    return result;
+  },
+  async testConnection(provider, config) {
+    const testMessage = [{ role: "user", content: 'Say "OK"' }];
+    const testSettings = {
+      activeProvider: provider,
+      providers: { gemini: null, openai: null, anthropic: null, [provider]: config }
+    };
+    const response = await this.sendMessage(testMessage, 'Respond with just "OK".', testSettings);
+    return !!response.content;
+  }
+};
+
+// ../services/codeGraphOrchestrator.ts
+var generateId2 = () => Math.random().toString(36).substr(2, 9);
+function buildContext(analysis, provider) {
+  const fileByPath = /* @__PURE__ */ new Map();
+  const astImportPairs = /* @__PURE__ */ new Set();
+  const allFiles = analysis.modules.flatMap((m) => m.files);
+  const allFilePaths = new Set(allFiles.map((f) => f.filePath));
+  for (const file of allFiles) {
+    fileByPath.set(file.filePath, file);
+    for (const imp of file.imports) {
+      if (imp.isExternal) continue;
+      const base = imp.source.replace(/^@\//, "").replace(/^\.\//, "");
+      for (const target of allFilePaths) {
+        const norm = target.replace(/\.[^/.]+$/, "");
+        if (norm.endsWith(base) || target === imp.source) {
+          astImportPairs.add(`${file.filePath}\u2192${target}`);
+          break;
+        }
+      }
+    }
+  }
+  return { analysis, astImportPairs, fileByPath, provider, fileCache: /* @__PURE__ */ new Map() };
+}
+function extractJSON(text) {
+  const fenced = text.match(/```(?:json)?\s*\n?([\s\S]*?)```/);
+  if (fenced) return fenced[1].trim();
+  const obj = text.match(/\{[\s\S]*\}/);
+  if (obj) return obj[0];
+  const arr = text.match(/\[[\s\S]*\]/);
+  if (arr) return arr[0];
+  return text.trim();
+}
+async function readFileCached(ctx, path, maxLines = 150) {
+  const cacheKey = `${path}:${maxLines}`;
+  if (ctx.fileCache.has(cacheKey)) return ctx.fileCache.get(cacheKey);
+  if (!ctx.provider) return "(file content not available \u2014 no filesystem provider)";
+  try {
+    const content = await ctx.provider.readFile(path);
+    const limited = content.split("\n").slice(0, maxLines).join("\n");
+    ctx.fileCache.set(cacheKey, limited);
+    return limited;
+  } catch {
+    return "(could not read file)";
+  }
+}
+var ANALYSTE_SYSTEM = `You are a senior software architect specializing in domain-driven design.
+
+Your task: analyze a codebase and group files into cohesive SEMANTIC DOMAINS \u2014 not technical layers.
+
+You have tools:
+- list_files_by_coupling(): list files sorted by import connections. Start here.
+- get_file_info(path): AST-extracted symbols + imports for a file. Fast and cheap.
+- read_file(path): actual source code (first 150 lines). Use selectively on pivotal/ambiguous files.
+
+STRATEGY:
+1. Call list_files_by_coupling() first to see the most connected files
+2. Use get_file_info() broadly to understand roles without reading everything
+3. Use read_file() only for files where you're unsure about their domain (max 8 reads)
+4. Identify 3-10 semantic domains based on BUSINESS RESPONSIBILITY
+
+DOMAIN RULES:
+- Name by WHAT the code does: "Diagram Editor", "Code Intelligence", "Workspace Management"
+- NEVER use: "Services", "Hooks", "Components", "Utils", "Core", "Lib"
+- A hook + its service + its component \u2192 same domain if they serve the same feature
+- Cross-directory grouping is expected
+- Every file must appear in exactly one cluster
+- Infrastructure/utility files (db adapters, config, shared in-memory stores) used by many domains \u2192 merge into the domain that uses them most. Do NOT isolate them as standalone clusters unless there are 3+ cohesive infrastructure files that belong together.
+- Client-side entry points (app.js, index.html, main.ts) that orchestrate many features \u2192 group by their primary responsibility, or create a "Client Application" cluster if they span multiple domains.
+
+When ready, output ONLY this JSON (no other text):
+{
+  "clusters": [
+    {
+      "name": "Domain Name",
+      "description": "What this domain handles (1-2 sentences)",
+      "files": ["exact/path/to/file.ts", ...]
+    }
+  ]
+}`;
+function buildAnalysteTools() {
+  return [
+    {
+      name: "list_files_by_coupling",
+      description: "List all files sorted by import connections (most-connected first). Good starting point for analysis.",
+      parameters: { type: "object", properties: {}, required: [] }
+    },
+    {
+      name: "get_file_info",
+      description: "Get AST-extracted symbols and imports for a file. Cheaper than read_file \u2014 use broadly.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string", description: "Relative file path from repo root" } },
+        required: ["path"]
+      }
+    },
+    {
+      name: "read_file",
+      description: "Read actual source code (first 150 lines). Use selectively for pivotal or ambiguous files only.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string", description: "Relative file path from repo root" } },
+        required: ["path"]
+      }
+    }
+  ];
+}
+function buildAnalysteExecutor(ctx) {
+  const importedCount = /* @__PURE__ */ new Map();
+  for (const file of ctx.analysis.modules.flatMap((m) => m.files)) {
+    for (const imp of file.imports) {
+      if (!imp.isExternal) {
+        importedCount.set(imp.source, (importedCount.get(imp.source) || 0) + 1);
+      }
+    }
+  }
+  return async (name, args) => {
+    switch (name) {
+      case "list_files_by_coupling": {
+        const allFiles = ctx.analysis.modules.flatMap((m) => m.files);
+        const sorted = allFiles.map((f) => ({
+          path: f.filePath,
+          language: f.language,
+          importedByCount: importedCount.get(f.filePath) || 0,
+          importsCount: f.imports.filter((i) => !i.isExternal).length,
+          symbolCount: f.symbols.length
+        })).sort((a, b) => b.importedByCount + b.importsCount - (a.importedByCount + a.importsCount)).slice(0, 60);
+        return {
+          toolName: name,
+          args,
+          result: JSON.stringify(sorted, null, 2),
+          label: "list_files_by_coupling()"
+        };
+      }
+      case "get_file_info": {
+        const path = String(args.path || "");
+        const file = ctx.fileByPath.get(path);
+        if (!file) {
+          return { toolName: name, args, result: `File not found: ${path}`, label: `get_file_info("${path}")` };
+        }
+        const info = {
+          path: file.filePath,
+          language: file.language,
+          symbols: file.symbols.map((s) => `${s.name} (${s.kind})`),
+          imports: file.imports.map((i) => `${i.name} from "${i.source}"${i.isExternal ? " [external]" : ""}`),
+          exports: file.exportedSymbols
+        };
+        return {
+          toolName: name,
+          args,
+          result: JSON.stringify(info, null, 2),
+          label: `get_file_info("${path}")`
+        };
+      }
+      case "read_file": {
+        const path = String(args.path || "");
+        const content = await readFileCached(ctx, path, 150);
+        return { toolName: name, args, result: content, label: `read_file("${path}")` };
+      }
+      default:
+        return { toolName: name, args, result: "Unknown tool", label: name };
+    }
+  };
+}
+async function runAnalysteAgent(ctx, llmSettings, onLog, signal, previousIssues, onAgentEvent, onToolStart) {
+  const allFiles = ctx.analysis.modules.flatMap((m) => m.files);
+  const allFilePaths = new Set(allFiles.map((f) => f.filePath));
+  let prompt = `Analyze this codebase and identify semantic domains.
+
+FILE LIST (${allFiles.length} files):
+`;
+  prompt += allFiles.map((f) => `- ${f.filePath} (${f.language})`).join("\n");
+  prompt += "\n\nUse your tools to explore key files, then output the JSON cluster mapping.";
+  if (previousIssues && previousIssues.length > 0) {
+    const errorText = previousIssues.filter((i) => i.severity === "error").map((i) => `- ${i.message}${i.target ? ` [${i.target}]` : ""}`).join("\n");
+    if (errorText) prompt += `
+
+ISSUES FROM PREVIOUS ATTEMPT (fix these):
+${errorText}`;
+  }
+  onLog?.("ai-cluster", "Analyste: exploring codebase structure...");
+  try {
+    const rawAnalysteExecutor = buildAnalysteExecutor(ctx);
+    const analysteExecutor = onAgentEvent || onToolStart ? async (name, args) => {
+      const argsSummary = args.path || args.query || Object.values(args).join(", ") || "";
+      onToolStart?.("analyste", name, argsSummary);
+      const t0 = Date.now();
+      const step = await rawAnalysteExecutor(name, args);
+      onAgentEvent?.({
+        agent: "analyste",
+        toolName: name,
+        argsSummary,
+        resultSummary: step.result.slice(0, 300),
+        durationMs: Date.now() - t0
+      });
+      return step;
+    } : rawAnalysteExecutor;
+    const result = await llmService.runAgentLoop(
+      [{ role: "user", content: prompt }],
+      ANALYSTE_SYSTEM,
+      buildAnalysteTools(),
+      analysteExecutor,
+      llmSettings,
+      { signal, source: "code-agent-analyste" }
+    );
+    if (result.interrupted) {
+      throw new Error("Analyste: agent reached max iterations without producing output. Try again or switch to a more capable model.");
+    }
+    onLog?.("ai-cluster", `Analyste: ${result.toolSteps.length} tool calls \u2014 parsing clusters`);
+    const jsonStr = extractJSON(result.content);
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed.clusters)) {
+      throw new Error("Analyste: response did not include a valid clusters array. Try again or switch model.");
+    }
+    const assigned = /* @__PURE__ */ new Set();
+    const clusters = [];
+    for (const c of parsed.clusters) {
+      if (typeof c.name !== "string" || !Array.isArray(c.files)) continue;
+      const validFiles = c.files.filter((f) => typeof f === "string" && allFilePaths.has(f) && !assigned.has(f));
+      validFiles.forEach((f) => assigned.add(f));
+      if (validFiles.length > 0) {
+        clusters.push({ name: c.name, description: String(c.description || ""), files: validFiles });
+      }
+    }
+    const rejectedFileRate = 1 - assigned.size / Math.max(allFilePaths.size, 1);
+    if (rejectedFileRate > 0.5) {
+      onLog?.("ai-cluster", `Analyste warning: ${Math.round(rejectedFileRate * 100)}% of files had unresolvable paths \u2014 LLM may have hallucinated paths`);
+    }
+    const unassigned = [...allFilePaths].filter((f) => !assigned.has(f));
+    if (unassigned.length > 0) {
+      onLog?.("ai-cluster", `Analyste: ${unassigned.length} unassigned files \u2192 "Other" cluster`);
+      clusters.push({ name: "Other", description: "Files not assigned to a specific domain", files: unassigned });
+    }
+    onLog?.("ai-cluster", `Analyste: ${clusters.length} domains identified (${assigned.size}/${allFilePaths.size} files assigned)`);
+    return clusters;
+  } catch (err) {
+    onLog?.("ai-cluster", `Analyste failed: ${err instanceof Error ? err.message : String(err)}`);
+    throw err;
+  }
+}
+async function evaluateClusters(ctx, clusters, llmSettings, onLog, onAgentEvent, onBlackboard) {
+  const allFiles = ctx.analysis.modules.flatMap((m) => m.files);
+  const allFilePaths = new Set(allFiles.map((f) => f.filePath));
+  const coveredFiles = new Set(clusters.flatMap((c) => c.files));
+  const uncoveredRate = (allFilePaths.size - coveredFiles.size) / Math.max(allFilePaths.size, 1);
+  const fileToCluster = /* @__PURE__ */ new Map();
+  for (const c of clusters) {
+    for (const f of c.files) fileToCluster.set(f, c.name);
+  }
+  const crossBoundarySample = [...ctx.astImportPairs].filter((pair) => {
+    const [src, tgt] = pair.split("\u2192");
+    const srcCluster = fileToCluster.get(src);
+    const tgtCluster = fileToCluster.get(tgt);
+    return srcCluster && tgtCluster && srcCluster !== tgtCluster;
+  }).slice(0, 30);
+  const clusterSummary = clusters.map((c) => ({
+    name: c.name,
+    description: c.description,
+    fileCount: c.files.length,
+    sampleFiles: c.files.slice(0, 6)
+  }));
+  const prompt = `You are an adversarial architecture reviewer. Find real flaws in these semantic domain clusters.
+
+CLUSTERS:
+${JSON.stringify(clusterSummary, null, 2)}
+
+UNCOVERED FILE RATE: ${(uncoveredRate * 100).toFixed(1)}%
+
+CROSS-BOUNDARY IMPORT PAIRS (files in different clusters that import each other):
+${crossBoundarySample.length > 0 ? crossBoundarySample.join("\n") : "(none detected)"}
+
+REVIEW:
+1. Flag files likely misplaced based on their imports crossing boundaries heavily
+2. Flag clusters that appear to group by code type rather than business domain (e.g., a cluster named like "Services" or "Hooks")
+3. Flag if uncovered file rate > 10%
+4. Do NOT flag legitimate cross-boundary imports (e.g., a shared utility used by multiple domains)
+
+Output ONLY this JSON:
+{
+  "issues": [
+    {
+      "type": "misplaced_file" | "missing_coverage" | "hallucinated_relation",
+      "severity": "warning" | "error",
+      "message": "specific actionable description",
+      "target": "cluster or file name"
+    }
+  ]
+}`;
+  onLog?.("ai-eval", "\xC9valuateur: validating semantic clusters...");
+  const evalStartMs = Date.now();
+  onAgentEvent?.({
+    agent: "evaluateur",
+    toolName: "__eval_start__",
+    argsSummary: "clusters",
+    resultSummary: "Validation en cours...",
+    durationMs: 0
+  });
+  try {
+    const response = await llmService.sendMessage(
+      [{ role: "user", content: prompt }],
+      "You are an adversarial architecture reviewer. Be rigorous and specific.",
+      llmSettings,
+      { source: "code-agent-evaluateur" }
+    );
+    const parsed = JSON.parse(extractJSON(response.content));
+    if (!Array.isArray(parsed.issues)) return [];
+    const issues = parsed.issues.filter((i) => typeof i === "object" && i !== null).map((i) => ({
+      type: i.type || "misplaced_file",
+      severity: i.severity || "warning",
+      message: String(i.message || ""),
+      target: i.target ? String(i.target) : void 0
+    }));
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warning").length;
+    onLog?.("ai-eval", `\xC9valuateur clusters: ${errors} errors, ${warnings} warnings`);
+    onAgentEvent?.({
+      agent: "evaluateur",
+      toolName: "__eval_result__",
+      argsSummary: `${errors} errors, ${warnings} warnings`,
+      resultSummary: issues.map((i) => `[${i.severity}] ${i.message}`).join("\n"),
+      durationMs: Date.now() - evalStartMs
+    });
+    onBlackboard?.({
+      clusterIssues: issues.map((i) => ({
+        severity: i.severity,
+        message: i.message,
+        target: i.target
+      }))
+    });
+    return issues;
+  } catch {
+    onLog?.("ai-eval", "\xC9valuateur cluster validation failed (non-fatal)");
+    return [];
+  }
+}
+var SYNTHESEUR_SYSTEM = `You are a senior software architect identifying RUNTIME FLOWS in a codebase.
+
+A flow = a named sequence tracing how a user action or system event propagates at RUNTIME across multiple files.
+
+TOOLS:
+- find_entry_points(): all entry point files (no or few incoming imports). Call this first.
+- read_file(path): actual source code. Use this to understand what a file DOES at runtime.
+- get_node_relations(node_id): static import edges for a file. Use to discover dependencies.
+- get_cluster_files(cluster_name): files in a semantic cluster.
+
+APPROACH \u2014 reason step by step BEFORE generating flows:
+STEP 1 \u2014 SURVEY: Call find_entry_points(). Call read_file() on the 2-3 most important entry points (server, app, router).
+STEP 2 \u2014 ENUMERATE (do this in your reasoning before outputting anything): Mentally list ALL distinct user-facing operations this system handles. Think:
+  - What HTTP endpoints exist? (scan server/router/handler files)
+  - What UI interactions can a user perform?
+  - What background jobs or system events exist?
+  Aim for at least 5-10 candidates before selecting.
+STEP 3 \u2014 SELECT: From your enumeration, pick 3-8 flows that are distinct, important, and span meaningful boundaries (client\u2192server, handler\u2192storage, etc).
+STEP 4 \u2014 TRACE: For each selected flow, call read_file() on the files it crosses to confirm the runtime chain.
+STEP 5 \u2014 OUTPUT: Generate the JSON.
+
+The enumeration in STEP 2 is the key to completeness \u2014 if you skip it, important flows will be missed.
+
+WHAT MAKES A GOOD FLOW:
+- Spans multiple files across meaningful boundaries (client\u2192server, handler\u2192service\u2192database)
+- Reflects what actually happens at runtime, not just what's imported
+- Has a clear trigger (user action, HTTP request, system event) and outcome
+- Steps say WHAT each file does in this specific flow
+
+RULES:
+- Use exact nodeIds from the FILE LIST in the user message.
+- Sequence diagrams: descriptive participant aliases (not nodeIds), include return arrows.
+- For HTTP boundaries: use "->>" with label "HTTP GET /route" or similar.
+- scopeNodeId MUST be either "rootNodeId" (for cross-cluster end-to-end flows) or the nodeId of a D1 PACKAGE node. NEVER use a D2 file nodeId as scopeNodeId \u2014 file-level flows don't exist at this stage. All flows generated here are either cross-system (rootNodeId) or within one domain cluster (D1 package nodeId).
+
+Output ONLY this JSON (no other text):
+{
+  "flows": [
+    {
+      "name": "Human-readable flow name",
+      "description": "What happens end-to-end (1-2 sentences)",
+      "scopeNodeId": "rootNodeId  \u2190 use this for flows spanning multiple clusters; OR the D1 package nodeId for flows within one cluster",
+      "steps": [
+        { "nodeId": "exact-nodeId-from-FILE-LIST", "label": "What this file does in this flow", "order": 0 }
+      ],
+      "sequenceDiagram": "sequenceDiagram\\n  participant A as Name\\n  A->>B: action\\n  B-->>A: response"
+    }
+  ]
+}`;
+function buildSyntheseurTools() {
+  return [
+    {
+      name: "find_entry_points",
+      description: "Returns all codebase entry points: files with no or few incoming dependencies (index, main, App, handlers). Start here to identify where flows begin.",
+      parameters: { type: "object", properties: {}, required: [] }
+    },
+    {
+      name: "get_node_relations",
+      description: "Get all outgoing/incoming call/import relations for a graph node. Use to follow where calls go next and trace cross-file chains.",
+      parameters: {
+        type: "object",
+        properties: { node_id: { type: "string", description: "Graph node ID" } },
+        required: ["node_id"]
+      }
+    },
+    {
+      name: "get_cluster_files",
+      description: "List all files (with graph nodeIds) in a semantic cluster. Use to explore a specific domain.",
+      parameters: {
+        type: "object",
+        properties: { cluster_name: { type: "string", description: "Cluster/domain name" } },
+        required: ["cluster_name"]
+      }
+    },
+    {
+      name: "read_file",
+      description: "Read source code of a file (first 200 lines). Use for orchestrator files to confirm call sequences.",
+      parameters: {
+        type: "object",
+        properties: { path: { type: "string", description: "Relative file path from repo root" } },
+        required: ["path"]
+      }
+    }
+  ];
+}
+function buildSyntheseurExecutor(ctx, graph) {
+  const filePathToNodeId = /* @__PURE__ */ new Map();
+  for (const node of Object.values(graph.nodes)) {
+    if (node.sourceRef && node.depth === 2) filePathToNodeId.set(node.sourceRef.filePath, node.id);
+  }
+  return async (name, args) => {
+    switch (name) {
+      case "find_entry_points": {
+        const d2Nodes = Object.values(graph.nodes).filter((n) => n.depth === 2);
+        const incomingCount = /* @__PURE__ */ new Map();
+        for (const n of d2Nodes) incomingCount.set(n.id, 0);
+        for (const rel of Object.values(graph.relations)) {
+          if (rel.type === "depends_on" && incomingCount.has(rel.targetId)) {
+            incomingCount.set(rel.targetId, (incomingCount.get(rel.targetId) || 0) + 1);
+          }
+        }
+        const ENTRY_PATTERN = /^(index|main|app|server|cli|background|content|handler)\./i;
+        const entries = d2Nodes.filter((n) => (incomingCount.get(n.id) || 0) === 0 || ENTRY_PATTERN.test(n.name)).map((n) => {
+          const cluster = ctx.semanticClusters?.find((c) => c.files.includes(n.sourceRef?.filePath || ""));
+          return {
+            nodeId: n.id,
+            name: n.name,
+            filePath: n.sourceRef?.filePath || null,
+            cluster: cluster?.name || null,
+            outgoingRelations: Object.values(graph.relations).filter((r) => r.sourceId === n.id && r.type !== "contains").length
+          };
+        }).sort((a, b) => b.outgoingRelations - a.outgoingRelations).slice(0, 20);
+        return {
+          toolName: name,
+          args,
+          result: JSON.stringify(entries, null, 2),
+          label: "find_entry_points()"
+        };
+      }
+      case "get_cluster_files": {
+        const clusterName = String(args.cluster_name || "");
+        const cluster = ctx.semanticClusters?.find((c) => c.name === clusterName);
+        if (!cluster) {
+          const names = ctx.semanticClusters?.map((c) => c.name).join(", ") || "none";
+          return {
+            toolName: name,
+            args,
+            result: `Cluster not found. Available: ${names}`,
+            label: `get_cluster_files("${clusterName}")`
+          };
+        }
+        const files = cluster.files.map((f) => {
+          const nodeId = filePathToNodeId.get(f);
+          const node = nodeId ? graph.nodes[nodeId] : null;
+          return { path: f, nodeId: nodeId || null, nodeName: node?.name || null, depth: node?.depth ?? null };
+        });
+        return {
+          toolName: name,
+          args,
+          result: JSON.stringify(files, null, 2),
+          label: `get_cluster_files("${clusterName}")`
+        };
+      }
+      case "get_node_relations": {
+        const nodeId = String(args.node_id || "");
+        const node = graph.nodes[nodeId];
+        if (!node) {
+          return { toolName: name, args, result: `Node not found: ${nodeId}`, label: `get_node_relations("${nodeId}")` };
+        }
+        const outgoing = Object.values(graph.relations).filter((r) => r.sourceId === nodeId && r.type !== "contains").map((r) => ({
+          direction: "outgoing",
+          type: r.type,
+          targetId: r.targetId,
+          targetName: graph.nodes[r.targetId]?.name || r.targetId,
+          targetFile: graph.nodes[r.targetId]?.sourceRef?.filePath || null
+        }));
+        const incoming = Object.values(graph.relations).filter((r) => r.targetId === nodeId && r.type !== "contains").map((r) => ({
+          direction: "incoming",
+          type: r.type,
+          sourceId: r.sourceId,
+          sourceName: graph.nodes[r.sourceId]?.name || r.sourceId,
+          sourceFile: graph.nodes[r.sourceId]?.sourceRef?.filePath || null
+        }));
+        return {
+          toolName: name,
+          args,
+          result: JSON.stringify({ nodeId, name: node.name, file: node.sourceRef?.filePath, outgoing, incoming }, null, 2),
+          label: `get_node_relations("${node.name}")`
+        };
+      }
+      case "read_file": {
+        const path = String(args.path || "");
+        const content = await readFileCached(ctx, path, 200);
+        return { toolName: name, args, result: content, label: `read_file("${path}")` };
+      }
+      default:
+        return { toolName: name, args, result: "Unknown tool", label: name };
+    }
+  };
+}
+async function runSyntheseurAgent(ctx, graph, llmSettings, onLog, signal, previousIssues, onAgentEvent, scopeCluster, frozenFlowNames, missingFlows, onToolStart) {
+  const d2Nodes = Object.values(graph.nodes).filter((n) => n.depth === 2);
+  const d2ById = new Map(d2Nodes.map((n) => [n.id, n]));
+  const fileToClusterName = /* @__PURE__ */ new Map();
+  for (const cluster of ctx.semanticClusters ?? []) {
+    for (const fp of cluster.files) fileToClusterName.set(fp, cluster.name);
+  }
+  const fileLines = d2Nodes.map((n) => {
+    const cluster = n.sourceRef ? fileToClusterName.get(n.sourceRef.filePath) ?? "?" : "?";
+    return `  ${n.id}  ${n.sourceRef?.filePath ?? n.name}  [${cluster}]`;
+  }).join("\n");
+  const edgeLines = Object.values(graph.relations).filter((r) => r.type === "depends_on").map((r) => {
+    const src = d2ById.get(r.sourceId);
+    const tgt = d2ById.get(r.targetId);
+    if (!src || !tgt) return null;
+    return `  ${src.sourceRef?.filePath ?? src.id}  \u2192  ${tgt.sourceRef?.filePath ?? tgt.id}`;
+  }).filter(Boolean).join("\n");
+  const clusterSummary = (ctx.semanticClusters ?? []).map(
+    (c) => `  "${c.name}": ${c.files.join(", ")}`
+  ).join("\n");
+  let prompt = scopeCluster ? `Generate runtime flows FOCUSED ON the "${scopeCluster.name}" domain cluster.
+
+` : `Generate runtime flows for this codebase.
+
+`;
+  prompt += `FILES (nodeId  path  [cluster]):
+${fileLines || "(none)"}
+
+`;
+  prompt += `DEPENDENCY EDGES (A \u2192 B means A imports B):
+${edgeLines || "(none)"}
+
+`;
+  prompt += `SEMANTIC CLUSTERS:
+${clusterSummary || "(none)"}
+
+`;
+  prompt += `rootNodeId="${graph.rootNodeId}"
+
+`;
+  if (scopeCluster) {
+    prompt += `FOCUS: Generate 2-5 flows specifically about the "${scopeCluster.name}" domain.
+`;
+    prompt += `- Flows should involve at least one of these files: ${scopeCluster.files.join(", ")}
+`;
+    prompt += `- Flows may cross into other clusters (that's fine \u2014 show how this domain interacts with the rest)
+`;
+    prompt += `- Set scopeNodeId="${scopeCluster.nodeId}" on ALL generated flows
+
+`;
+  }
+  prompt += "Use find_entry_points() to confirm entry points, read_file() to understand orchestration logic, then output the flows JSON.";
+  if (previousIssues || frozenFlowNames || missingFlows) {
+    const flowErrors = /* @__PURE__ */ new Map();
+    const untargetedErrors = [];
+    for (const issue of (previousIssues ?? []).filter((i) => i.severity === "error")) {
+      if (issue.target) {
+        if (!flowErrors.has(issue.target)) flowErrors.set(issue.target, []);
+        flowErrors.get(issue.target).push(issue.message);
+      } else {
+        untargetedErrors.push(issue.message);
+      }
+    }
+    if (frozenFlowNames && frozenFlowNames.length > 0) {
+      prompt += `
+
+FROZEN FLOWS (already verified correct \u2014 do NOT regenerate, do not include in output):
+${frozenFlowNames.map((n) => `  \u2713 "${n}"`).join("\n")}`;
+    }
+    const toFix = [...flowErrors.keys()];
+    const toAdd = missingFlows ?? [];
+    const totalExpected = toFix.length + toAdd.length;
+    if (toFix.length > 0) {
+      prompt += `
+
+FLOWS TO REGENERATE WITH FIXES (include ALL of these in your output):`;
+      for (const [name, errs] of flowErrors) {
+        prompt += `
+  - "${name}"
+    Fix: ${errs.join("; ")}`;
+      }
+    }
+    if (toAdd.length > 0) {
+      prompt += `
+
+NEW FLOWS TO ADD (include ALL of these in your output):
+${toAdd.map((n) => `  + "${n}"`).join("\n")}`;
+    }
+    if (untargetedErrors.length > 0) {
+      prompt += `
+
+GENERAL ISSUES TO AVOID:
+${untargetedErrors.map((e) => `- ${e}`).join("\n")}`;
+    }
+    if (totalExpected > 0) {
+      prompt += `
+
+OUTPUT REQUIREMENT: your JSON must contain exactly ${totalExpected} flow(s) \u2014 one for each item listed above (flows to fix + new flows). Do not add or drop any.`;
+    }
+  }
+  onLog?.("ai-synth", "Synth\xE9tiseur: tracing runtime flows...");
+  try {
+    const rawSyntheseurExecutor = buildSyntheseurExecutor(ctx, graph);
+    const syntheseurExecutor = onAgentEvent || onToolStart ? async (name, args) => {
+      const argsSummary = args.path || args.query || Object.values(args).join(", ") || "";
+      onToolStart?.("syntheseur", name, argsSummary);
+      const t0 = Date.now();
+      const step = await rawSyntheseurExecutor(name, args);
+      onAgentEvent?.({
+        agent: "syntheseur",
+        toolName: name,
+        argsSummary,
+        resultSummary: step.result.slice(0, 300),
+        durationMs: Date.now() - t0
+      });
+      return step;
+    } : rawSyntheseurExecutor;
+    const result = await llmService.runAgentLoop(
+      [{ role: "user", content: prompt }],
+      SYNTHESEUR_SYSTEM,
+      buildSyntheseurTools(),
+      syntheseurExecutor,
+      llmSettings,
+      { signal, source: "code-agent-syntheseur" }
+    );
+    if (result.interrupted) {
+      onLog?.("ai-synth", "Synth\xE9tiseur: agent reached max iterations without producing output \u2014 no flows generated");
+      return null;
+    }
+    onLog?.("ai-synth", `Synth\xE9tiseur: ${result.toolSteps.length} tool calls \u2014 parsing flows`);
+    const jsonStr = extractJSON(result.content);
+    const parsed = JSON.parse(jsonStr);
+    const flows = validateAndBuildFlows(parsed, graph);
+    if (!flows) {
+      onLog?.("ai-synth", "Synth\xE9tiseur: flow validation failed");
+      return null;
+    }
+    onLog?.("ai-synth", `Synth\xE9tiseur: ${Object.keys(flows).length} valid flows generated`);
+    return flows;
+  } catch (err) {
+    if (err instanceof LLMRateLimitError || err instanceof LLMConfigError) throw err;
+    onLog?.("ai-synth", `Synth\xE9tiseur failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
+function validateAndBuildFlows(raw, graph) {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw;
+  const flowsArr = Array.isArray(obj.flows) ? obj.flows : null;
+  if (!flowsArr) return null;
+  const d1Ids = new Set(Object.values(graph.nodes).filter((n) => n.depth === 1).map((n) => n.id));
+  const d2Ids = new Set(Object.values(graph.nodes).filter((n) => n.depth === 2).map((n) => n.id));
+  const allValidIds = /* @__PURE__ */ new Set([graph.rootNodeId, ...d1Ids, ...d2Ids]);
+  const nameToId = /* @__PURE__ */ new Map();
+  for (const node of Object.values(graph.nodes)) {
+    const lower = node.name.toLowerCase();
+    if (!nameToId.has(lower)) nameToId.set(lower, node.id);
+    const noExt = node.name.replace(/\.[^.]+$/, "").toLowerCase();
+    if (!nameToId.has(noExt)) nameToId.set(noExt, node.id);
+  }
+  const resolveId = (id) => {
+    if (allValidIds.has(id)) return id;
+    const byName = nameToId.get(id.toLowerCase());
+    if (byName && allValidIds.has(byName)) return byName;
+    return null;
+  };
+  const flows = {};
+  for (const item of flowsArr) {
+    if (typeof item !== "object" || item === null) continue;
+    const { name, description, scopeNodeId, steps, sequenceDiagram } = item;
+    if (typeof name !== "string" || !name) continue;
+    if (!Array.isArray(steps) || steps.length < 2) continue;
+    let resolvedScope = typeof scopeNodeId === "string" ? resolveId(scopeNodeId) : null;
+    if (resolvedScope) {
+      const scopeNode = graph.nodes[resolvedScope];
+      if (scopeNode && scopeNode.depth > 1) resolvedScope = null;
+    }
+    if (!resolvedScope) resolvedScope = graph.rootNodeId;
+    const validSteps = [];
+    for (const step of steps) {
+      if (typeof step !== "object" || step === null) continue;
+      const s = step;
+      if (typeof s.nodeId !== "string") continue;
+      const resolved = resolveId(s.nodeId);
+      if (!resolved) continue;
+      validSteps.push({
+        nodeId: resolved,
+        label: typeof s.label === "string" ? s.label : s.nodeId,
+        order: typeof s.order === "number" ? s.order : validSteps.length
+      });
+    }
+    if (validSteps.length < 2) continue;
+    let seqDiagram = typeof sequenceDiagram === "string" ? sequenceDiagram : "";
+    if (!seqDiagram.startsWith("sequenceDiagram")) {
+      const parts = validSteps.map(
+        (s) => `  participant ${s.nodeId} as ${s.label.replace(/\.[^.]+$/, "")}`
+      ).join("\n");
+      const arrows = validSteps.slice(0, -1).map(
+        (s, i) => `  ${s.nodeId}->>${validSteps[i + 1].nodeId}: calls`
+      ).join("\n");
+      seqDiagram = `sequenceDiagram
+${parts}
+${arrows}`;
+    }
+    const id = generateId2();
+    flows[id] = {
+      id,
+      name,
+      description: typeof description === "string" ? description : "",
+      scopeNodeId: resolvedScope,
+      steps: validSteps,
+      sequenceDiagram: seqDiagram
+    };
+  }
+  return Object.keys(flows).length > 0 ? flows : null;
+}
+var EVALUATEUR_FLOW_SYSTEM = `You are an adversarial code reviewer verifying that runtime flows accurately represent the source code.
+
+You have one tool: read_file(path) \u2014 read source code to verify claims.
+
+PROCESS:
+1. Read the entry point file (step 0) of each flow.
+2. Verify: does the code actually connect to the next step at runtime?
+   - Static import \u2192 look for require() / import statements
+   - HTTP call \u2192 look for fetch(), axios, XMLHttpRequest, http.request()
+   - Event \u2192 look for emit(), addEventListener(), on()
+3. Read subsequent files as needed to verify the chain.
+4. Be STRICT \u2014 if a connection is not verifiable in the code, flag it as an error.
+5. Be ACCURATE \u2014 if you read the code and the connection IS there, do NOT flag it.
+6. IMPORTANT: read_file only returns the first 200 lines. If a step is NOT visible in the snippet but the entry point file is large and the function could plausibly exist further down, do NOT reject it \u2014 instead, mark it as a warning (cannot verify) rather than an error.
+
+Flag as ERROR:
+- A claimed connection (import, HTTP call, event) that does not exist in the source
+- A step whose label is completely wrong about what the file does
+- A file included in a flow that plays no role whatsoever
+
+Flag as WARNING:
+- A step label that is vague or partially inaccurate
+- A flow that skips important intermediate files
+
+Do NOT flag:
+- HTTP calls between client and server (verify with read_file that fetch/axios/routes exist)
+- Fan-out from a common parent (A imports B, A imports C, A imports D \u2014 all valid)
+- Transitive import chains (A imports B imports C)
+
+COMPLETENESS CHECK:
+After verifying existing flows, ask yourself: based on the source files you read, are there important user journeys or system events that are clearly NOT represented? Be conservative \u2014 only flag things that are obviously important AND obviously absent (not minor variations, not error edge cases).
+
+Output ONLY this JSON after your investigation:
+{
+  "issues": [
+    {
+      "type": "invalid_flow_step" | "trivial_flow" | "hallucinated_relation",
+      "severity": "warning" | "error",
+      "message": "specific description referencing what you found in the code",
+      "target": "flow name"
+    }
+  ],
+  "missing": ["Suggested missing flow name 1", "Suggested missing flow name 2"]
+}
+(If nothing important is missing, output "missing": [])`;
+var ALREADY_READ = "(already provided above)";
+function buildEvaluateurFlowExecutor(ctx) {
+  const readOnce = /* @__PURE__ */ new Set();
+  return async (name, args) => {
+    if (name === "read_file") {
+      const filePath = String(args.path ?? "");
+      if (readOnce.has(filePath)) {
+        return { toolName: name, args, result: ALREADY_READ, label: `read_file(${filePath}) [dup]` };
+      }
+      const content = await readFileCached(ctx, filePath, 200);
+      readOnce.add(filePath);
+      return { toolName: name, args, result: content, label: `read_file(${filePath})` };
+    }
+    return { toolName: name, args, result: "(unknown tool)", label: name };
+  };
+}
+async function evaluateFlows(ctx, graph, flows, llmSettings, onLog, onAgentEvent, onBlackboard, onToolStart) {
+  const flowSummary = Object.values(flows).map((f) => ({
+    name: f.name,
+    description: f.description,
+    steps: f.steps.map((s) => ({
+      file: graph.nodes[s.nodeId]?.sourceRef?.filePath ?? s.nodeId,
+      label: s.label
+    }))
+  }));
+  const prompt = `Verify these runtime flows against the actual source code. Use read_file() to check each connection before judging.
+
+FLOWS TO VERIFY:
+${JSON.stringify(flowSummary, null, 2)}
+
+For each flow, read the source files of the steps and verify the claimed connections exist in the code.`;
+  onLog?.("ai-eval", "\xC9valuateur: validating flows against source code...");
+  const evalFlowStartMs = Date.now();
+  const rawExecutor = buildEvaluateurFlowExecutor(ctx);
+  const executor = onAgentEvent || onToolStart ? async (name, args) => {
+    const argsSummary = String(args.path ?? args.file ?? "");
+    onToolStart?.("evaluateur", name, argsSummary);
+    const t0 = Date.now();
+    const step = await rawExecutor(name, args);
+    if (step.result !== ALREADY_READ) {
+      onAgentEvent?.({
+        agent: "evaluateur",
+        toolName: name,
+        argsSummary,
+        resultSummary: step.result.slice(0, 300),
+        durationMs: Date.now() - t0
+      });
+    }
+    return step;
+  } : rawExecutor;
+  const evalTools = [{
+    name: "read_file",
+    description: "Read source code of a file to verify a flow step connection",
+    parameters: {
+      type: "object",
+      properties: { path: { type: "string", description: "File path relative to project root" } },
+      required: ["path"]
+    }
+  }];
+  try {
+    const result = await llmService.runAgentLoop(
+      [{ role: "user", content: prompt }],
+      EVALUATEUR_FLOW_SYSTEM,
+      evalTools,
+      executor,
+      llmSettings,
+      { source: "code-agent-evaluateur" }
+    );
+    const parsed = JSON.parse(extractJSON(result.content));
+    if (!Array.isArray(parsed.issues)) return { issues: [], missing: [] };
+    const issues = parsed.issues.filter((i) => typeof i === "object" && i !== null).map((i) => ({
+      type: i.type || "invalid_flow_step",
+      severity: i.severity || "warning",
+      message: String(i.message || ""),
+      target: i.target ? String(i.target) : void 0
+    }));
+    const missing = Array.isArray(parsed.missing) ? parsed.missing.filter((s) => typeof s === "string") : [];
+    const errors = issues.filter((i) => i.severity === "error").length;
+    const warnings = issues.filter((i) => i.severity === "warning").length;
+    onLog?.("ai-eval", `\xC9valuateur flows: ${errors} errors, ${warnings} warnings, ${missing.length} missing (${result.toolSteps.length} files read)`);
+    onAgentEvent?.({
+      agent: "evaluateur",
+      toolName: "__eval_result__",
+      argsSummary: `${errors} errors, ${warnings} warnings`,
+      resultSummary: issues.length === 0 && missing.length === 0 ? "\u2713 All flows verified" : [
+        ...issues.map((i) => `[${i.severity}] ${i.message}`),
+        ...missing.map((m) => `[missing] ${m}`)
+      ].join("\n"),
+      durationMs: Date.now() - evalFlowStartMs
+    });
+    onBlackboard?.({
+      flowIssues: issues.map((i) => ({
+        severity: i.severity,
+        message: i.message,
+        target: i.target
+      }))
+    });
+    return { issues, missing };
+  } catch {
+    onLog?.("ai-eval", "\xC9valuateur flow validation failed (non-fatal)");
+    return { issues: [], missing: [] };
+  }
+}
+async function orchestrateCodebaseAnalysis(analysis, provider, llmSettings, onProgress, onLog, signal, onAgentEvent, onBlackboard, onToolStart) {
+  const ctx = buildContext(analysis, provider);
+  let clusters = null;
+  let issues = [];
+  onProgress?.("Semantic clustering", 1, 3);
+  clusters = await runAnalysteAgent(ctx, llmSettings, onLog, signal, void 0, onAgentEvent, onToolStart);
+  if (clusters && clusters.length > 0) {
+    ctx.semanticClusters = clusters;
+    onBlackboard?.({ clusters: clusters.map((c) => ({ name: c.name, fileCount: c.files.length, files: c.files })) });
+    onProgress?.("Validating clusters", 2, 3);
+    issues = await evaluateClusters(ctx, clusters, llmSettings, onLog, onAgentEvent, onBlackboard);
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    if (errorCount >= 1) {
+      onLog?.("ai-cluster", `Analyste round 2 (${errorCount} errors to fix)...`);
+      onProgress?.("Re-clustering (round 2)", 3, 3);
+      const round2 = await runAnalysteAgent(ctx, llmSettings, onLog, signal, issues, onAgentEvent, onToolStart);
+      if (round2 && round2.length > 0) {
+        clusters = round2;
+        ctx.semanticClusters = clusters;
+        onBlackboard?.({
+          clusters: clusters.map((c) => ({ name: c.name, fileCount: c.files.length, files: c.files })),
+          clusterIssues: []
+          // cleared — round 2 attempted to fix them
+        });
+      }
+    }
+  }
+  onProgress?.("Building modules", 3, 3);
+  if (!clusters || clusters.length === 0) {
+    throw new Error("Analyste produced no clusters. The model may be overloaded \u2014 try again or switch to a different model in AI Settings.");
+  }
+  const fileByPath = ctx.fileByPath;
+  const fileToCluster = /* @__PURE__ */ new Map();
+  for (const cluster of clusters) {
+    for (const fp of cluster.files) fileToCluster.set(fp, cluster.name);
+  }
+  const allFilePaths = Array.from(fileByPath.keys());
+  function resolveImport(source, fromFile) {
+    if (!source.startsWith(".") && !source.startsWith("@/")) return null;
+    let base;
+    if (source.startsWith("@/")) {
+      base = source.slice(2);
+    } else {
+      const dir = fromFile.substring(0, fromFile.lastIndexOf("/"));
+      const parts = source.split("/");
+      let cur = dir;
+      for (const p of parts) {
+        if (p === ".") continue;
+        else if (p === "..") {
+          const i = cur.lastIndexOf("/");
+          cur = i >= 0 ? cur.substring(0, i) : "";
+        } else {
+          cur = cur ? `${cur}/${p}` : p;
+        }
+      }
+      base = cur;
+    }
+    const exts = [".ts", ".tsx", ".js", ".jsx", ".py", ""];
+    const idxs = ["/index.ts", "/index.tsx", "/index.js", "/index.jsx"];
+    for (const ext of exts) {
+      const candidate = base + ext;
+      if (allFilePaths.includes(candidate)) return candidate;
+    }
+    for (const idx of idxs) {
+      const candidate = base + idx;
+      if (allFilePaths.includes(candidate)) return candidate;
+    }
+    return null;
+  }
+  const modules = clusters.map((cluster) => {
+    const files = cluster.files.map((fp) => fileByPath.get(fp)).filter((f) => f !== void 0);
+    const depSet = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      for (const imp of file.imports) {
+        if (imp.isExternal) continue;
+        const resolved = resolveImport(imp.source, file.filePath);
+        if (resolved) {
+          const targetCluster = fileToCluster.get(resolved);
+          if (targetCluster && targetCluster !== cluster.name) depSet.add(targetCluster);
+        }
+      }
+    }
+    return {
+      name: cluster.name,
+      description: cluster.description,
+      path: cluster.name,
+      files,
+      dependencies: Array.from(depSet)
+    };
+  });
+  const enrichedAnalysis = {
+    ...analysis,
+    modules
+  };
+  return { analysis: enrichedAnalysis, clusters };
+}
+async function orchestrateFlowGeneration(graph, clusters, provider, llmSettings, onProgress, onLog, signal, onAgentEvent, onBlackboard, scopeCluster, onToolStart) {
+  const ctx = {
+    analysis: { modules: [], externalDeps: [], entryPoints: [], totalFiles: 0, totalSymbols: 0 },
+    astImportPairs: new Set(
+      Object.values(graph.relations).filter((r) => r.type === "depends_on").map((r) => {
+        const src = graph.nodes[r.sourceId]?.sourceRef?.filePath;
+        const tgt = graph.nodes[r.targetId]?.sourceRef?.filePath;
+        return src && tgt ? `${src}\u2192${tgt}` : null;
+      }).filter((p) => p !== null)
+    ),
+    fileByPath: /* @__PURE__ */ new Map(),
+    provider,
+    fileCache: /* @__PURE__ */ new Map(),
+    semanticClusters: clusters
+  };
+  let flows = null;
+  let issues = [];
+  onProgress?.("Generating flows", 1, 3);
+  flows = await runSyntheseurAgent(ctx, graph, llmSettings, onLog, signal, void 0, onAgentEvent, scopeCluster, void 0, void 0, onToolStart);
+  if (flows && Object.keys(flows).length > 0) {
+    onBlackboard?.({ flows: Object.values(flows).map((f) => ({ name: f.name, stepCount: f.steps.length })) });
+    onProgress?.("Validating flows", 2, 3);
+    const { issues: evalIssues, missing } = await evaluateFlows(ctx, graph, flows, llmSettings, onLog, onAgentEvent, onBlackboard, onToolStart);
+    issues = evalIssues;
+    const errorCount = issues.filter((i) => i.severity === "error").length;
+    if (errorCount >= 1 || missing.length > 0) {
+      onLog?.("ai-synth", `Synth\xE9tiseur round 2 (${errorCount} errors to fix, ${missing.length} to add)...`);
+      onProgress?.("Re-generating flows (round 2)", 3, 3);
+      const errorTargets = new Set(
+        issues.filter((i) => i.severity === "error" && i.target).map((i) => i.target)
+      );
+      const hasUntargetedErrors = issues.some((i) => i.severity === "error" && !i.target);
+      const frozenFlowNames = hasUntargetedErrors ? [] : Object.values(flows).filter((f) => !errorTargets.has(f.name)).map((f) => f.name);
+      const round2 = await runSyntheseurAgent(
+        ctx,
+        graph,
+        llmSettings,
+        onLog,
+        signal,
+        issues,
+        onAgentEvent,
+        scopeCluster,
+        frozenFlowNames.length > 0 ? frozenFlowNames : void 0,
+        missing.length > 0 ? missing : void 0,
+        onToolStart
+      );
+      if (round2 && Object.keys(round2).length > 0) {
+        if (frozenFlowNames.length > 0) {
+          const frozenMap = {};
+          for (const f of Object.values(flows)) {
+            if (frozenFlowNames.includes(f.name)) frozenMap[f.id] = f;
+          }
+          flows = { ...frozenMap, ...round2 };
+        } else {
+          flows = round2;
+        }
+        onBlackboard?.({ flows: Object.values(flows).map((f) => ({ name: f.name, stepCount: f.steps.length })) });
+        const regenNames = /* @__PURE__ */ new Set([...errorTargets, ...missing]);
+        onBlackboard?.({
+          flowIssues: issues.filter((i) => i.severity !== "error" || !i.target || !regenNames.has(i.target)).map((i) => ({ severity: i.severity, message: i.message, target: i.target }))
+        });
+      }
+    }
+  }
+  if (scopeCluster && flows) {
+    const rescoped = {};
+    for (const [id, flow] of Object.entries(flows)) {
+      rescoped[id] = { ...flow, scopeNodeId: scopeCluster.nodeId };
+    }
+    flows = rescoped;
+  }
+  if (!flows || Object.keys(flows).length === 0) {
+    onLog?.("ai-synth", "Synth\xE9tiseur produced no valid flows");
+    return {};
+  }
+  onLog?.("ai-synth", `Flow generation complete: ${Object.keys(flows).length} flows`);
+  return flows;
+}
+
+// src/tools/codegraph.ts
+function graphSummary(graph) {
+  const nodes = Object.values(graph.nodes);
+  const relations = Object.values(graph.relations);
+  const nodesByKind = {};
+  for (const n of nodes) nodesByKind[n.kind] = (nodesByKind[n.kind] ?? 0) + 1;
+  const relationsByType = {};
+  for (const r of relations) relationsByType[r.type] = (relationsByType[r.type] ?? 0) + 1;
+  return {
+    id: graph.id,
+    name: graph.name,
+    repoId: graph.repoId,
+    workspaceId: graph.workspaceId,
+    nodeCount: nodes.length,
+    relationCount: relations.length,
+    nodesByKind,
+    relationsByType,
+    packages: nodes.filter((n) => n.depth === 1).map((n) => ({ id: n.id, name: n.name, childCount: n.children.length })),
+    createdAt: graph.createdAt,
+    updatedAt: graph.updatedAt
+  };
+}
+function buildLLMSettings(provider, apiKey, model) {
+  return {
+    activeProvider: provider,
+    providers: {
+      gemini: provider === "gemini" ? { provider: "gemini", apiKey, model: model ?? "gemini-2.0-flash" } : null,
+      openai: provider === "openai" ? { provider: "openai", apiKey, model: model ?? "gpt-4o-mini" } : null,
+      anthropic: provider === "anthropic" ? { provider: "anthropic", apiKey, model: model ?? "claude-sonnet-4-6" } : null
+    }
+  };
+}
+function registerCodeGraphTools(server2) {
+  server2.tool(
+    "scan_codebase",
+    "Scan a local directory, build a CodeGraph with LLM semantic clustering and flow generation. API keys are read from environment variables only (GEMINI_API_KEY, OPENAI_API_KEY, ANTHROPIC_API_KEY) \u2014 never pass keys as parameters.",
+    {
+      directory: z3.string().describe("Absolute path to the directory to scan"),
+      workspace_id: z3.string().describe("Workspace ID to store the CodeGraph in"),
+      repo_name: z3.string().optional().describe("Display name for this repo (defaults to directory basename)"),
+      llm_provider: z3.enum(["gemini", "openai", "anthropic"]).optional().describe("LLM provider \u2014 auto-detected from env vars if omitted"),
+      llm_model: z3.string().optional().describe("Model override (e.g. gemini-2.5-flash, gpt-4o, claude-sonnet-4-6)")
+    },
+    async ({ directory, workspace_id, repo_name, llm_provider: rawProvider, llm_model }) => {
+      const llm_provider = rawProvider ?? (process.env.GEMINI_API_KEY || process.env.API_KEY ? "gemini" : process.env.OPENAI_API_KEY ? "openai" : process.env.ANTHROPIC_API_KEY ? "anthropic" : void 0);
+      const llm_api_key = llm_provider === "gemini" ? process.env.GEMINI_API_KEY ?? process.env.API_KEY : llm_provider === "openai" ? process.env.OPENAI_API_KEY : llm_provider === "anthropic" ? process.env.ANTHROPIC_API_KEY : void 0;
+      if (!existsSync2(directory)) {
+        return { content: [{ type: "text", text: `Directory not found: ${directory}` }], isError: true };
+      }
+      const workspaces = await storage.listWorkspaces();
+      if (!workspaces.find((w) => w.id === workspace_id)) {
+        return { content: [{ type: "text", text: `Workspace "${workspace_id}" not found` }], isError: true };
+      }
+      const name = repo_name ?? directory.split("/").pop() ?? directory;
+      const repoId = `repo-${Date.now()}`;
+      const provider = new NodeFileSystemProvider(directory);
+      let analysisResult = await codebaseAnalyzerService.analyzeCodebase(provider);
+      const logs = [];
+      const onLog = (_type, msg) => {
+        logs.push(msg);
+      };
+      let clusters = [];
+      const usedLLM = !!(llm_provider && llm_api_key);
+      if (usedLLM) {
+        const llmSettings = buildLLMSettings(llm_provider, llm_api_key, llm_model);
+        try {
+          const orchestrated = await orchestrateCodebaseAnalysis(
+            analysisResult,
+            provider,
+            llmSettings,
+            void 0,
+            onLog
+          );
+          analysisResult = orchestrated.analysis;
+          clusters = orchestrated.clusters;
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          return { content: [{ type: "text", text: `LLM clustering failed: ${msg}` }], isError: true };
+        }
+      }
+      let graph = await parseCodebaseToGraph(analysisResult, repoId, name, workspace_id, provider);
+      if (usedLLM && clusters.length > 0) {
+        const llmSettings = buildLLMSettings(llm_provider, llm_api_key, llm_model);
+        try {
+          const flows = await orchestrateFlowGeneration(
+            graph,
+            clusters,
+            provider,
+            llmSettings,
+            void 0,
+            onLog
+          );
+          if (Object.keys(flows).length > 0) {
+            graph = { ...graph, flows, updatedAt: Date.now() };
+          }
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          logs.push(`Flow generation failed (${msg})`);
+        }
+      }
+      await storage.saveCodeGraph(graph);
+      const anomalies = codeGraphModelService.validateGraph(graph);
+      const summary = graphSummary(graph);
+      const flowCount = Object.keys(graph.flows ?? {}).length;
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            message: `CodeGraph "${name}" created successfully`,
+            graphId: graph.id,
+            pipeline: usedLLM ? "agentic (LLM semantic clustering + flow generation)" : "static analysis only",
+            filesScanned: analysisResult.totalFiles,
+            totalSymbols: analysisResult.totalSymbols,
+            modules: analysisResult.modules.length,
+            semanticClusters: clusters.length,
+            flows: flowCount,
+            externalDeps: analysisResult.externalDeps.length,
+            entryPoints: analysisResult.entryPoints,
+            summary,
+            anomalies: anomalies.slice(0, 10),
+            logs: logs.slice(-20)
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "list_codegraphs",
+    "List all stored CodeGraphs, optionally filtered by workspace",
+    { workspace_id: z3.string().optional().describe("Filter by workspace ID") },
+    async ({ workspace_id }) => {
+      const graphs = await storage.listCodeGraphs(workspace_id);
+      if (graphs.length === 0) {
+        return { content: [{ type: "text", text: "No CodeGraphs found. Use scan_codebase to create one." }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(graphs, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "get_codegraph_summary",
+    "Get a high-level summary of a CodeGraph (modules, node counts, dependency stats)",
+    { graph_id: z3.string().describe("CodeGraph ID") },
+    async ({ graph_id }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) {
+        return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(graphSummary(graph), null, 2) }] };
+    }
+  );
+  server2.tool(
+    "get_codegraph_nodes",
+    "Get nodes from a CodeGraph, optionally filtered by depth or kind",
+    {
+      graph_id: z3.string().describe("CodeGraph ID"),
+      depth: z3.number().int().min(0).max(4).optional().describe("Filter by depth: 0=system, 1=package, 2=module, 3=class/function, 4=method/field"),
+      kind: z3.enum(["system", "package", "module", "class", "function", "interface", "variable", "method", "field"]).optional().describe("Filter by node kind"),
+      parent_id: z3.string().optional().describe("Filter by parent node ID (list direct children)")
+    },
+    async ({ graph_id, depth, kind, parent_id }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) {
+        return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      }
+      let nodes = Object.values(graph.nodes);
+      if (depth !== void 0) nodes = nodes.filter((n) => n.depth === depth);
+      if (kind !== void 0) nodes = nodes.filter((n) => n.kind === kind);
+      if (parent_id !== void 0) nodes = nodes.filter((n) => n.parentId === parent_id);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(nodes.map((n) => ({
+            id: n.id,
+            name: n.name,
+            kind: n.kind,
+            depth: n.depth,
+            parentId: n.parentId,
+            childCount: n.children.length,
+            sourceRef: n.sourceRef ? { filePath: n.sourceRef.filePath, lines: `${n.sourceRef.lineStart}-${n.sourceRef.lineEnd}` } : null,
+            tags: n.tags
+          })), null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "detect_codegraph_anomalies",
+    "Detect anomalies in a CodeGraph: circular deps, god nodes (high fan-in), high coupling (high fan-out), orphan nodes, broken references",
+    { graph_id: z3.string().describe("CodeGraph ID") },
+    async ({ graph_id }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) {
+        return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      }
+      const anomalies = codeGraphModelService.validateGraph(graph);
+      if (anomalies.length === 0) {
+        return { content: [{ type: "text", text: "No anomalies detected." }] };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(anomalies, null, 2) }] };
+    }
+  );
+  server2.tool(
+    "generate_domain_diagrams",
+    "Drill into a specific package/domain node and generate scoped sequence diagrams for it. Call recursively on child nodes to build a multi-level diagram map. API keys are read from environment variables only.",
+    {
+      graph_id: z3.string().describe("CodeGraph ID"),
+      node_id: z3.string().describe("Package or module node ID to scope the generation to"),
+      workspace_id: z3.string().describe("Workspace ID where diagrams will be saved"),
+      folder_id: z3.string().optional().describe("Folder ID to save diagrams into"),
+      llm_provider: z3.enum(["gemini", "openai", "anthropic"]).optional().describe("LLM provider \u2014 auto-detected from env vars if omitted"),
+      llm_model: z3.string().optional().describe("Model override")
+    },
+    async ({ graph_id, node_id, workspace_id, folder_id, llm_provider: rawProvider, llm_model }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) {
+        return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      }
+      const scopeNode = graph.nodes[node_id];
+      if (!scopeNode) {
+        return { content: [{ type: "text", text: `Node "${node_id}" not found in graph` }], isError: true };
+      }
+      const llm_provider = rawProvider ?? (process.env.GEMINI_API_KEY || process.env.API_KEY ? "gemini" : process.env.OPENAI_API_KEY ? "openai" : process.env.ANTHROPIC_API_KEY ? "anthropic" : void 0);
+      const llm_api_key = llm_provider === "gemini" ? process.env.GEMINI_API_KEY ?? process.env.API_KEY : llm_provider === "openai" ? process.env.OPENAI_API_KEY : llm_provider === "anthropic" ? process.env.ANTHROPIC_API_KEY : void 0;
+      if (!llm_provider || !llm_api_key) {
+        return { content: [{ type: "text", text: "No LLM API key found in environment variables" }], isError: true };
+      }
+      const getDescendantFiles = (nodeId) => {
+        const node = graph.nodes[nodeId];
+        if (!node) return [];
+        if (node.sourceRef?.filePath && node.kind === "module") return [node.sourceRef.filePath];
+        return node.children.flatMap((childId) => getDescendantFiles(childId));
+      };
+      const files = getDescendantFiles(node_id);
+      if (files.length === 0) {
+        return { content: [{ type: "text", text: `No source files found under node "${scopeNode.name}"` }], isError: true };
+      }
+      const llmSettings = buildLLMSettings(llm_provider, llm_api_key, llm_model);
+      const logs = [];
+      const onLog = (_type, msg) => {
+        logs.push(msg);
+      };
+      const anyFile = files[0];
+      const repoRoot = Object.values(graph.nodes).filter((n) => n.kind === "system").map((n) => n.sourceRef?.filePath).find(Boolean) ?? "";
+      let fsProvider;
+      try {
+        const sampleFilePath = files[0];
+        const possibleRoots = ["/home/nathan/Projects/bluelens", process.cwd()];
+        for (const root of possibleRoots) {
+          const { existsSync: exists } = await import("fs");
+          if (exists(`${root}/${sampleFilePath}`)) {
+            fsProvider = new NodeFileSystemProvider(root);
+            break;
+          }
+        }
+      } catch {
+      }
+      const scopeCluster = { nodeId: node_id, name: scopeNode.name, files };
+      let flows;
+      try {
+        flows = await orchestrateFlowGeneration(
+          graph,
+          [],
+          fsProvider,
+          llmSettings,
+          void 0,
+          onLog,
+          void 0,
+          void 0,
+          void 0,
+          scopeCluster
+        );
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Flow generation failed: ${msg}` }], isError: true };
+      }
+      if (Object.keys(flows).length === 0) {
+        return { content: [{ type: "text", text: `No flows generated for "${scopeNode.name}"` }] };
+      }
+      const created = [];
+      for (const flow of Object.values(flows)) {
+        const seq = flow.sequenceDiagram;
+        if (!seq) continue;
+        const diagram = await storage.createDiagram(
+          workspace_id,
+          flow.name,
+          seq,
+          folder_id ?? null,
+          flow.description
+        );
+        created.push({ id: diagram.id, name: diagram.name });
+      }
+      const updatedGraph = { ...graph, flows: { ...graph.flows, ...flows }, updatedAt: Date.now() };
+      await storage.saveCodeGraph(updatedGraph);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            scope: scopeNode.name,
+            depth: scopeNode.depth,
+            filesAnalyzed: files.length,
+            diagramsCreated: created,
+            logs: logs.slice(-15)
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "delete_codegraph",
+    "Delete a stored CodeGraph",
+    { graph_id: z3.string().describe("CodeGraph ID to delete") },
+    async ({ graph_id }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) {
+        return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      }
+      await storage.deleteCodeGraph(graph_id);
+      return { content: [{ type: "text", text: `CodeGraph "${graph_id}" ("${graph.name}") deleted` }] };
+    }
+  );
+  server2.tool(
+    "push_to_cloud",
+    "Upload a local CodeGraph to the BlueLens Cloud MCP server so AI agents can access it remotely. The cloud server stores it under your API key namespace.",
+    {
+      graph_id: z3.string().describe("Local CodeGraph ID to push"),
+      cloud_url: z3.string().describe("BlueLens Cloud MCP server base URL (e.g. https://mcp.bluelens.dev or http://localhost:3003)"),
+      api_key: z3.string().describe("Your BlueLens Cloud API key")
+    },
+    async ({ graph_id, cloud_url, api_key }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) {
+        return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      }
+      const endpoint = `${cloud_url.replace(/\/$/, "")}/api/graphs`;
+      let response;
+      try {
+        response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${api_key}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(graph)
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `Network error reaching "${endpoint}": ${msg}` }], isError: true };
+      }
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = { rawStatus: response.status };
+      }
+      if (!response.ok) {
+        return {
+          content: [{
+            type: "text",
+            text: `Upload failed (HTTP ${response.status}): ${JSON.stringify(body)}`
+          }],
+          isError: true
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            message: `CodeGraph "${graph.name}" pushed to cloud successfully`,
+            endpoint,
+            graphId: graph.id,
+            nodeCount: Object.keys(graph.nodes).length,
+            server_response: body
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/tools/analysis.ts
+import { z as z4 } from "zod";
+import { readFileSync } from "fs";
+import { join as join4 } from "path";
+import { execSync } from "child_process";
+function getDependentIds(graph, nodeId) {
+  return Object.values(graph.relations).filter((r) => r.targetId === nodeId && r.type === "depends_on").map((r) => ({ sourceId: r.sourceId, type: r.type }));
+}
+function getDependencyIds(graph, nodeId) {
+  return Object.values(graph.relations).filter((r) => r.sourceId === nodeId && r.type === "depends_on").map((r) => ({ targetId: r.targetId, type: r.type }));
+}
+function collectTransitiveNodes(graph, startId, direction, maxDepth) {
+  const visited = /* @__PURE__ */ new Set([startId]);
+  const result = [];
+  const queue = [{ id: startId, distance: 0 }];
+  while (queue.length > 0) {
+    const { id: currentId, distance } = queue.shift();
+    if (distance >= maxDepth) continue;
+    const neighbors = direction === "up" ? getDependentIds(graph, currentId).map((r) => r.sourceId) : getDependencyIds(graph, currentId).map((r) => r.targetId);
+    for (const neighborId of neighbors) {
+      if (visited.has(neighborId)) continue;
+      visited.add(neighborId);
+      const node = graph.nodes[neighborId];
+      if (!node) continue;
+      result.push({ id: neighborId, name: node.name, kind: node.kind, filePath: node.sourceRef?.filePath ?? null, distance: distance + 1 });
+      queue.push({ id: neighborId, distance: distance + 1 });
+    }
+  }
+  return result;
+}
+function nodeShape(node) {
+  return { id: node.id, name: node.name, kind: node.kind, filePath: node.sourceRef?.filePath ?? null, depth: node.depth };
+}
+function getNodeDomain(graph, nodeId) {
+  let node = graph.nodes[nodeId];
+  while (node) {
+    if (node.depth === 1) return node.name;
+    if (!node.parentId) return null;
+    node = graph.nodes[node.parentId];
+  }
+  return null;
+}
+function buildLLMSettings2(provider, apiKey, model) {
+  return {
+    activeProvider: provider,
+    providers: {
+      gemini: provider === "gemini" ? { provider: "gemini", apiKey, model: model ?? "gemini-2.5-flash" } : null,
+      openai: provider === "openai" ? { provider: "openai", apiKey, model: model ?? "gpt-4o-mini" } : null,
+      anthropic: provider === "anthropic" ? { provider: "anthropic", apiKey, model: model ?? "claude-sonnet-4-6" } : null
+    }
+  };
+}
+function detectProvider() {
+  if (process.env.GEMINI_API_KEY || process.env.API_KEY) {
+    return { provider: "gemini", apiKey: process.env.GEMINI_API_KEY ?? process.env.API_KEY };
+  }
+  if (process.env.OPENAI_API_KEY) return { provider: "openai", apiKey: process.env.OPENAI_API_KEY };
+  if (process.env.ANTHROPIC_API_KEY) return { provider: "anthropic", apiKey: process.env.ANTHROPIC_API_KEY };
+  return null;
+}
+function runRules(graph, rules) {
+  const violations = [];
+  for (const rule of rules) {
+    if (rule.type === "forbidden_cross_domain" && rule.from_domain && rule.to_domain) {
+      for (const rel of Object.values(graph.relations)) {
+        if (rel.type !== "depends_on") continue;
+        const src = graph.nodes[rel.sourceId];
+        const tgt = graph.nodes[rel.targetId];
+        if (src?.kind !== "module" || tgt?.kind !== "module") continue;
+        const srcDomain = getNodeDomain(graph, rel.sourceId);
+        const tgtDomain = getNodeDomain(graph, rel.targetId);
+        if (srcDomain === rule.from_domain && tgtDomain === rule.to_domain) {
+          violations.push({
+            rule: rule.description,
+            severity: "error",
+            message: `Forbidden import: "${src?.name}" (${rule.from_domain}) \u2192 "${tgt?.name}" (${rule.to_domain})`,
+            details: `${src?.sourceRef?.filePath ?? src?.name} \u2192 ${tgt?.sourceRef?.filePath ?? tgt?.name}`
+          });
+        }
+      }
+    }
+    if (rule.type === "fan_in_threshold" && rule.file_query && rule.max !== void 0) {
+      const q = rule.file_query.toLowerCase();
+      const matches = Object.values(graph.nodes).filter(
+        (n) => n.name.toLowerCase().includes(q) || (n.sourceRef?.filePath?.toLowerCase().includes(q) ?? false)
+      );
+      for (const node of matches) {
+        const fanIn = Object.values(graph.relations).filter((r) => r.targetId === node.id && r.type === "depends_on").length;
+        if (fanIn > rule.max) {
+          violations.push({
+            rule: rule.description,
+            severity: "warning",
+            message: `Fan-in exceeded: "${node.name}" has ${fanIn} dependents (max: ${rule.max})`,
+            details: node.sourceRef?.filePath ?? node.name
+          });
+        }
+      }
+    }
+  }
+  return violations;
+}
+function violationKey(v) {
+  return `${v.rule}::${v.details}`;
+}
+function registerAnalysisTools(server2) {
+  server2.tool(
+    "analyze_node_impact",
+    "Blast-radius analysis: shows direct dependents (fan-in), direct dependencies (fan-out), and transitive blast radius. Run before modifying any file to know the risk.",
+    {
+      graph_id: z4.string().describe("CodeGraph ID"),
+      node_id: z4.string().optional().describe("Node ID to analyze"),
+      file_path: z4.string().optional().describe("Partial file path \u2014 resolves to the matching module node (use if node_id is unknown)"),
+      max_depth: z4.number().int().min(1).max(6).optional().describe("Transitive depth for blast radius (default: 3)")
+    },
+    async ({ graph_id, node_id, file_path, max_depth = 3 }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      let node;
+      if (node_id) {
+        node = graph.nodes[node_id];
+      } else if (file_path) {
+        const q = file_path.toLowerCase();
+        node = Object.values(graph.nodes).find((n) => n.sourceRef?.filePath?.toLowerCase().includes(q));
+      }
+      if (!node) {
+        return { content: [{ type: "text", text: node_id ? `Node "${node_id}" not found` : `No node matches file path "${file_path}"` }], isError: true };
+      }
+      const directDependents = getDependentIds(graph, node.id).map((r) => {
+        const n = graph.nodes[r.sourceId];
+        return n ? { ...nodeShape(n), relationType: r.type } : null;
+      }).filter(Boolean);
+      const directDependencies = getDependencyIds(graph, node.id).map((r) => {
+        const n = graph.nodes[r.targetId];
+        return n ? { ...nodeShape(n), relationType: r.type } : null;
+      }).filter(Boolean);
+      const blastRadius = collectTransitiveNodes(graph, node.id, "up", max_depth);
+      const riskScore = Math.min(10, Math.ceil(
+        (directDependents.length * 2 + blastRadius.length * 0.4) / 2
+      ));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            node: { ...nodeShape(node), tags: node.tags },
+            impact: {
+              directDependents: directDependents.length,
+              directDependencies: directDependencies.length,
+              transitiveBlastRadius: blastRadius.length,
+              riskScore: `${riskScore}/10`
+            },
+            directDependents,
+            directDependencies,
+            blastRadius: blastRadius.sort((a, b) => a.distance - b.distance)
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "find_dependency_path",
+    "Find the shortest dependency path between two nodes (how does A reach B?). Useful for understanding indirect coupling.",
+    {
+      graph_id: z4.string().describe("CodeGraph ID"),
+      from_node_id: z4.string().describe("Source node ID"),
+      to_node_id: z4.string().describe("Target node ID"),
+      max_hops: z4.number().int().min(1).max(10).optional().describe("Maximum path length to search (default: 6)")
+    },
+    async ({ graph_id, from_node_id, to_node_id, max_hops = 6 }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      if (!graph.nodes[from_node_id]) return { content: [{ type: "text", text: `Node "${from_node_id}" not found` }], isError: true };
+      if (!graph.nodes[to_node_id]) return { content: [{ type: "text", text: `Node "${to_node_id}" not found` }], isError: true };
+      const queue = [{ id: from_node_id, path: [from_node_id], relationPath: [] }];
+      const visited = /* @__PURE__ */ new Set([from_node_id]);
+      while (queue.length > 0) {
+        const { id: currentId, path, relationPath } = queue.shift();
+        if (path.length > max_hops) continue;
+        const outgoing = Object.values(graph.relations).filter((r) => r.sourceId === currentId && r.type === "depends_on");
+        for (const rel of outgoing) {
+          const isTarget = rel.targetId === to_node_id;
+          if (isTarget || !visited.has(rel.targetId)) {
+            const fullPath = [...path, rel.targetId];
+            const fullRelPath = [...relationPath, rel.type];
+            if (isTarget) {
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    found: true,
+                    hops: fullPath.length - 1,
+                    path: fullPath.map((nodeId, i) => {
+                      const n = graph.nodes[nodeId];
+                      return { id: nodeId, name: n?.name ?? nodeId, kind: n?.kind, filePath: n?.sourceRef?.filePath ?? null, relationToNext: i < fullPath.length - 1 ? fullRelPath[i] : null };
+                    })
+                  }, null, 2)
+                }]
+              };
+            }
+            visited.add(rel.targetId);
+            queue.push({ id: rel.targetId, path: fullPath, relationPath: fullRelPath });
+          }
+        }
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            found: false,
+            message: `No dependency path from "${graph.nodes[from_node_id]?.name}" to "${graph.nodes[to_node_id]?.name}" within ${max_hops} hops`
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "diff_codegraphs",
+    "Structural diff between two CodeGraphs (before vs after a refactor). Reports added/removed files, new/dropped dependencies, and domain-level drift.",
+    {
+      base_graph_id: z4.string().describe('Base CodeGraph ID (the "before" state)'),
+      target_graph_id: z4.string().describe('Target CodeGraph ID (the "after" state)')
+    },
+    async ({ base_graph_id, target_graph_id }) => {
+      const [base, target] = await Promise.all([storage.getCodeGraph(base_graph_id), storage.getCodeGraph(target_graph_id)]);
+      if (!base) return { content: [{ type: "text", text: `CodeGraph "${base_graph_id}" not found` }], isError: true };
+      if (!target) return { content: [{ type: "text", text: `CodeGraph "${target_graph_id}" not found` }], isError: true };
+      const baseModules = Object.values(base.nodes).filter((n) => n.kind === "module");
+      const targetModules = Object.values(target.nodes).filter((n) => n.kind === "module");
+      const baseByPath = new Map(baseModules.map((n) => [n.sourceRef?.filePath, n]));
+      const targetByPath = new Map(targetModules.map((n) => [n.sourceRef?.filePath, n]));
+      const addedModules = targetModules.filter((n) => n.sourceRef?.filePath && !baseByPath.has(n.sourceRef.filePath));
+      const removedModules = baseModules.filter((n) => n.sourceRef?.filePath && !targetByPath.has(n.sourceRef.filePath));
+      const depKey = (graph, r) => {
+        const src = graph.nodes[r.sourceId]?.sourceRef?.filePath;
+        const tgt = graph.nodes[r.targetId]?.sourceRef?.filePath;
+        return src && tgt ? `${src} \u2192 ${tgt}` : null;
+      };
+      const baseDeps = new Set(Object.values(base.relations).filter((r) => r.type === "depends_on").map((r) => depKey(base, r)).filter(Boolean));
+      const targetDeps = new Set(Object.values(target.relations).filter((r) => r.type === "depends_on").map((r) => depKey(target, r)).filter(Boolean));
+      const addedDeps = [...targetDeps].filter((d) => !baseDeps.has(d));
+      const removedDeps = [...baseDeps].filter((d) => !targetDeps.has(d));
+      const basePackages = new Set(Object.values(base.nodes).filter((n) => n.depth === 1).map((n) => n.name));
+      const targetPackages = new Set(Object.values(target.nodes).filter((n) => n.depth === 1).map((n) => n.name));
+      const addedDomains = [...targetPackages].filter((p) => !basePackages.has(p));
+      const removedDomains = [...basePackages].filter((p) => !targetPackages.has(p));
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            base: { id: base.id, name: base.name, scannedAt: new Date(base.createdAt).toISOString(), modules: baseModules.length, dependencies: baseDeps.size },
+            target: { id: target.id, name: target.name, scannedAt: new Date(target.createdAt).toISOString(), modules: targetModules.length, dependencies: targetDeps.size },
+            summary: {
+              addedModules: addedModules.length,
+              removedModules: removedModules.length,
+              addedDependencies: addedDeps.length,
+              removedDependencies: removedDeps.length,
+              addedDomains: addedDomains.length,
+              removedDomains: removedDomains.length
+            },
+            addedModules: addedModules.map((n) => ({ name: n.name, filePath: n.sourceRef?.filePath })),
+            removedModules: removedModules.map((n) => ({ name: n.name, filePath: n.sourceRef?.filePath })),
+            addedDependencies: addedDeps.slice(0, 40),
+            removedDependencies: removedDeps.slice(0, 40),
+            domainChanges: { added: addedDomains, removed: removedDomains }
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "find_nodes",
+    "Search for nodes by name, file path, kind, or depth. Use this to resolve a node ID before calling analyze_node_impact or find_dependency_path.",
+    {
+      graph_id: z4.string().describe("CodeGraph ID"),
+      query: z4.string().optional().describe("Partial name or file path match (case-insensitive)"),
+      kind: z4.enum(["system", "package", "module", "class", "function", "interface", "variable", "method", "field"]).optional().describe("Filter by node kind"),
+      depth: z4.number().int().min(0).max(4).optional().describe("Filter by depth (0=system, 1=package/domain, 2=module/file, 3=class/function, 4=method)")
+    },
+    async ({ graph_id, query, kind, depth }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      let nodes = Object.values(graph.nodes);
+      if (kind !== void 0) nodes = nodes.filter((n) => n.kind === kind);
+      if (depth !== void 0) nodes = nodes.filter((n) => n.depth === depth);
+      if (query) {
+        const q = query.toLowerCase();
+        nodes = nodes.filter((n) => n.name.toLowerCase().includes(q) || (n.sourceRef?.filePath?.toLowerCase().includes(q) ?? false));
+      }
+      if (nodes.length === 0) {
+        return { content: [{ type: "text", text: "No nodes matched the query." }] };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(nodes.map((n) => ({
+            id: n.id,
+            name: n.name,
+            kind: n.kind,
+            depth: n.depth,
+            filePath: n.sourceRef?.filePath ?? null,
+            parentId: n.parentId,
+            childCount: n.children.length,
+            tags: n.tags
+          })), null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "check_architectural_rules",
+    "Run deterministic architectural rules against a CodeGraph: forbidden cross-domain imports, fan-in thresholds. Optionally compare against a base graph to surface only NEW violations.",
+    {
+      graph_id: z4.string().describe("CodeGraph to check"),
+      rules: z4.array(z4.object({
+        type: z4.enum(["forbidden_cross_domain", "fan_in_threshold"]),
+        from_domain: z4.string().optional().describe("For forbidden_cross_domain: the importing domain name"),
+        to_domain: z4.string().optional().describe("For forbidden_cross_domain: the imported domain name"),
+        file_query: z4.string().optional().describe("For fan_in_threshold: partial file name to match"),
+        max: z4.number().optional().describe("For fan_in_threshold: maximum allowed fan-in"),
+        description: z4.string().describe("Human-readable rule description")
+      })).optional().describe("Rules to enforce. Omit to use the default bluelens ruleset."),
+      base_graph_id: z4.string().optional().describe("If provided, report only NEW violations not present in the base graph")
+    },
+    async ({ graph_id, rules: customRules, base_graph_id }) => {
+      const graph = await storage.getCodeGraph(graph_id);
+      if (!graph) return { content: [{ type: "text", text: `CodeGraph "${graph_id}" not found` }], isError: true };
+      const DEFAULT_RULES = [
+        { type: "forbidden_cross_domain", from_domain: "Shared Utilities & Configuration", to_domain: "Code Graph & Analysis", description: "Shared utils must not import Code Graph layer" },
+        { type: "forbidden_cross_domain", from_domain: "Shared Utilities & Configuration", to_domain: "AI Agent & LLM Integration", description: "Shared utils must not import LLM layer" },
+        { type: "forbidden_cross_domain", from_domain: "Shared Utilities & Configuration", to_domain: "Application Shell & Core UI", description: "Shared utils must not import UI layer" },
+        { type: "forbidden_cross_domain", from_domain: "Diagramming & Visualization", to_domain: "AI Agent & LLM Integration", description: "Diagramming must not directly import LLM agents" },
+        { type: "fan_in_threshold", file_query: "types.ts", max: 310, description: "types.ts fan-in must not grow beyond 310 (currently ~297)" },
+        { type: "fan_in_threshold", file_query: "llmService.ts", max: 30, description: "llmService.ts fan-in must not grow beyond 30 (currently ~23)" },
+        { type: "fan_in_threshold", file_query: "App.tsx", max: 70, description: "App.tsx dependency count must not grow beyond 70 (currently ~56)" }
+      ];
+      const rules = customRules ?? DEFAULT_RULES;
+      const violations = runRules(graph, rules);
+      let newViolations;
+      if (base_graph_id) {
+        const baseGraph = await storage.getCodeGraph(base_graph_id);
+        if (!baseGraph) return { content: [{ type: "text", text: `Base CodeGraph "${base_graph_id}" not found` }], isError: true };
+        const baseViolations = new Set(runRules(baseGraph, rules).map(violationKey));
+        newViolations = violations.filter((v) => !baseViolations.has(violationKey(v)));
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            graph: { id: graph.id, name: graph.name },
+            rulesChecked: rules.length,
+            totalViolations: violations.length,
+            ...newViolations !== void 0 ? { newViolations: newViolations.length, newViolationDetails: newViolations } : {},
+            violations
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server2.tool(
+    "review_architectural_drift",
+    "LLM-powered review of structural changes between two CodeGraphs. Evaluates whether the changes align with the project architectural philosophy and flags risks. API keys read from env.",
+    {
+      base_graph_id: z4.string().describe('Base CodeGraph ID (the "before")'),
+      target_graph_id: z4.string().describe('Target CodeGraph ID (the "after")'),
+      project_directory: z4.string().optional().describe("Path to the project root \u2014 used to read CLAUDE.md for architectural context"),
+      architectural_context: z4.string().optional().describe("Architectural philosophy to evaluate against (used if project_directory is not provided)"),
+      llm_model: z4.string().optional().describe("Model override (default: gemini-2.5-flash)")
+    },
+    async ({ base_graph_id, target_graph_id, project_directory, architectural_context, llm_model }) => {
+      const [base, target] = await Promise.all([storage.getCodeGraph(base_graph_id), storage.getCodeGraph(target_graph_id)]);
+      if (!base) return { content: [{ type: "text", text: `CodeGraph "${base_graph_id}" not found` }], isError: true };
+      if (!target) return { content: [{ type: "text", text: `CodeGraph "${target_graph_id}" not found` }], isError: true };
+      const detected = detectProvider();
+      if (!detected) return { content: [{ type: "text", text: "No LLM API key found in environment variables" }], isError: true };
+      const baseModules = Object.values(base.nodes).filter((n) => n.kind === "module");
+      const targetModules = Object.values(target.nodes).filter((n) => n.kind === "module");
+      const baseByPath = new Map(baseModules.map((n) => [n.sourceRef?.filePath, n]));
+      const targetByPath = new Map(targetModules.map((n) => [n.sourceRef?.filePath, n]));
+      const addedModules = targetModules.filter((n) => n.sourceRef?.filePath && !baseByPath.has(n.sourceRef.filePath)).map((n) => n.sourceRef.filePath);
+      const removedModules = baseModules.filter((n) => n.sourceRef?.filePath && !targetByPath.has(n.sourceRef.filePath)).map((n) => n.sourceRef.filePath);
+      const depKey = (graph, r) => {
+        const src = graph.nodes[r.sourceId]?.sourceRef?.filePath;
+        const tgt = graph.nodes[r.targetId]?.sourceRef?.filePath;
+        return src && tgt ? `${src} \u2192 ${tgt}` : null;
+      };
+      const baseDeps = new Set(Object.values(base.relations).filter((r) => r.type === "depends_on").map((r) => depKey(base, r)).filter(Boolean));
+      const targetDeps = new Set(Object.values(target.relations).filter((r) => r.type === "depends_on").map((r) => depKey(target, r)).filter(Boolean));
+      const addedDeps = [...targetDeps].filter((d) => !baseDeps.has(d));
+      const removedDeps = [...baseDeps].filter((d) => !targetDeps.has(d));
+      const baseAnomalies = codeGraphModelService.validateGraph(base);
+      const targetAnomalies = codeGraphModelService.validateGraph(target);
+      const baseAnomalyKeys = new Set(baseAnomalies.map((a) => `${a.type}::${a.message}`));
+      const newAnomalies = targetAnomalies.filter((a) => !baseAnomalyKeys.has(`${a.type}::${a.message}`));
+      const DEFAULT_RULES = [
+        { type: "forbidden_cross_domain", from_domain: "Shared Utilities & Configuration", to_domain: "Code Graph & Analysis", description: "Shared utils must not import Code Graph layer" },
+        { type: "forbidden_cross_domain", from_domain: "Shared Utilities & Configuration", to_domain: "AI Agent & LLM Integration", description: "Shared utils must not import LLM layer" },
+        { type: "forbidden_cross_domain", from_domain: "Diagramming & Visualization", to_domain: "AI Agent & LLM Integration", description: "Diagramming must not directly import LLM agents" },
+        { type: "fan_in_threshold", file_query: "types.ts", max: 310, description: "types.ts fan-in threshold" },
+        { type: "fan_in_threshold", file_query: "llmService.ts", max: 30, description: "llmService.ts fan-in threshold" }
+      ];
+      const baseRuleViolations = new Set(runRules(base, DEFAULT_RULES).map(violationKey));
+      const newRuleViolations = runRules(target, DEFAULT_RULES).filter((v) => !baseRuleViolations.has(violationKey(v)));
+      let context = architectural_context ?? "";
+      if (!context && project_directory) {
+        try {
+          context = readFileSync(join4(project_directory, "CLAUDE.md"), "utf-8");
+        } catch {
+        }
+        if (!context) {
+          try {
+            context = readFileSync(join4(project_directory, "PRD"), "utf-8").slice(0, 3e3);
+          } catch {
+          }
+        }
+      }
+      let gitLog = "";
+      if (project_directory) {
+        try {
+          const since = new Date(base.createdAt).toISOString();
+          const until = new Date(target.createdAt + 1e3).toISOString();
+          gitLog = execSync(
+            `git log --after="${since}" --before="${until}" --format="commit %h%n%s%n%b%n---" --no-merges`,
+            { cwd: project_directory, encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }
+          ).trim();
+        } catch {
+        }
+      }
+      const basePackages = Object.values(base.nodes).filter((n) => n.depth === 1).map((n) => n.name);
+      const targetPackages = Object.values(target.nodes).filter((n) => n.depth === 1).map((n) => n.name);
+      const systemPrompt = `You are a senior software architect reviewing codebase evolution.
+Your job: evaluate whether structural changes between two CodeGraph snapshots are consistent with the project's architectural philosophy, and flag concrete risks.
+Be direct, concise, and specific. Do not summarize what you were given \u2014 focus on what matters architecturally.`;
+      const userMessage = `## Architectural Philosophy
+${context || "(not provided \u2014 use general software architecture principles)"}
+
+## Commits Between Scans
+${gitLog || "(no git history available \u2014 structural changes cannot be explained by commit context)"}
+
+## Structural Changes
+- Added modules (${addedModules.length}): ${addedModules.slice(0, 20).join(", ") || "none"}
+- Removed modules (${removedModules.length}): ${removedModules.slice(0, 20).join(", ") || "none"}
+- New dependencies (${addedDeps.length}): ${addedDeps.slice(0, 20).join("; ") || "none"}
+- Removed dependencies (${removedDeps.length}): ${removedDeps.slice(0, 20).join("; ") || "none"}
+- Domain structure changed: base=[${basePackages.join(", ")}] \u2192 target=[${targetPackages.join(", ")}]
+
+## New Structural Anomalies Introduced (${newAnomalies.length})
+${newAnomalies.map((a) => `- [${a.severity}] ${a.type}: ${a.message}`).join("\n") || "none"}
+
+## New Deterministic Rule Violations (${newRuleViolations.length})
+${newRuleViolations.map((v) => `- [${v.severity}] ${v.message}`).join("\n") || "none"}
+
+Answer these three questions:
+1. **Alignment**: Use the commit messages to understand intent. Do the structural changes match what the commits describe? Flag any structural change NOT explained by a commit.
+2. **Risks**: What are the concrete architectural risks introduced? Distinguish between intentional changes (explained by commits) and unexplained drift.
+3. **Recommendations**: What should be fixed or watched? If a commit lacks an architectural explanation for a significant structural change, flag that too.`;
+      const messages = [{ role: "user", content: userMessage }];
+      const llmSettings = buildLLMSettings2(detected.provider, detected.apiKey, llm_model);
+      try {
+        const response = await llmService.sendMessage(messages, systemPrompt, llmSettings, { source: "architectural-review" });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              base: { id: base.id, name: base.name, scannedAt: new Date(base.createdAt).toISOString() },
+              target: { id: target.id, name: target.name, scannedAt: new Date(target.createdAt).toISOString() },
+              structuralDiff: { addedModules: addedModules.length, removedModules: removedModules.length, addedDeps: addedDeps.length, removedDeps: removedDeps.length },
+              newAnomalies: newAnomalies.length,
+              newRuleViolations: newRuleViolations.length,
+              tokensUsed: response.usage?.totalTokens,
+              review: response.content
+            }, null, 2)
+          }]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { content: [{ type: "text", text: `LLM review failed: ${msg}` }], isError: true };
+      }
+    }
+  );
+}
+
+// src/index.ts
+var projectRoot = join5(dirname(fileURLToPath(import.meta.url)), "..", "..");
+for (const envFile of [join5(projectRoot, ".env"), join5(projectRoot, "mcp", ".env")]) {
+  try {
+    const lines = readFileSync2(envFile, "utf-8").split("\n");
+    for (const line of lines) {
+      const match = line.match(/^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/);
+      if (match && !process.env[match[1]]) {
+        process.env[match[1]] = match[2].replace(/^["']|["']$/g, "").trim();
+      }
+    }
+  } catch {
+  }
+}
+var server = new McpServer({
+  name: "bluelens",
+  version: "0.1.0"
+});
+registerWorkspaceTools(server);
+registerDiagramTools(server);
+registerCodeGraphTools(server);
+registerAnalysisTools(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);