@openez-graph/cli 0.3.1 → 0.4.0

package/dist/cli.cjs

@@ -11564,6 +11564,15 @@ var init_schema = __esm({
 });
 
 // ../../packages/db/src/sqlite/database-loader.ts
+function getRequireUrl() {
+  try {
+    if (typeof import_meta !== "undefined" && import_meta.url) {
+      return import_meta.url;
+    }
+  } catch {
+  }
+  return `file://${__filename}`;
+}
 function tryResolveAddon() {
   if (resolvedAddon !== void 0) return resolvedAddon;
   try {
@@ -11600,9 +11609,7 @@ var init_database_loader = __esm({
     import_node_fs = __toESM(require("fs"), 1);
     import_node_module = __toESM(require("module"), 1);
     import_meta = {};
-    _require = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : import_node_module.default.createRequire(
-      typeof import_meta !== "undefined" && import_meta.url ? import_meta.url : `file://${__filename}`
-    );
+    _require = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : import_node_module.default.createRequire(getRequireUrl());
   }
 });
 
@@ -11722,6 +11729,68 @@ function initializeWorkspaceSchema(sqlite) {
     CREATE INDEX IF NOT EXISTS idx_graph_edges_type ON graph_edges(type);
     CREATE INDEX IF NOT EXISTS idx_embeddings_chunk_id ON embeddings(chunk_id);
   `);
+  sqlite.exec(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunks_fts USING fts5(
+      chunk_id UNINDEXED,
+      path,
+      heading,
+      language,
+      search_text,
+      content,
+      tokenize = 'porter unicode61'
+    );
+  `);
+  const ftsColumns = sqlite.prepare("PRAGMA table_info(chunks_fts)").all();
+  if (!ftsColumns.some((column) => column.name === "search_text")) {
+    sqlite.exec(`
+      DROP TRIGGER IF EXISTS chunks_fts_insert;
+      DROP TRIGGER IF EXISTS chunks_fts_delete;
+      DROP TRIGGER IF EXISTS chunks_fts_update;
+      DROP TABLE chunks_fts;
+      CREATE VIRTUAL TABLE chunks_fts USING fts5(
+        chunk_id UNINDEXED,
+        path,
+        heading,
+        language,
+        search_text,
+        content,
+        tokenize = 'porter unicode61'
+      );
+    `);
+  }
+  sqlite.exec(`
+    CREATE TRIGGER IF NOT EXISTS chunks_fts_insert AFTER INSERT ON chunks
+    BEGIN
+      INSERT INTO chunks_fts (chunk_id, path, heading, language, search_text, content)
+      SELECT new.id, documents.path, coalesce(new.heading, ''),
+        coalesce(documents.language, ''), coalesce(json_extract(new.metadata, '$.searchText'), ''), new.content
+      FROM documents WHERE documents.id = new.document_id;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS chunks_fts_delete AFTER DELETE ON chunks
+    BEGIN
+      DELETE FROM chunks_fts WHERE chunk_id = old.id;
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS chunks_fts_update AFTER UPDATE ON chunks
+    BEGIN
+      DELETE FROM chunks_fts WHERE chunk_id = old.id;
+      INSERT INTO chunks_fts (chunk_id, path, heading, language, search_text, content)
+      SELECT new.id, documents.path, coalesce(new.heading, ''),
+        coalesce(documents.language, ''), coalesce(json_extract(new.metadata, '$.searchText'), ''), new.content
+      FROM documents WHERE documents.id = new.document_id;
+    END;
+  `);
+  sqlite.exec(`
+    INSERT INTO chunks_fts (chunk_id, path, heading, language, search_text, content)
+    SELECT chunks.id, documents.path, coalesce(chunks.heading, ''),
+      coalesce(documents.language, ''), coalesce(json_extract(chunks.metadata, '$.searchText'), ''), chunks.content
+    FROM chunks
+    INNER JOIN documents ON documents.id = chunks.document_id
+    WHERE NOT EXISTS (
+      SELECT 1 FROM chunks_fts WHERE chunks_fts.chunk_id = chunks.id
+    );
+  `);
 }
 function getWorkspaceTableDefinitions() {
   return [
@@ -12081,8 +12150,9 @@ function createWorkspaceRepository(rootPath) {
       const existing = native.prepare("SELECT * FROM graph_nodes WHERE type = ? AND label = ?").get(input.type, input.label);
       if (existing) {
         const nextMetadata = input.metadata ?? String(existing.metadata ?? "{}");
-        const nextRefId = input.refId ?? existing.refId ?? null;
-        if (nextRefId !== existing.refId || nextMetadata !== existing.metadata) {
+        const existingRefId = existing.ref_id ?? null;
+        const nextRefId = input.refId ?? existingRefId;
+        if (nextRefId !== existingRefId || nextMetadata !== existing.metadata) {
           native.prepare("UPDATE graph_nodes SET ref_id = ?, metadata = ?, updated_at = ? WHERE id = ?").run(nextRefId, nextMetadata, (/* @__PURE__ */ new Date()).toISOString(), existing.id);
         }
         return String(existing.id);
@@ -12133,36 +12203,59 @@ function createWorkspaceRepository(rootPath) {
     },
     // ── Full-Text Search ──
     async fullTextSearch(query, limit2) {
-      const likePattern = `%${query}%`;
+      const ftsQuery = sanitizeFtsQuery(query);
+      if (!ftsQuery) return [];
       const rows = native.prepare(
-        `SELECT chunks.id, chunks.content, chunks.heading, chunks.metadata, documents.path
-           FROM chunks
+        `SELECT
+            chunks.id, chunks.content, chunks.heading, chunks.metadata,
+            documents.path,
+            bm25(chunks_fts, 0, 4, 3, 1.5, 2, 1)
+              * CASE
+                  WHEN documents.path LIKE 'tests/%' OR documents.path LIKE '%/__tests__/%' OR documents.path GLOB '*.test.*' THEN 0.8
+                  WHEN documents.kind = 'code' THEN 1.35
+                  ELSE 1
+                END AS bm25_score
+           FROM chunks_fts
+           INNER JOIN chunks ON chunks.id = chunks_fts.chunk_id
            INNER JOIN documents ON documents.id = chunks.document_id
-           WHERE chunks.content LIKE ?
+           WHERE chunks_fts MATCH ?
+           ORDER BY bm25_score ASC
            LIMIT ?`
-      ).all(likePattern, limit2);
-      return rows.map((row) => ({
-        id: String(row.id),
-        path: String(row.path),
-        content: String(row.content),
-        score: 0.1,
-        heading: row.heading ? String(row.heading) : null,
-        metadata: safeParseJson(String(row.metadata ?? ""), {})
-      }));
+      ).all(ftsQuery, limit2 * 5);
+      const seenPaths = /* @__PURE__ */ new Set();
+      return rows.map((row) => {
+        const bm25 = Number(row.bm25_score ?? 0);
+        const score = -bm25;
+        return {
+          id: String(row.id),
+          path: String(row.path),
+          content: String(row.content),
+          score,
+          heading: row.heading ? String(row.heading) : null,
+          metadata: safeParseJson(String(row.metadata ?? ""), {})
+        };
+      }).filter((row) => {
+        if (seenPaths.has(row.path)) return false;
+        seenPaths.add(row.path);
+        return true;
+      }).slice(0, limit2);
     },
     // ── Graph Traversal ──
-    async graphNeighbors(label, depth) {
-      const seedNodes = native.prepare("SELECT * FROM graph_nodes WHERE label = ? LIMIT 1").all(label);
+    async graphNeighbors(labelOrId, depth) {
+      const seedNodes = native.prepare("SELECT * FROM graph_nodes WHERE id = ? OR label = ? ORDER BY id = ? DESC LIMIT 1").all(labelOrId, labelOrId, labelOrId);
       if (seedNodes.length === 0) {
         return { nodes: [], edges: [] };
       }
       const seedId = String(seedNodes[0].id);
       const visited = /* @__PURE__ */ new Set();
-      const resultNodes = [];
+      const resultNodes = [
+        { ...seedNodes[0], metadata: safeParseJson(String(seedNodes[0].metadata ?? ""), {}) }
+      ];
       const resultEdges = [];
+      const resultEdgeIds = /* @__PURE__ */ new Set();
       let currentBatch = [seedId];
       visited.add(seedId);
-      for (let hop = 0; hop <= depth; hop++) {
+      for (let hop = 0; hop < Math.max(0, depth); hop++) {
         if (currentBatch.length === 0) break;
         const placeholders = currentBatch.map(() => "?").join(",");
         const edges = native.prepare(`SELECT * FROM graph_edges WHERE (from_node_id IN (${placeholders}) OR to_node_id IN (${placeholders}))`).all(...currentBatch, ...currentBatch);
@@ -12170,15 +12263,19 @@ function createWorkspaceRepository(rootPath) {
         for (const edge of edges) {
           const fromId = String(edge.from_node_id);
           const toId = String(edge.to_node_id);
-          if (!visited.has(fromId)) {
+          if (!visited.has(fromId) && visited.size < 200) {
             nextBatch.push(fromId);
             visited.add(fromId);
           }
-          if (!visited.has(toId)) {
+          if (!visited.has(toId) && visited.size < 200) {
             nextBatch.push(toId);
             visited.add(toId);
           }
-          resultEdges.push(edge);
+          const edgeId = String(edge.id);
+          if (!resultEdgeIds.has(edgeId)) {
+            resultEdgeIds.add(edgeId);
+            resultEdges.push(edge);
+          }
         }
         for (const nodeId of nextBatch) {
           const node = native.prepare("SELECT * FROM graph_nodes WHERE id = ?").get(nodeId);
@@ -12188,9 +12285,6 @@ function createWorkspaceRepository(rootPath) {
         }
         currentBatch = nextBatch;
       }
-      if (seedNodes[0]) {
-        resultNodes.push({ ...seedNodes[0], metadata: safeParseJson(String(seedNodes[0].metadata ?? ""), {}) });
-      }
       return { nodes: resultNodes, edges: resultEdges };
     },
     // ── Memory Operations ──
@@ -12317,6 +12411,38 @@ function safeParseJson(value, fallback) {
     return fallback;
   }
 }
+function sanitizeFtsQuery(query) {
+  const stopwords = /* @__PURE__ */ new Set([
+    "a",
+    "an",
+    "are",
+    "does",
+    "extracted",
+    "how",
+    "implement",
+    "implementation",
+    "implemented",
+    "in",
+    "is",
+    "of",
+    "the",
+    "to",
+    "what",
+    "where",
+    "work"
+  ]);
+  const codeVerbs = {
+    created: "create",
+    generated: "generate",
+    indexing: "index",
+    selected: "select",
+    stored: "store",
+    written: "write"
+  };
+  const terms = (query.match(/[\p{L}\p{N}$]+/gu) ?? []).filter((t) => t.length > 1 && !stopwords.has(t.toLowerCase()));
+  if (terms.length === 0) return "";
+  return [...new Set(terms.map((term) => codeVerbs[term.toLowerCase()] ?? term))].map((term) => `"${term}"*`).join(" OR ");
+}
 var import_node_crypto;
 var init_repository = __esm({
   "../../packages/db/src/sqlite/repository.ts"() {
@@ -27434,6 +27560,27 @@ function truncateToTokenLimit(value, maxTokens) {
     return value.slice(0, approximateMaxChars);
   }
 }
+function splitToTokenLimit(value, maxTokens, overlapTokens = 0) {
+  if (!value || maxTokens <= 0) return [];
+  const overlap = Math.min(Math.max(0, overlapTokens), maxTokens - 1);
+  try {
+    const tokens = encode2(value);
+    if (tokens.length <= maxTokens) return [value];
+    const chunks2 = [];
+    for (let start = 0; start < tokens.length; start += maxTokens - overlap) {
+      chunks2.push(decode2(tokens.slice(start, start + maxTokens)));
+    }
+    return chunks2;
+  } catch {
+    const maxChars = maxTokens * 4;
+    const overlapChars = overlap * 4;
+    const chunks2 = [];
+    for (let start = 0; start < value.length; start += maxChars - overlapChars) {
+      chunks2.push(value.slice(start, start + maxChars));
+    }
+    return chunks2;
+  }
+}
 var init_tokenizer = __esm({
   "../../packages/core/src/tokenizer.ts"() {
     "use strict";
@@ -27442,6 +27589,14 @@ var init_tokenizer = __esm({
 });
 
 // ../../packages/core/src/embeddings.ts
+function embeddingStorageModel(provider) {
+  return `${provider.model}:openez-code-v1`;
+}
+function formatEmbeddingInput(provider, input, task) {
+  const text2 = task === "query" ? input.content : [`path: ${input.path ?? ""}`, input.heading ? `heading: ${input.heading}` : "", input.content].filter(Boolean).join("\n");
+  const nomicPrefix = provider.provider === "ollama" && provider.model.includes("nomic-embed-text") ? task === "query" ? "search_query: " : "search_document: " : "";
+  return `${nomicPrefix}${text2}`;
+}
 function getEmbeddingProvider() {
   const env = loadEnv();
   if (env.EMBEDDING_PROVIDER === "none" || !env.EMBEDDING_PROVIDER) {
@@ -27548,13 +27703,14 @@ async function codeContext(input) {
   const edges = neighbors.edges.filter((edge) => edge.type === "calls");
   const relatedChunks = neighbors.nodes.filter((node) => node.type === "chunk");
   const symbol = neighbors.nodes.find(
-    (node) => node.type === "symbol" || node.label === input.symbolOrPath
+    (node) => node.type === "symbol" && (node.label === input.symbolOrPath || node.id === input.symbolOrPath)
   );
+  const symbolId = symbol ? String(symbol.id) : "";
   return {
     symbol,
     files,
-    callers: edges,
-    callees: edges,
+    callers: edges.filter((edge) => String(edge.to_node_id) === symbolId),
+    callees: edges.filter((edge) => String(edge.from_node_id) === symbolId),
     relatedChunks
   };
 }
@@ -27590,12 +27746,12 @@ var init_memory = __esm({
 });
 
 // ../../packages/core/src/rrf.ts
-function reciprocalRankFusion(resultSets, k = 60) {
+function reciprocalRankFusion(resultSets, k = 60, weights = []) {
   const map = /* @__PURE__ */ new Map();
-  resultSets.forEach((resultSet) => {
+  resultSets.forEach((resultSet, resultSetIndex) => {
     resultSet.forEach((entry, index2) => {
       const existing = map.get(entry.item.id);
-      const score = 1 / (k + index2 + 1);
+      const score = (weights[resultSetIndex] ?? 1) / (k + index2 + 1);
       if (existing) {
         existing.score += score;
       } else {
@@ -27634,77 +27790,116 @@ function formatContextBlock(chunk) {
   return `[source: ${chunk.path}:${startLine}-${endLine} | score: ${chunk.score.toFixed(3)}]
 ${chunk.content}`;
 }
-async function vectorSearch(rootPath, query, limit2) {
-  const provider = getEmbeddingProvider();
-  if (!provider) return [];
-  const [queryEmbedding] = await provider.embed([query]);
-  const queryDimensions = queryEmbedding.length;
-  const embeddingJson = JSON.stringify(queryEmbedding);
+function cosineSimilarity(left, right) {
+  if (left.length === 0 || left.length !== right.length) return 0;
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index2 = 0; index2 < left.length; index2 += 1) {
+    dot += left[index2] * right[index2];
+    leftNorm += left[index2] * left[index2];
+    rightNorm += right[index2] * right[index2];
+  }
+  return leftNorm === 0 || rightNorm === 0 ? 0 : dot / Math.sqrt(leftNorm * rightNorm);
+}
+function parseEmbedding(value) {
+  try {
+    const parsed = JSON.parse(String(value));
+    return Array.isArray(parsed) && parsed.every((item) => typeof item === "number") ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+async function rankStoredEmbeddings(rootPath, provider, queryEmbedding, limit2) {
+  if (queryEmbedding.length === 0) return [];
   const repo = createWorkspaceRepository(rootPath);
   const results = await repo.queryRaw(
     `SELECT
       chunks.id, chunks.content, chunks.heading, chunks.metadata,
-      documents.path
+      documents.path, embeddings.embedding
     FROM embeddings
     INNER JOIN chunks ON chunks.id = embeddings.chunk_id
     INNER JOIN documents ON documents.id = chunks.document_id
-    WHERE embeddings.model = ?
-      AND embeddings.dimensions = ?
-    ORDER BY abs(length(embeddings.embedding) - ?) ASC
-    LIMIT ?`,
-    [provider.model, queryDimensions, embeddingJson.length, limit2]
+    WHERE embeddings.provider = ?
+      AND embeddings.model = ?
+      AND embeddings.dimensions = ?`,
+    [provider.provider, embeddingStorageModel(provider), queryEmbedding.length]
   );
   return results.map((row) => ({
     id: String(row.id),
     path: String(row.path),
     content: String(row.content),
-    score: 0.5,
+    score: cosineSimilarity(queryEmbedding, parseEmbedding(row.embedding)),
     heading: row.heading ? String(row.heading) : null,
     metadata: safeParseJson2(String(row.metadata ?? "{}"), {})
-  }));
+  })).sort((left, right) => right.score - left.score).slice(0, limit2);
 }
-async function graphExpand(rootPath, seedIds, limit2) {
+async function vectorSearch(rootPath, query, limit2) {
+  const provider = getEmbeddingProvider();
+  if (!provider) return [];
+  const [queryEmbedding] = await provider.embed([
+    formatEmbeddingInput(provider, { content: query }, "query")
+  ]);
+  return rankStoredEmbeddings(rootPath, provider, queryEmbedding ?? [], limit2);
+}
+async function graphExpand(rootPath, seedIds, depth, limit2) {
   if (seedIds.length === 0) return [];
   const repo = createWorkspaceRepository(rootPath);
   const placeholders = seedIds.map(() => "?").join(",");
   const results = await repo.queryRaw(
-    `WITH seed_nodes AS (
-      SELECT id, ref_id
+    `WITH RECURSIVE walk(node_id, depth) AS (
+      SELECT id, 0
       FROM graph_nodes
       WHERE type = 'chunk'
         AND ref_id IN (${placeholders})
-    ),
-    neighbor_nodes AS (
-      SELECT DISTINCT
+      UNION
+      SELECT
         CASE
-          WHEN graph_edges.from_node_id = seed_nodes.id THEN graph_edges.to_node_id
+          WHEN graph_edges.from_node_id = walk.node_id THEN graph_edges.to_node_id
           ELSE graph_edges.from_node_id
-        END AS node_id
-      FROM graph_edges
-      INNER JOIN seed_nodes
-        ON graph_edges.from_node_id = seed_nodes.id
-        OR graph_edges.to_node_id = seed_nodes.id
+        END,
+        walk.depth + 1
+      FROM walk
+      INNER JOIN graph_edges
+        ON graph_edges.from_node_id = walk.node_id
+        OR graph_edges.to_node_id = walk.node_id
+      WHERE walk.depth < ?
+    ),
+    candidate_chunks AS (
+      SELECT chunks.id, MIN(walk.depth) AS distance
+      FROM walk
+      INNER JOIN graph_nodes ON graph_nodes.id = walk.node_id
+      INNER JOIN chunks ON chunks.id = graph_nodes.ref_id
+      WHERE graph_nodes.type = 'chunk'
+        AND walk.depth > 0
+        AND chunks.id NOT IN (${placeholders})
+      GROUP BY chunks.id
+      ORDER BY distance
       LIMIT ?
     )
     SELECT
       chunks.id, chunks.content, chunks.heading, chunks.metadata,
       documents.path,
-      0.15 AS score
-    FROM graph_nodes
-    INNER JOIN neighbor_nodes ON neighbor_nodes.node_id = graph_nodes.id
-    INNER JOIN chunks ON chunks.id = graph_nodes.ref_id
+      1.0 / (candidate_chunks.distance + 1) AS score
+    FROM candidate_chunks
+    INNER JOIN chunks ON chunks.id = candidate_chunks.id
     INNER JOIN documents ON documents.id = chunks.document_id
-    WHERE graph_nodes.type = 'chunk'`,
-    [...seedIds, limit2]
+    ORDER BY candidate_chunks.distance, documents.path`,
+    [...seedIds, depth, ...seedIds, limit2 * 5]
   );
+  const seenPaths = /* @__PURE__ */ new Set();
   return results.map((row) => ({
     id: String(row.id),
     path: String(row.path),
     content: String(row.content),
-    score: Number(row.score ?? 0.15),
+    score: Number(row.score ?? 0),
     heading: row.heading ? String(row.heading) : null,
     metadata: safeParseJson2(String(row.metadata ?? "{}"), {})
-  }));
+  })).filter((row) => {
+    if (seenPaths.has(row.path)) return false;
+    seenPaths.add(row.path);
+    return true;
+  }).slice(0, limit2);
 }
 async function memoryQuery(input) {
   const registry2 = createRegistryRepository();
@@ -27721,29 +27916,34 @@ async function memoryQuery(input) {
     repo.fullTextSearch(input.query, retrieval.textLimit),
     vectorSearch(workspace.rootPath, input.query, retrieval.vectorLimit)
   ]);
+  const primaryResults = ftsResults.length > 0 ? ftsResults : vectorResults;
   let fused = reciprocalRankFusion([
-    ftsResults.map((item) => ({ item, score: item.score })),
-    vectorResults.map((item) => ({ item, score: item.score }))
+    primaryResults.map((item) => ({ item, score: item.score }))
   ]);
   if (!input.skipGraphExpand) {
     const graphResults = await graphExpand(
       workspace.rootPath,
-      fused.slice(0, finalLimit).map((entry) => entry.item.id),
+      fused.slice(0, Math.min(finalLimit, 5)).map((entry) => entry.item.id),
+      retrieval.graphHops,
       retrieval.maxGraphNeighbors
     );
+    const fusedItemsByPath = new Map(fused.map((entry) => [entry.item.path, entry.item]));
     fused = reciprocalRankFusion([
       fused,
-      graphResults.map((item) => ({ item, score: item.score }))
-    ]);
+      graphResults.map((item) => ({ item: fusedItemsByPath.get(item.path) ?? item, score: item.score }))
+    ], 60, [1, 0.25]);
   }
   const selected = [];
   let usedTokens = 0;
+  const chunksPerPath = /* @__PURE__ */ new Map();
   for (const entry of fused) {
     if (selected.length >= finalLimit) break;
     const tokenCount = countTokens2(entry.item.content);
     if (usedTokens + tokenCount > maxTokens) continue;
-    selected.push(entry.item);
+    if (chunksPerPath.has(entry.item.path)) continue;
+    selected.push({ ...entry.item, score: entry.score });
     usedTokens += tokenCount;
+    chunksPerPath.set(entry.item.path, (chunksPerPath.get(entry.item.path) ?? 0) + 1);
   }
   const sources = selected.map((chunk) => sourceFromChunk(chunk, "retrieved-context"));
   await repo.insertQueryLog({
@@ -302258,6 +302458,10 @@ function getLineRange(node) {
     endLine: node.getEndLineNumber()
   };
 }
+function codeSearchText(text2) {
+  const identifiers = text2.match(/[A-Za-z_$][A-Za-z0-9_$]*/g) ?? [];
+  return [...new Set(identifiers.flatMap((identifier) => identifier.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(" ").filter((term) => term.length > 1)))].slice(0, 256).join(" ");
+}
 function indexCode(content, filePath) {
   const project = new import_ts_morph.Project({
     useInMemoryFileSystem: true,
@@ -302269,6 +302473,7 @@ function indexCode(content, filePath) {
   const chunks2 = [];
   const definedSymbols = [];
   const calledIdentifiers = /* @__PURE__ */ new Set();
+  const callExpressions = [];
   sourceFile.getImportDeclarations().forEach((declaration) => {
     declaration.getDescendantsOfKind(import_ts_morph.SyntaxKind.Identifier).forEach((identifier) => {
       if (identifier.getText()) {
@@ -302308,6 +302513,7 @@ function indexCode(content, filePath) {
       symbolType: symbolType2,
       metadata: {
         kind: "code",
+        searchText: codeSearchText(text2),
         symbolName: name,
         symbolType: symbolType2,
         exported,
@@ -302319,6 +302525,7 @@ function indexCode(content, filePath) {
       const calledName = expression.getText();
       if (calledName) {
         calledIdentifiers.add(calledName);
+        callExpressions.push({ callerName: name, calleeName: calledName.split(".").pop() ?? calledName });
       }
     });
   });
@@ -302339,6 +302546,7 @@ function indexCode(content, filePath) {
       symbolType: "variable",
       metadata: {
         kind: "code",
+        searchText: codeSearchText(text2),
         symbolName: name,
         symbolType: "variable",
         exported,
@@ -302359,6 +302567,7 @@ function indexCode(content, filePath) {
         contentHash: hashContent(slice),
         metadata: {
           kind: "code",
+          searchText: codeSearchText(slice),
           fallback: true,
           startLine: index2 + 1,
           endLine: Math.min(index2 + 80, lines.length)
@@ -302370,7 +302579,8 @@ function indexCode(content, filePath) {
     chunks: chunks2,
     importPaths: sourceFile.getImportDeclarations().map((declaration) => declaration.getModuleSpecifierValue()),
     definedSymbols,
-    calledIdentifiers: [...calledIdentifiers]
+    calledIdentifiers: [...calledIdentifiers],
+    callExpressions
   };
 }
 var import_ts_morph;
@@ -302572,13 +302782,37 @@ function inferDocumentKind(filePath) {
   }
   return { kind: "text", language: extension.slice(1) || null, extension };
 }
+function stripPythonAlias(value) {
+  return value.trim().replace(/^\(+|\)+$/g, "").split(/\s+as\s+/i)[0]?.trim() ?? "";
+}
+function parsePythonImportLine(line) {
+  const trimmed = line.trim().replace(/\s+#.*$/, "");
+  const fromMatch = /^from\s+([.\w]+)\s+import\s+(.+)$/.exec(trimmed);
+  if (fromMatch) {
+    const modulePath = fromMatch[1];
+    const importedNames = fromMatch[2].split(",").map(stripPythonAlias).filter((name) => name && name !== "*");
+    return [
+      modulePath,
+      ...importedNames.map((name) => modulePath.endsWith(".") ? `${modulePath}${name}` : `${modulePath}.${name}`)
+    ];
+  }
+  const importMatch = /^import\s+(.+)$/.exec(trimmed);
+  if (!importMatch) return [];
+  return importMatch[1].split(",").map(stripPythonAlias).filter(Boolean);
+}
+function normalizePythonCallName(value) {
+  const parts = value.split(".").filter(Boolean);
+  return parts[parts.length - 1] ?? value;
+}
 function parsePython(content) {
   const lines = content.split("\n");
   const definedSymbols = [];
   const importPaths = [];
+  const calledIdentifiers = /* @__PURE__ */ new Set();
+  const callExpressions = [];
   const symbolRegex = /^(?:async\s+)?(?:def|class)\s+(\w+)/;
-  const importRegex = /^(?:from\s+(\S+)\s+)?import\s+(\S+)/;
   const moduleDocstring = /^"""/;
+  const callRegex = /(\w+(?:\.\w+)*)\s*\(/g;
   let inMultilineString = false;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -302594,29 +302828,37 @@ function parsePython(content) {
       }
       continue;
     }
-    const symbolMatch = symbolRegex.exec(line);
-    if (symbolMatch && line.trim().startsWith("def") || symbolMatch && line.trim().startsWith("class") || symbolMatch && line.trim().startsWith("async def") || symbolMatch && line.trim().startsWith("async class")) {
+    const trimmed = line.trim();
+    const symbolMatch = symbolRegex.exec(trimmed);
+    if (symbolMatch) {
       const name = symbolMatch[1];
-      const isAsync2 = line.trim().startsWith("async");
-      const stripped = isAsync2 ? line.trim().slice(6) : line.trim();
+      const isAsync2 = trimmed.startsWith("async");
+      const stripped = isAsync2 ? trimmed.slice(6) : trimmed;
       const symbolType2 = stripped.startsWith("def") ? "function" : "class";
       const exported = !name.startsWith("_");
       const startLine = i + 1;
       const endLine = findBlockEnd(lines, i);
       const content2 = lines.slice(i, endLine).join("\n");
       definedSymbols.push({ name, symbolType: symbolType2, type: symbolType2, exported, startLine, endLine });
+      const bodyContent = lines.slice(i, endLine).join("\n");
+      let callMatch;
+      const localCallRegex = new RegExp(callRegex);
+      while ((callMatch = localCallRegex.exec(bodyContent)) !== null) {
+        const rawCalledName = callMatch[1];
+        const calledName = normalizePythonCallName(rawCalledName);
+        if (!PYTHON_CALL_IGNORES.has(rawCalledName) && !PYTHON_CALL_IGNORES.has(calledName) && calledName !== name) {
+          calledIdentifiers.add(calledName);
+          callExpressions.push({ callerName: name, calleeName: calledName });
+        }
+      }
     }
-    const importMatch = importRegex.exec(line);
-    if (importMatch) {
-      const modulePath = importMatch[1] || importMatch[2];
-      importPaths.push(modulePath);
-    }
+    importPaths.push(...parsePythonImportLine(line));
   }
   const chunks2 = createSymbolChunks(definedSymbols, lines, "python");
   if (chunks2.length === 0) {
-    return makeFallbackChunks(content, lines);
+    return { ...makeFallbackChunks(content, lines), callExpressions: [] };
   }
-  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [] };
+  return { chunks: chunks2, importPaths: [...new Set(importPaths)], definedSymbols, calledIdentifiers: [...calledIdentifiers], callExpressions };
 }
 function parseGo(content) {
   const lines = content.split("\n");
@@ -302683,7 +302925,7 @@ function parseGo(content) {
   if (chunks2.length === 0) {
     return makeFallbackChunks(content, lines);
   }
-  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [] };
+  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [], callExpressions: [] };
 }
 function parseRust(content) {
   const lines = content.split("\n");
@@ -302781,7 +303023,7 @@ function parseRust(content) {
   if (chunks2.length === 0) {
     return makeFallbackChunks(content, lines);
   }
-  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [] };
+  return { chunks: chunks2, importPaths, definedSymbols, calledIdentifiers: [], callExpressions: [] };
 }
 function indexConfig(content, language) {
   switch (language) {
@@ -303003,9 +303245,9 @@ function makeFallbackChunks(content, lines) {
       }
     });
   }
-  return { chunks: chunks2, importPaths: [], definedSymbols: [], calledIdentifiers: [] };
+  return { chunks: chunks2, importPaths: [], definedSymbols: [], calledIdentifiers: [], callExpressions: [] };
 }
-var import_node_path9, codeExtensions, configExtensions, markdownExtensions;
+var import_node_path9, codeExtensions, configExtensions, markdownExtensions, PYTHON_CALL_IGNORES;
 var init_languages = __esm({
   "../../packages/indexer/src/languages.ts"() {
     "use strict";
@@ -303032,6 +303274,30 @@ var init_languages = __esm({
       [".toml", "toml"]
     ]);
     markdownExtensions = /* @__PURE__ */ new Set([".md", ".mdx"]);
+    PYTHON_CALL_IGNORES = /* @__PURE__ */ new Set([
+      "if",
+      "for",
+      "while",
+      "with",
+      "return",
+      "yield",
+      "print",
+      "len",
+      "range",
+      "str",
+      "int",
+      "float",
+      "list",
+      "dict",
+      "set",
+      "tuple",
+      "bool",
+      "isinstance",
+      "issubclass",
+      "super",
+      "self",
+      "cls"
+    ]);
   }
 });
 
@@ -303104,7 +303370,10 @@ var init_scanner = __esm({
       "**/build/**",
       "**/coverage/**",
       "**/.turbo/**",
-      "**/.openez/**"
+      "**/.openez/**",
+      "**/pnpm-lock.yaml",
+      "**/package-lock.json",
+      "**/yarn.lock"
     ];
   }
 });
@@ -303141,24 +303410,68 @@ function createWorkspaceFileResolver(workspaceRoot, files) {
     }
     return null;
   }
+  function resolvePythonModulePath(modulePath) {
+    const basePath = normalizeRelativePath(modulePath.replace(/\./g, "/"));
+    const directPath = `${basePath}.py`;
+    if (knownRelativePaths.has(directPath)) return directPath;
+    const initPath = `${basePath}/__init__.py`;
+    if (knownRelativePaths.has(initPath)) return initPath;
+    return null;
+  }
+  function resolvePythonRelativeImport(importerRelativePath, importPath) {
+    const dotMatch = /^(\.+)(.*)$/.exec(importPath);
+    if (!dotMatch) return null;
+    const level = dotMatch[1].length;
+    const remainder = dotMatch[2].replace(/^\./, "");
+    let baseDirectory = normalizeRelativePath(import_node_path11.default.dirname(importerRelativePath));
+    for (let index2 = 1; index2 < level; index2++) {
+      baseDirectory = normalizeRelativePath(import_node_path11.default.dirname(baseDirectory));
+    }
+    const modulePath = remainder ? normalizeRelativePath(import_node_path11.default.join(baseDirectory, remainder.replace(/\./g, "/"))) : baseDirectory;
+    return resolvePythonModulePath(modulePath);
+  }
+  function resolvePythonImport(importerRelativePath, importPath) {
+    if (importPath.startsWith(".")) {
+      const resolved = resolvePythonRelativeImport(importerRelativePath, importPath);
+      if (resolved) return resolved;
+    }
+    return resolvePythonModulePath(importPath);
+  }
   return {
-    resolveImport(importerRelativePath, importPath) {
-      if (!importPath.startsWith(".")) return null;
-      return resolveRelativeImport(importerRelativePath, importPath);
+    resolveImport(importerRelativePath, importPath, language) {
+      if (language === "python") {
+        const resolved = resolvePythonImport(importerRelativePath, importPath);
+        if (resolved) return resolved;
+      }
+      if (importPath.startsWith(".")) {
+        return resolveRelativeImport(importerRelativePath, importPath);
+      }
+      return null;
     }
   };
 }
 async function resetDocumentArtifacts(repo, documentId) {
   const chunks2 = await repo.getChunksByDocument(documentId);
   const chunkIds = chunks2.map((c) => c.id);
-  const allNodeIds = [documentId, ...chunkIds];
   if (chunkIds.length > 0) {
     await repo.deleteEmbeddingsByChunkIds(chunkIds);
   }
-  await repo.deleteEdgesByNodeIds(allNodeIds);
   await repo.deleteGraphNodesByRefId(documentId);
   await repo.deleteChunksByDocument(documentId);
 }
+function boundChunks(chunks2, targetTokens, overlapTokens) {
+  return chunks2.flatMap((chunk) => {
+    const parts = splitToTokenLimit(chunk.content, targetTokens, overlapTokens);
+    if (parts.length <= 1) return chunk;
+    return parts.map((content, splitIndex) => ({
+      ...chunk,
+      content,
+      tokenCount: countTokens2(content),
+      contentHash: hashContent(content),
+      metadata: { ...chunk.metadata, splitIndex, splitCount: parts.length }
+    }));
+  });
+}
 async function chunkDocument(input) {
   const info = inferDocumentKind(input.relativePath);
   if (info.kind === "markdown") {
@@ -303174,7 +303487,8 @@ async function chunkDocument(input) {
       importPaths: [],
       wikilinks: result.wikilinks,
       definedSymbols: [],
-      calledIdentifiers: []
+      calledIdentifiers: [],
+      callExpressions: []
     };
   }
   if (info.kind === "config") {
@@ -303186,7 +303500,8 @@ async function chunkDocument(input) {
       importPaths: [],
       wikilinks: [],
       definedSymbols: [],
-      calledIdentifiers: []
+      calledIdentifiers: [],
+      callExpressions: []
     };
   }
   if (info.kind === "code") {
@@ -303199,7 +303514,8 @@ async function chunkDocument(input) {
         importPaths: result.importPaths,
         wikilinks: [],
         definedSymbols: result.definedSymbols,
-        calledIdentifiers: result.calledIdentifiers
+        calledIdentifiers: result.calledIdentifiers,
+        callExpressions: result.callExpressions
       };
     }
     if (info.language === "python") {
@@ -303211,7 +303527,8 @@ async function chunkDocument(input) {
         importPaths: result.importPaths,
         wikilinks: [],
         definedSymbols: result.definedSymbols,
-        calledIdentifiers: result.calledIdentifiers
+        calledIdentifiers: result.calledIdentifiers,
+        callExpressions: result.callExpressions
       };
     }
     if (info.language === "go") {
@@ -303223,7 +303540,8 @@ async function chunkDocument(input) {
         importPaths: result.importPaths,
         wikilinks: [],
         definedSymbols: result.definedSymbols,
-        calledIdentifiers: result.calledIdentifiers
+        calledIdentifiers: result.calledIdentifiers,
+        callExpressions: result.callExpressions
       };
     }
     if (info.language === "rust") {
@@ -303235,7 +303553,8 @@ async function chunkDocument(input) {
         importPaths: result.importPaths,
         wikilinks: [],
         definedSymbols: result.definedSymbols,
-        calledIdentifiers: result.calledIdentifiers
+        calledIdentifiers: result.calledIdentifiers,
+        callExpressions: result.callExpressions
       };
     }
     const fallbackChunk2 = {
@@ -303256,7 +303575,8 @@ async function chunkDocument(input) {
       importPaths: [],
       wikilinks: [],
       definedSymbols: [],
-      calledIdentifiers: []
+      calledIdentifiers: [],
+      callExpressions: []
     };
   }
   const fallbackChunk = {
@@ -303276,19 +303596,33 @@ async function chunkDocument(input) {
     importPaths: [],
     wikilinks: [],
     definedSymbols: [],
-    calledIdentifiers: []
+    calledIdentifiers: [],
+    callExpressions: []
   };
 }
-async function writeEmbeddingsToRepo(repo, chunkRows) {
-  const provider = getEmbeddingProvider();
+async function writeEmbeddingsToRepo(repo, chunkRows, provider) {
   if (!provider || chunkRows.length === 0) {
     return 0;
   }
+  const existing = await repo.queryRaw(
+    `SELECT chunk_id FROM embeddings
+     WHERE provider = ? AND model = ? AND chunk_id IN (${chunkRows.map(() => "?").join(",")})`,
+    [provider.provider, embeddingStorageModel(provider), ...chunkRows.map((chunk) => chunk.id)]
+  );
+  const existingIds = new Set(existing.map((row) => String(row.chunk_id)));
+  const missingRows = chunkRows.filter((chunk) => !existingIds.has(chunk.id));
+  if (missingRows.length === 0) return 0;
   try {
-    const vectors = await provider.embed(chunkRows.map((chunk) => chunk.content));
+    const vectors = await provider.embed(
+      missingRows.map((chunk) => formatEmbeddingInput(provider, chunk, "document"))
+    );
+    if (vectors.length !== missingRows.length) {
+      console.error(`Embedding provider returned ${vectors.length} vectors for ${missingRows.length} chunks`);
+      return 0;
+    }
     const invalidEmbeddingIndex = vectors.findIndex((embedding) => embedding.length === 0);
     if (invalidEmbeddingIndex !== -1) {
-      console.error(`Embedding provider returned empty vector for chunk ${chunkRows[invalidEmbeddingIndex].id}`);
+      console.error(`Embedding provider returned empty vector for chunk ${missingRows[invalidEmbeddingIndex].id}`);
       return 0;
     }
     const dimensions = vectors[0]?.length ?? 0;
@@ -303298,9 +303632,9 @@ async function writeEmbeddingsToRepo(repo, chunkRows) {
     }
     await repo.insertEmbeddings(
       vectors.map((embedding, index2) => ({
-        chunkId: chunkRows[index2].id,
+        chunkId: missingRows[index2].id,
         provider: provider.provider,
-        model: provider.model,
+        model: embeddingStorageModel(provider),
         dimensions,
         embedding: JSON.stringify(embedding)
       }))
@@ -303328,20 +303662,36 @@ async function indexWorkspace(input) {
   await writeLocalWorkspaceConfig(workspace);
   const repo = createWorkspaceRepository(workspace.rootPath);
   const settings = await getBrainSettings();
+  const config2 = await loadBrainConfig(workspace.rootPath);
+  const configuredWorkspace = config2.workspaces?.find(
+    (candidate) => candidate.id === workspace.id || import_node_path11.default.resolve(candidate.root) === import_node_path11.default.resolve(workspace.rootPath)
+  );
+  const includeGlobs = workspace.includeGlobs || configuredWorkspace?.include.join("\n") || "";
+  const excludeGlobs = workspace.excludeGlobs || configuredWorkspace?.exclude.join("\n") || "";
+  const embeddingProvider = getEmbeddingProvider();
   const runMode = input.mode ?? "incremental";
   const reportProgress = async (message, progress) => {
     await input.onProgress?.({ message, progress });
   };
-  const runId = await repo.createIndexRun({ mode: runMode });
   if (runMode === "full") {
     await repo.resetAll();
   }
+  const runId = await repo.createIndexRun({ mode: runMode });
   await reportProgress("Scanning workspace files...", 5);
   const files = await scanWorkspaceFiles({
     rootPath: workspace.rootPath,
-    include: workspace.includeGlobs || "",
-    exclude: workspace.excludeGlobs || ""
+    include: includeGlobs,
+    exclude: excludeGlobs
   });
+  if (runMode === "incremental") {
+    const scannedPaths = new Set(files.map((file) => file.relativePath));
+    for (const document of await repo.listDocuments()) {
+      if (!scannedPaths.has(document.path)) {
+        await resetDocumentArtifacts(repo, document.id);
+        await repo.deleteDocument(document.id);
+      }
+    }
+  }
   const workspaceFileResolver = createWorkspaceFileResolver(
     workspace.rootPath,
     files.map((file) => ({
@@ -303352,6 +303702,8 @@ async function indexWorkspace(input) {
   let filesUpdated = 0;
   let chunksWritten = 0;
   let embeddingsWritten = 0;
+  const symbolNodeIdsByName = /* @__PURE__ */ new Map();
+  const pendingCallEdges = [];
   try {
     await reportProgress(
       files.length === 0 ? "No files matched the workspace filters" : `Queued ${files.length} file(s) for indexing`,
@@ -303363,7 +303715,19 @@ async function indexWorkspace(input) {
       const content = await import_promises7.default.readFile(file.absolutePath, "utf8");
       const contentHash = hashContent(content);
       const existingDocument = await repo.getDocumentByPath(file.relativePath);
-      if (runMode === "incremental" && existingDocument && existingDocument.contentHash === contentHash && existingDocument.mtimeMs === file.mtimeMs) {
+      const existingChunks = existingDocument ? await repo.getChunksByDocument(existingDocument.id) : [];
+      const unchanged = runMode === "incremental" && existingDocument && existingDocument.contentHash === contentHash && existingDocument.mtimeMs === file.mtimeMs;
+      if (unchanged) {
+        embeddingsWritten += await writeEmbeddingsToRepo(
+          repo,
+          existingChunks.map((chunk) => ({
+            id: chunk.id,
+            content: chunk.content,
+            path: existingDocument.path,
+            heading: chunk.heading
+          })),
+          embeddingProvider
+        );
         continue;
       }
       const indexed = await chunkDocument({
@@ -303373,6 +303737,7 @@ async function indexWorkspace(input) {
         targetTokens: settings.chunking.targetTokens,
         overlapTokens: settings.chunking.overlapTokens
       });
+      indexed.chunks = boundChunks(indexed.chunks, settings.chunking.targetTokens, settings.chunking.overlapTokens);
       let documentId;
       if (existingDocument) {
         await resetDocumentArtifacts(repo, existingDocument.id);
@@ -303450,10 +303815,11 @@ async function indexWorkspace(input) {
             toNodeId: chunkNodeId,
             type: "represented_by"
           });
+          symbolNodeIdsByName.set(symbolName, symbolNodeId);
         }
       }
       for (const importPath of indexed.importPaths) {
-        const resolvedImportPath = workspaceFileResolver.resolveImport(file.relativePath, importPath);
+        const resolvedImportPath = workspaceFileResolver?.resolveImport(file.relativePath, importPath, indexed.language ?? void 0);
         if (!resolvedImportPath) continue;
         const targetNodeId = await repo.upsertGraphNode({
           type: "file",
@@ -303479,43 +303845,33 @@ async function indexWorkspace(input) {
           type: "mentions"
         });
       }
-      if (indexed.definedSymbols.length > 0 && indexed.calledIdentifiers.length > 0) {
-        const symbolNodeIds = await Promise.all(
-          indexed.definedSymbols.map(
-            (symbol) => repo.upsertGraphNode({
-              type: "symbol",
-              label: symbol.name,
-              metadata: JSON.stringify({
-                symbolType: symbol.type,
-                exported: symbol.exported,
-                filePath: file.relativePath
-              })
-            })
-          )
-        );
-        for (const caller of indexed.calledIdentifiers) {
-          const callerIndex = indexed.definedSymbols.findIndex((s) => s.name === caller);
-          if (callerIndex === -1) continue;
-          const calleeNode = await repo.findGraphNode("symbol", caller);
-          if (calleeNode && symbolNodeIds[callerIndex] !== calleeNode.id) {
-            await repo.insertEdge({
-              fromNodeId: symbolNodeIds[callerIndex],
-              toNodeId: calleeNode.id,
-              type: "calls",
-              weight: 0.35,
-              metadata: JSON.stringify({ heuristic: true })
-            });
-          }
-        }
-      }
+      pendingCallEdges.push(...indexed.callExpressions);
       const chunkRows = chunkIds.map((id, i) => ({
         id,
-        content: indexed.chunks[i].content
+        content: indexed.chunks[i].content,
+        path: file.relativePath,
+        heading: indexed.chunks[i].heading
       }));
-      embeddingsWritten += await writeEmbeddingsToRepo(repo, chunkRows);
+      embeddingsWritten += await writeEmbeddingsToRepo(repo, chunkRows, embeddingProvider);
       chunksWritten += chunkIds.length;
       filesUpdated += 1;
     }
+    const insertedCallEdges = /* @__PURE__ */ new Set();
+    for (const callExpression of pendingCallEdges) {
+      const callerNodeId = symbolNodeIdsByName.get(callExpression.callerName) ?? (await repo.findGraphNode("symbol", callExpression.callerName))?.id;
+      const calleeNodeId = symbolNodeIdsByName.get(callExpression.calleeName) ?? (await repo.findGraphNode("symbol", callExpression.calleeName))?.id;
+      if (!callerNodeId || !calleeNodeId || callerNodeId === calleeNodeId) continue;
+      const edgeKey = `${callerNodeId}:${calleeNodeId}:calls`;
+      if (insertedCallEdges.has(edgeKey)) continue;
+      insertedCallEdges.add(edgeKey);
+      await repo.insertEdge({
+        fromNodeId: callerNodeId,
+        toNodeId: calleeNodeId,
+        type: "calls",
+        weight: 0.35,
+        metadata: JSON.stringify({ heuristic: true, callee: callExpression.calleeName })
+      });
+    }
     await reportProgress("Finalizing index run...", 98);
     await repo.completeIndexRun(runId, {
       status: "completed",
@@ -303588,7 +303944,8 @@ var init_index_workspace = __esm({
       ".mts",
       ".cts",
       ".md",
-      ".mdx"
+      ".mdx",
+      ".py"
     ];
   }
 });
@@ -318760,6 +319117,15 @@ var init_mcp_bridge = __esm({
 });
 
 // ../web/src/server/sqlite.ts
+function getRequireUrl2() {
+  try {
+    if (typeof import_meta3 !== "undefined" && import_meta3.url) {
+      return import_meta3.url;
+    }
+  } catch {
+  }
+  return `file://${__filename}`;
+}
 function safeParseJson3(value, fallback) {
   if (!value) return fallback;
   try {
@@ -318947,6 +319313,9 @@ function initializeWorkspaceSchema2(db) {
 }
 function getWorkspaceDb2(rootPath) {
   const normalized = normalizeRootPath2(rootPath);
+  if (normalized === "/" || normalized === "" || !import_node_fs9.default.existsSync(normalized)) {
+    throw new Error(`Workspace root path does not exist: "${rootPath}"`);
+  }
   const cached2 = workspaceDbs.get(normalized);
   if (cached2) {
     return cached2;
@@ -319162,9 +319531,7 @@ var init_sqlite2 = __esm({
     import_node_path13 = __toESM(require("path"), 1);
     import_node_module2 = require("module");
     import_meta3 = {};
-    require2 = (0, import_node_module2.createRequire)(
-      typeof import_meta3 !== "undefined" && import_meta3.url ? import_meta3.url : `file://${__filename}`
-    );
+    require2 = (0, import_node_module2.createRequire)(getRequireUrl2());
     Database = require2("better-sqlite3");
     registryDb2 = null;
     workspaceDbs = /* @__PURE__ */ new Map();
@@ -319185,6 +319552,15 @@ var init_sqlite2 = __esm({
 });
 
 // ../web/src/server/index.ts
+function getDirname() {
+  try {
+    if (typeof import_meta4 !== "undefined" && import_meta4.url) {
+      return import_node_path14.default.dirname(new URL(import_meta4.url).pathname);
+    }
+  } catch {
+  }
+  return typeof __dirname2 !== "undefined" ? __dirname2 : process.cwd();
+}
 function mapWorkspace2(ws) {
   return {
     id: ws.id,
@@ -319207,10 +319583,10 @@ function mapWorkspace2(ws) {
   };
 }
 function resolveWebDist() {
-  const sourceDist = import_node_path14.default.resolve(__dirname, "..", "dist");
-  if ((0, import_node_fs11.existsSync)(import_node_path14.default.join(sourceDist, "index.html"))) return sourceDist;
-  const cliDist = import_node_path14.default.resolve(__dirname, "web");
-  if ((0, import_node_fs11.existsSync)(import_node_path14.default.join(cliDist, "index.html"))) return cliDist;
+  const sourceDist = import_node_path14.default.resolve(__dirname2, "..", "dist");
+  if ((0, import_node_fs10.existsSync)(import_node_path14.default.join(sourceDist, "index.html"))) return sourceDist;
+  const cliDist = import_node_path14.default.resolve(__dirname2, "web");
+  if ((0, import_node_fs10.existsSync)(import_node_path14.default.join(cliDist, "index.html"))) return cliDist;
   return null;
 }
 function createWebServer() {
@@ -319219,31 +319595,40 @@ function createWebServer() {
     app.use("/*", (0, import_serve_static.serveStatic)({ root: webDist, rewriteRequestPath: (p) => p }));
     app.get("*", (c) => {
       const indexPath = import_node_path14.default.join(webDist, "index.html");
-      const index2 = (0, import_node_fs11.readFileSync)(indexPath, "utf-8");
+      const index2 = (0, import_node_fs10.readFileSync)(indexPath, "utf-8");
       return c.html(index2);
     });
   }
   return app;
 }
-var import_hono, import_cors, import_serve_static, import_node_crypto3, import_node_fs10, import_node_fs11, import_node_path14, app, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS;
+var import_serve_static, import_hono, import_cors, import_node_crypto3, import_node_fs10, import_node_path14, import_meta4, __dirname2, app, DEFAULT_INCLUDE_GLOBS, DEFAULT_EXCLUDE_GLOBS;
 var init_server3 = __esm({
   "../web/src/server/index.ts"() {
     "use strict";
+    import_serve_static = require("@hono/node-server/serve-static");
     import_hono = require("hono");
     import_cors = require("hono/cors");
-    import_serve_static = require("@hono/node-server/serve-static");
     import_node_crypto3 = __toESM(require("crypto"), 1);
     import_node_fs10 = require("fs");
-    import_node_fs11 = require("fs");
     import_node_path14 = __toESM(require("path"), 1);
     init_sqlite2();
     init_src3();
     init_src();
+    import_meta4 = {};
+    __dirname2 = getDirname();
     app = new import_hono.Hono();
-    app.use("/*", (0, import_cors.cors)({
-      origin: ["http://localhost:5173", "http://127.0.0.1:5173", "http://localhost:11368", "http://127.0.0.1:11368"],
-      credentials: true
-    }));
+    app.use(
+      "/*",
+      (0, import_cors.cors)({
+        origin: [
+          "http://localhost:5173",
+          "http://127.0.0.1:5173",
+          "http://localhost:11368",
+          "http://127.0.0.1:11368"
+        ],
+        credentials: true
+      })
+    );
     DEFAULT_INCLUDE_GLOBS = [
       "src/**/*.{ts,tsx,js,jsx}",
       "app/**/*.{ts,tsx}",
@@ -319264,11 +319649,23 @@ var init_server3 = __esm({
     app.get("/api/dashboard", (c) => {
       try {
         const all = listRegistryWorkspaces();
-        const target = all[0];
+        const target = all.find((ws) => {
+          try {
+            return ws.rootPath && ws.rootPath !== "/" && (0, import_node_fs10.existsSync)(ws.rootPath);
+          } catch {
+            return false;
+          }
+        }) ?? all[0];
         if (!target) {
           return c.json({
             workspace: { id: "", name: "No workspace", root: "" },
-            stats: { documents: 0, chunks: 0, graphNodes: 0, graphEdges: 0, memories: 0 },
+            stats: {
+              documents: 0,
+              chunks: 0,
+              graphNodes: 0,
+              graphEdges: 0,
+              memories: 0
+            },
             recentRuns: [],
             recentDocuments: [],
             recentMemories: [],
@@ -319295,7 +319692,13 @@ var init_server3 = __esm({
         console.error("Dashboard error:", err);
         return c.json({
           workspace: { id: "", name: "No workspace", root: "" },
-          stats: { documents: 0, chunks: 0, graphNodes: 0, graphEdges: 0, memories: 0 },
+          stats: {
+            documents: 0,
+            chunks: 0,
+            graphNodes: 0,
+            graphEdges: 0,
+            memories: 0
+          },
           recentRuns: [],
           recentDocuments: [],
           recentMemories: [],
@@ -319335,25 +319738,42 @@ var init_server3 = __esm({
       if (!rootPath) return c.json({ valid: false, error: "Path is required" });
       try {
         const stats = await import_node_fs10.promises.stat(rootPath);
-        if (!stats.isDirectory()) return c.json({ valid: false, error: "Path is not a directory" });
+        if (!stats.isDirectory())
+          return c.json({ valid: false, error: "Path is not a directory" });
         return c.json({ valid: true });
       } catch {
-        return c.json({ valid: false, error: "Directory does not exist or is not accessible" });
+        return c.json({
+          valid: false,
+          error: "Directory does not exist or is not accessible"
+        });
       }
     });
     app.get("/api/workspaces", (c) => {
       try {
         const dbPath = resolveRegistryDbPath2();
         const all = listRegistryWorkspaces();
-        const data = all.map((ws) => ({
-          ...mapWorkspace2(ws),
-          latestIndexRun: getLatestIndexRun(ws.rootPath),
-          latestGraphRun: getLatestGraphRun(ws.rootPath)
-        }));
+        const data = all.map((ws) => {
+          let latestIndexRun = null;
+          let latestGraphRun = null;
+          try {
+            latestIndexRun = getLatestIndexRun(ws.rootPath);
+            latestGraphRun = getLatestGraphRun(ws.rootPath);
+          } catch {
+          }
+          return {
+            ...mapWorkspace2(ws),
+            latestIndexRun,
+            latestGraphRun
+          };
+        });
         return c.json({ ok: true, data });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return c.json({ ok: false, error: message, dbPath: resolveRegistryDbPath2() });
+        return c.json({
+          ok: false,
+          error: message,
+          dbPath: resolveRegistryDbPath2()
+        });
       }
     });
     app.get("/api/workspaces/:id", (c) => {
@@ -319371,19 +319791,28 @@ var init_server3 = __esm({
         return c.json({ ok: true, data });
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
-        return c.json({ ok: false, error: message, dbPath: resolveRegistryDbPath2() });
+        return c.json({
+          ok: false,
+          error: message,
+          dbPath: resolveRegistryDbPath2()
+        });
       }
     });
     app.post("/api/workspaces", async (c) => {
       try {
         const body = await c.req.json();
         const rootPath = body.rootPath;
-        if (!rootPath) return c.json({ success: false, error: "rootPath is required" });
+        if (!rootPath)
+          return c.json({ success: false, error: "rootPath is required" });
         try {
           const stats = await import_node_fs10.promises.stat(rootPath);
-          if (!stats.isDirectory()) return c.json({ success: false, error: "Path is not a directory" });
+          if (!stats.isDirectory())
+            return c.json({ success: false, error: "Path is not a directory" });
         } catch {
-          return c.json({ success: false, error: "Directory does not exist or is not accessible" });
+          return c.json({
+            success: false,
+            error: "Directory does not exist or is not accessible"
+          });
         }
         const ws = ensureRegistryWorkspace({
           name: body.name?.trim() || import_node_path14.default.basename(rootPath),
@@ -319393,7 +319822,11 @@ var init_server3 = __esm({
         });
         return c.json({
           success: true,
-          workspace: { ...mapWorkspace2(ws), latestIndexRun: null, latestGraphRun: null }
+          workspace: {
+            ...mapWorkspace2(ws),
+            latestIndexRun: null,
+            latestGraphRun: null
+          }
         });
       } catch (err) {
         console.error("Failed to create workspace:", err);
@@ -319419,7 +319852,11 @@ var init_server3 = __esm({
     app.post("/api/workspaces/:id/index", async (c) => {
       const id = c.req.param("id");
       const ws = getRegistryWorkspace(id);
-      if (!ws) return c.json({ jobId: null, status: "error", error: "Workspace not found" }, 404);
+      if (!ws)
+        return c.json(
+          { jobId: null, status: "error", error: "Workspace not found" },
+          404
+        );
       const body = await c.req.json().catch(() => ({ mode: "incremental" }));
       updateRegistryWorkspace(id, {
         indexingStatus: "running",
@@ -319593,8 +320030,11 @@ function getThisDir() {
   if (typeof __dirname !== "undefined") {
     return __dirname;
   }
-  if (typeof import_meta4 !== "undefined" && import_meta4.dirname) {
-    return import_meta4.dirname;
+  try {
+    if (typeof import_meta5 !== "undefined" && import_meta5.dirname) {
+      return import_meta5.dirname;
+    }
+  } catch {
   }
   return process.cwd();
 }
@@ -319611,7 +320051,7 @@ function resolveCliInvocation() {
   }
   const repoRoot = import_node_path15.default.resolve(thisDir, "../../..");
   const builtCliPath = import_node_path15.default.resolve(thisDir, "../dist/cli.cjs");
-  if (import_node_fs12.default.existsSync(builtCliPath)) {
+  if (import_node_fs11.default.existsSync(builtCliPath)) {
     return {
       command: process.execPath,
       args: [builtCliPath, "serve", "--mcp"],
@@ -319626,13 +320066,13 @@ function resolveCliInvocation() {
     repoRoot
   };
 }
-var import_node_fs12, import_node_path15, import_meta4;
+var import_node_fs11, import_node_path15, import_meta5;
 var init_resolve_cli = __esm({
   "src/resolve-cli.ts"() {
     "use strict";
-    import_node_fs12 = __toESM(require("fs"), 1);
+    import_node_fs11 = __toESM(require("fs"), 1);
     import_node_path15 = __toESM(require("path"), 1);
-    import_meta4 = {};
+    import_meta5 = {};
   }
 });
 
@@ -320549,11 +320989,11 @@ function getCodexConfigPath() {
 }
 async function setupCodex(rootPath) {
   const resolvedPath = import_node_path16.default.resolve(rootPath);
-  if (!import_node_fs13.default.existsSync(resolvedPath)) {
+  if (!import_node_fs12.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs13.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs12.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320561,12 +321001,12 @@ async function setupCodex(rootPath) {
   const label = "openez";
   const configPath = getCodexConfigPath();
   const configDir = import_node_path16.default.dirname(configPath);
-  if (!import_node_fs13.default.existsSync(configDir)) {
-    import_node_fs13.default.mkdirSync(configDir, { recursive: true, mode: 493 });
+  if (!import_node_fs12.default.existsSync(configDir)) {
+    import_node_fs12.default.mkdirSync(configDir, { recursive: true, mode: 493 });
   }
   let config2 = {};
-  if (import_node_fs13.default.existsSync(configPath)) {
-    const raw = import_node_fs13.default.readFileSync(configPath, "utf-8");
+  if (import_node_fs12.default.existsSync(configPath)) {
+    const raw = import_node_fs12.default.readFileSync(configPath, "utf-8");
     try {
       config2 = parse3(raw);
     } catch {
@@ -320584,8 +321024,8 @@ async function setupCodex(rootPath) {
   };
   mcpServers[label] = entry;
   const output = stringify2(config2);
-  import_node_fs13.default.writeFileSync(configPath, output, "utf-8");
-  import_node_fs13.default.chmodSync(configPath, 420);
+  import_node_fs12.default.writeFileSync(configPath, output, "utf-8");
+  import_node_fs12.default.chmodSync(configPath, 420);
   console.log(`Codex MCP server configured: '${label}'`);
   console.log("  Mode:    shared multi-workspace MCP");
   console.log(`  Repo:    ${repoRoot}`);
@@ -320593,11 +321033,11 @@ async function setupCodex(rootPath) {
   console.log("");
   console.log("Restart Codex or open a new session for the changes to take effect.");
 }
-var import_node_fs13, import_node_os3, import_node_path16;
+var import_node_fs12, import_node_os3, import_node_path16;
 var init_setup_codex = __esm({
   "src/setup-codex.ts"() {
     "use strict";
-    import_node_fs13 = __toESM(require("fs"), 1);
+    import_node_fs12 = __toESM(require("fs"), 1);
     import_node_os3 = __toESM(require("os"), 1);
     import_node_path16 = __toESM(require("path"), 1);
     init_resolve_cli();
@@ -320615,11 +321055,11 @@ function getClaudeConfigPath() {
 }
 async function setupClaude(rootPath) {
   const resolvedPath = import_node_path17.default.resolve(rootPath);
-  if (!import_node_fs14.default.existsSync(resolvedPath)) {
+  if (!import_node_fs13.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs14.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs13.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320627,12 +321067,12 @@ async function setupClaude(rootPath) {
   const label = "openez";
   const configPath = getClaudeConfigPath();
   const configDir = import_node_path17.default.dirname(configPath);
-  if (!import_node_fs14.default.existsSync(configDir)) {
-    import_node_fs14.default.mkdirSync(configDir, { recursive: true, mode: 493 });
+  if (!import_node_fs13.default.existsSync(configDir)) {
+    import_node_fs13.default.mkdirSync(configDir, { recursive: true, mode: 493 });
   }
   let config2 = {};
-  if (import_node_fs14.default.existsSync(configPath)) {
-    const raw = import_node_fs14.default.readFileSync(configPath, "utf-8");
+  if (import_node_fs13.default.existsSync(configPath)) {
+    const raw = import_node_fs13.default.readFileSync(configPath, "utf-8");
     try {
       config2 = JSON.parse(raw);
     } catch {
@@ -320648,8 +321088,8 @@ async function setupClaude(rootPath) {
     args,
     startupTimeoutSec: 120
   };
-  import_node_fs14.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-  import_node_fs14.default.chmodSync(configPath, 420);
+  import_node_fs13.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  import_node_fs13.default.chmodSync(configPath, 420);
   console.log(`Claude Code MCP server configured: '${label}'`);
   console.log("  Mode:    shared multi-workspace MCP");
   console.log(`  Repo:    ${repoRoot}`);
@@ -320657,11 +321097,11 @@ async function setupClaude(rootPath) {
   console.log("");
   console.log("Restart Claude Code or open a new session for the changes to take effect.");
 }
-var import_node_fs14, import_node_os4, import_node_path17;
+var import_node_fs13, import_node_os4, import_node_path17;
 var init_setup_claude = __esm({
   "src/setup-claude.ts"() {
     "use strict";
-    import_node_fs14 = __toESM(require("fs"), 1);
+    import_node_fs13 = __toESM(require("fs"), 1);
     import_node_os4 = __toESM(require("os"), 1);
     import_node_path17 = __toESM(require("path"), 1);
     init_resolve_cli();
@@ -320678,11 +321118,11 @@ function getOpenCodeConfigPath() {
 }
 async function setupOpenCode(rootPath) {
   const resolvedPath = import_node_path18.default.resolve(rootPath);
-  if (!import_node_fs15.default.existsSync(resolvedPath)) {
+  if (!import_node_fs14.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs15.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs14.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }
@@ -320690,12 +321130,12 @@ async function setupOpenCode(rootPath) {
   const label = "openez";
   const configPath = getOpenCodeConfigPath();
   const configDir = import_node_path18.default.dirname(configPath);
-  if (!import_node_fs15.default.existsSync(configDir)) {
-    import_node_fs15.default.mkdirSync(configDir, { recursive: true, mode: 493 });
+  if (!import_node_fs14.default.existsSync(configDir)) {
+    import_node_fs14.default.mkdirSync(configDir, { recursive: true, mode: 493 });
   }
   let config2 = {};
-  if (import_node_fs15.default.existsSync(configPath)) {
-    const raw = import_node_fs15.default.readFileSync(configPath, "utf-8");
+  if (import_node_fs14.default.existsSync(configPath)) {
+    const raw = import_node_fs14.default.readFileSync(configPath, "utf-8");
     try {
       config2 = JSON.parse(raw);
     } catch {
@@ -320710,8 +321150,8 @@ async function setupOpenCode(rootPath) {
     command,
     args
   };
-  import_node_fs15.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-  import_node_fs15.default.chmodSync(configPath, 420);
+  import_node_fs14.default.writeFileSync(configPath, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  import_node_fs14.default.chmodSync(configPath, 420);
   console.log(`OpenCode MCP server configured: '${label}'`);
   console.log("  Mode:    shared multi-workspace MCP");
   console.log(`  Repo:    ${repoRoot}`);
@@ -320719,11 +321159,11 @@ async function setupOpenCode(rootPath) {
   console.log("");
   console.log("Restart OpenCode or open a new session for the changes to take effect.");
 }
-var import_node_fs15, import_node_os5, import_node_path18;
+var import_node_fs14, import_node_os5, import_node_path18;
 var init_setup_opencode = __esm({
   "src/setup-opencode.ts"() {
     "use strict";
-    import_node_fs15 = __toESM(require("fs"), 1);
+    import_node_fs14 = __toESM(require("fs"), 1);
     import_node_os5 = __toESM(require("os"), 1);
     import_node_path18 = __toESM(require("path"), 1);
     init_resolve_cli();
@@ -320731,7 +321171,7 @@ var init_setup_opencode = __esm({
 });
 
 // src/cli.ts
-var import_node_fs16 = __toESM(require("fs"), 1);
+var import_node_fs15 = __toESM(require("fs"), 1);
 var import_node_path19 = __toESM(require("path"), 1);
 init_esm2();
 
@@ -320756,14 +321196,14 @@ var {
 init_src();
 init_src4();
 var program2 = new Command();
-program2.name("openez").description("OpenEZ Graph - Local-first knowledge retrieval system").version("0.3.0");
+program2.name("openez").description("OpenEZ Graph - Local-first knowledge retrieval system").version("0.4.0");
 program2.command("init").description("Initialize a workspace at the given path and run initial index").argument("[path]", "path to the project directory", process.cwd()).option("--no-index", "skip initial indexing").action(async (targetPath, options) => {
   const resolvedPath = import_node_path19.default.resolve(targetPath);
-  if (!import_node_fs16.default.existsSync(resolvedPath)) {
+  if (!import_node_fs15.default.existsSync(resolvedPath)) {
     console.error(`Error: path does not exist: ${resolvedPath}`);
     process.exit(1);
   }
-  if (!import_node_fs16.default.statSync(resolvedPath).isDirectory()) {
+  if (!import_node_fs15.default.statSync(resolvedPath).isDirectory()) {
     console.error(`Error: path is not a directory: ${resolvedPath}`);
     process.exit(1);
   }