@ngommans/codefocus 0.1.3 → 0.1.4

package/dist/mcp-server.js

@@ -1,559 +1,28 @@
 #!/usr/bin/env node
 import {
-  IndexDatabase,
   resolveRoot
-} from "./chunk-ITVAEU6K.js";
+} from "./chunk-ZIVIJRW3.js";
+import {
+  indexProject
+} from "./chunk-FQ3L6YEU.js";
+import {
+  IndexDatabase
+} from "./chunk-472RLVFC.js";
 
 // src/mcp.ts
-import { createRequire as createRequire3 } from "module";
-import { resolve as resolve2 } from "path";
+import { createRequire } from "module";
+import { resolve } from "path";
 import { existsSync } from "fs";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-
-// src/indexer.ts
-import { createRequire as createRequire2 } from "module";
-import { readFileSync } from "fs";
-import { resolve, relative, dirname, extname } from "path";
-import { createHash } from "crypto";
-
-// src/parser.ts
-import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
-var Parser = require2("tree-sitter");
-var TypeScriptLang = require2("tree-sitter-typescript").typescript;
-var parser = null;
-function getParser() {
-  if (!parser) {
-    parser = new Parser();
-    parser.setLanguage(TypeScriptLang);
-  }
-  return parser;
-}
-function extractSignature(node, source) {
-  const kind = node.type;
-  if (kind === "function_declaration" || kind === "arrow_function") {
-    const nameNode = node.childForFieldName("name");
-    const paramsNode = node.childForFieldName("parameters");
-    const returnType = node.childForFieldName("return_type");
-    if (nameNode && paramsNode) {
-      let sig = `function ${nameNode.text}${paramsNode.text}`;
-      if (returnType) sig += returnType.text;
-      return sig;
-    }
-  }
-  if (kind === "class_declaration") {
-    const nameNode = node.childForFieldName("name");
-    if (nameNode) return `class ${nameNode.text}`;
-  }
-  if (kind === "interface_declaration") {
-    const nameNode = node.childForFieldName("name");
-    if (nameNode) return `interface ${nameNode.text}`;
-  }
-  if (kind === "type_alias_declaration") {
-    const text = node.text;
-    const semiIdx = text.indexOf(";");
-    return semiIdx > 0 ? text.slice(0, semiIdx) : text;
-  }
-  if (kind === "enum_declaration") {
-    const nameNode = node.childForFieldName("name");
-    if (nameNode) return `enum ${nameNode.text}`;
-  }
-  if (kind === "method_definition") {
-    const nameNode = node.childForFieldName("name");
-    const paramsNode = node.childForFieldName("parameters");
-    const returnType = node.childForFieldName("return_type");
-    if (nameNode && paramsNode) {
-      let sig = `${nameNode.text}${paramsNode.text}`;
-      if (returnType) sig += returnType.text;
-      return sig;
-    }
-  }
-  return null;
-}
-function getSymbolName(node) {
-  const nameNode = node.childForFieldName("name") ?? node.childForFieldName("declarator");
-  return nameNode?.text ?? null;
-}
-function extractDeclaration(node, source, exported) {
-  const kindMap = {
-    function_declaration: "function",
-    class_declaration: "class",
-    interface_declaration: "interface",
-    type_alias_declaration: "type",
-    enum_declaration: "enum"
-  };
-  const kind = kindMap[node.type];
-  if (!kind) return null;
-  const name = getSymbolName(node);
-  if (!name) return null;
-  return {
-    name,
-    kind,
-    startByte: node.startIndex,
-    endByte: node.endIndex,
-    startLine: node.startPosition.row + 1,
-    endLine: node.endPosition.row + 1,
-    startColumn: node.startPosition.column,
-    endColumn: node.endPosition.column,
-    signature: extractSignature(node, source),
-    exported
-  };
-}
-function extractMethods(classNode, source, exported) {
-  const methods = [];
-  const body = classNode.childForFieldName("body");
-  if (!body) return methods;
-  for (const child of body.namedChildren) {
-    if (child.type === "method_definition") {
-      const nameNode = child.childForFieldName("name");
-      if (!nameNode) continue;
-      methods.push({
-        name: nameNode.text,
-        kind: "method",
-        startByte: child.startIndex,
-        endByte: child.endIndex,
-        startLine: child.startPosition.row + 1,
-        endLine: child.endPosition.row + 1,
-        startColumn: child.startPosition.column,
-        endColumn: child.endPosition.column,
-        signature: extractSignature(child, source),
-        exported
-      });
-    }
-  }
-  return methods;
-}
-function extractVariableDeclarations(node, exported) {
-  const symbols = [];
-  for (const child of node.namedChildren) {
-    if (child.type === "variable_declarator") {
-      const nameNode = child.childForFieldName("name");
-      if (nameNode) {
-        symbols.push({
-          name: nameNode.text,
-          kind: "variable",
-          startByte: node.startIndex,
-          endByte: node.endIndex,
-          startLine: node.startPosition.row + 1,
-          endLine: node.endPosition.row + 1,
-          startColumn: node.startPosition.column,
-          endColumn: node.endPosition.column,
-          signature: null,
-          exported
-        });
-      }
-    }
-  }
-  return symbols;
-}
-function extractImport(node) {
-  let sourceNode = null;
-  for (const child of node.children) {
-    if (child.type === "string") {
-      sourceNode = child;
-      break;
-    }
-  }
-  if (!sourceNode) return null;
-  const rawSource = sourceNode.text;
-  const source = rawSource.replace(/^['"]|['"]$/g, "");
-  const specifiers = [];
-  const isTypeOnly = node.children.some(
-    (c) => c.type === "type" && c.text === "type"
-  );
-  for (const child of node.children) {
-    if (child.type === "import_clause") {
-      for (const clause of child.namedChildren) {
-        if (clause.type === "named_imports") {
-          for (const spec of clause.namedChildren) {
-            if (spec.type === "import_specifier") {
-              const nameNode = spec.childForFieldName("name");
-              const aliasNode = spec.childForFieldName("alias");
-              specifiers.push(aliasNode?.text ?? nameNode?.text ?? spec.text);
-            }
-          }
-        } else if (clause.type === "identifier") {
-          specifiers.push(clause.text);
-        } else if (clause.type === "namespace_import") {
-          const nameNode = clause.namedChildren.find(
-            (c) => c.type === "identifier"
-          );
-          if (nameNode) specifiers.push(`* as ${nameNode.text}`);
-        }
-      }
-    }
-  }
-  return { specifiers, source, isTypeOnly };
-}
-function extractReExportSpecifiers(node) {
-  const specifiers = [];
-  for (const child of node.children) {
-    if (child.type === "export_clause") {
-      for (const spec of child.namedChildren) {
-        if (spec.type === "export_specifier") {
-          const nameNode = spec.childForFieldName("name");
-          if (nameNode) specifiers.push(nameNode.text);
-        }
-      }
-    }
-  }
-  return specifiers;
-}
-function findIdentifierUsages(source, names) {
-  if (names.size === 0) return [];
-  const p = getParser();
-  const tree = p.parse(source);
-  const root = tree.rootNode;
-  const usages = [];
-  function walk(node) {
-    if ((node.type === "identifier" || node.type === "type_identifier") && names.has(node.text)) {
-      let parent = node.parent;
-      let isImportExport = false;
-      while (parent) {
-        if (parent.type === "import_statement" || parent.type === "import_clause" || parent.type === "import_specifier" || parent.type === "export_statement" && parent.children.some((c) => c.type === "from")) {
-          isImportExport = true;
-          break;
-        }
-        parent = parent.parent;
-      }
-      if (!isImportExport) {
-        usages.push({
-          name: node.text,
-          line: node.startPosition.row + 1,
-          column: node.startPosition.column
-        });
-      }
-    }
-    for (const child of node.children) {
-      walk(child);
-    }
-  }
-  walk(root);
-  return usages;
-}
-function extractDynamicImports(root) {
-  const imports = [];
-  function walk(node) {
-    if (node.type === "call_expression") {
-      const fn = node.child(0);
-      if (fn && fn.type === "import") {
-        const argsNode = node.childForFieldName("arguments");
-        if (argsNode) {
-          const strArg = argsNode.namedChildren.find(
-            (c) => c.type === "string"
-          );
-          if (strArg) {
-            const modulePath = strArg.text.replace(/^['"]|['"]$/g, "");
-            const specifiers = extractDynamicImportSpecifiers(node);
-            imports.push({ specifiers, source: modulePath, isTypeOnly: false });
-          }
-        }
-        return;
-      }
-    }
-    for (const child of node.children) {
-      walk(child);
-    }
-  }
-  walk(root);
-  return imports;
-}
-function extractDynamicImportSpecifiers(importCall) {
-  let current = importCall.parent;
-  if (current && current.type === "await_expression") {
-    current = current.parent;
-  }
-  if (current && current.type === "variable_declarator") {
-    const pattern = current.childForFieldName("name");
-    if (pattern && pattern.type === "object_pattern") {
-      const specs = [];
-      for (const child of pattern.namedChildren) {
-        if (child.type === "shorthand_property_identifier_pattern") {
-          specs.push(child.text);
-        } else if (child.type === "pair_pattern") {
-          const value = child.childForFieldName("value");
-          if (value) specs.push(value.text);
-        }
-      }
-      return specs;
-    }
-  }
-  return [];
-}
-function parseSource(source) {
-  const p = getParser();
-  const tree = p.parse(source);
-  const root = tree.rootNode;
-  const symbols = [];
-  const imports = [];
-  for (const node of root.namedChildren) {
-    if (node.type === "import_statement") {
-      const imp = extractImport(node);
-      if (imp) imports.push(imp);
-      continue;
-    }
-    if (node.type === "export_statement") {
-      const hasFrom = node.children.some(
-        (c) => c.type === "from"
-      );
-      if (hasFrom) {
-        let sourceNode = null;
-        for (const child of node.children) {
-          if (child.type === "string") {
-            sourceNode = child;
-            break;
-          }
-        }
-        if (sourceNode) {
-          const rawSource = sourceNode.text;
-          const source2 = rawSource.replace(/^['"]|['"]$/g, "");
-          const specifiers = extractReExportSpecifiers(node);
-          const isTypeOnly = node.children.some(
-            (c) => c.type === "type" && c.text === "type"
-          );
-          imports.push({ specifiers, source: source2, isTypeOnly });
-        }
-        continue;
-      }
-      for (const child of node.namedChildren) {
-        const decl2 = extractDeclaration(child, source, true);
-        if (decl2) {
-          symbols.push(decl2);
-          if (child.type === "class_declaration") {
-            symbols.push(...extractMethods(child, source, true));
-          }
-        }
-        if (child.type === "lexical_declaration" || child.type === "variable_declaration") {
-          symbols.push(...extractVariableDeclarations(child, true));
-        }
-      }
-      continue;
-    }
-    const decl = extractDeclaration(node, source, false);
-    if (decl) {
-      symbols.push(decl);
-      if (node.type === "class_declaration") {
-        symbols.push(...extractMethods(node, source, false));
-      }
-    }
-    if (node.type === "lexical_declaration" || node.type === "variable_declaration") {
-      symbols.push(...extractVariableDeclarations(node, false));
-    }
-  }
-  imports.push(...extractDynamicImports(root));
-  return { symbols, imports };
-}
-
-// src/indexer.ts
-var require3 = createRequire2(import.meta.url);
-var fg = require3("fast-glob");
-var TS_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
-var IGNORE_PATTERNS = [
-  "**/node_modules/**",
-  "**/dist/**",
-  "**/.codefocus/**",
-  "**/__tests__/**",
-  "**/*.test.*",
-  "**/*.spec.*",
-  "**/*.d.ts"
-];
-function hashContent(content) {
-  return createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-function resolveImportPath(importSource, fromFile, rootDir2, allFiles) {
-  if (!importSource.startsWith(".")) return null;
-  const fromDir = dirname(fromFile);
-  const basePath = resolve(rootDir2, fromDir, importSource);
-  const ext = extname(basePath);
-  const strippedBase = ext === ".js" || ext === ".jsx" ? basePath.slice(0, -ext.length) : null;
-  const candidates = [
-    basePath,
-    ...Array.from(TS_EXTENSIONS).map((e) => basePath + e),
-    ...Array.from(TS_EXTENSIONS).map((e) => resolve(basePath, "index" + e))
-  ];
-  if (strippedBase) {
-    candidates.push(
-      ...Array.from(TS_EXTENSIONS).map((e) => strippedBase + e),
-      ...Array.from(TS_EXTENSIONS).map(
-        (e) => resolve(strippedBase, "index" + e)
-      )
-    );
-  }
-  for (const candidate of candidates) {
-    const rel = relative(rootDir2, candidate);
-    if (allFiles.has(rel)) return rel;
-  }
-  return null;
-}
-async function indexProject(rootDir2, dbPath) {
-  const startTime = Date.now();
-  const absRoot = resolve(rootDir2);
-  const files = await fg("**/*.{ts,tsx,js,jsx}", {
-    cwd: absRoot,
-    ignore: IGNORE_PATTERNS,
-    absolute: false
-  });
-  const allFiles = new Set(files);
-  const db2 = new IndexDatabase(dbPath);
-  let filesIndexed = 0;
-  let filesSkipped = 0;
-  let symbolsExtracted = 0;
-  let importsFound = 0;
-  let referencesCreated = 0;
-  const symbolIdMap = /* @__PURE__ */ new Map();
-  const fileImports = /* @__PURE__ */ new Map();
-  const fileContents = /* @__PURE__ */ new Map();
-  db2.transaction(() => {
-    for (const filePath of files) {
-      const absPath = resolve(absRoot, filePath);
-      let content;
-      try {
-        content = readFileSync(absPath, "utf-8");
-      } catch {
-        filesSkipped++;
-        continue;
-      }
-      const hash = hashContent(content);
-      const existingHash = db2.getFileHash(filePath);
-      const result = parseSource(content);
-      if (result.imports.length > 0) {
-        fileImports.set(filePath, result.imports);
-        fileContents.set(filePath, content);
-      }
-      if (existingHash === hash) {
-        filesSkipped++;
-        for (const sym of db2.getSymbolsByFile(filePath)) {
-          symbolIdMap.set(`${filePath}:${sym.name}`, sym.id);
-        }
-        continue;
-      }
-      db2.clearFile(filePath);
-      const ext = extname(filePath);
-      const language = ext === ".js" || ext === ".jsx" ? "javascript" : "typescript";
-      db2.upsertFile({
-        path: filePath,
-        content_hash: hash,
-        language,
-        last_indexed: Date.now()
-      });
-      db2.upsertFileContent(filePath, content);
-      for (const sym of result.symbols) {
-        const id = db2.insertSymbol({
-          file_path: filePath,
-          name: sym.name,
-          kind: sym.kind,
-          start_byte: sym.startByte,
-          end_byte: sym.endByte,
-          start_line: sym.startLine,
-          end_line: sym.endLine,
-          start_column: sym.startColumn,
-          end_column: sym.endColumn,
-          signature: sym.signature
-        });
-        symbolIdMap.set(`${filePath}:${sym.name}`, id);
-        symbolsExtracted++;
-      }
-      filesIndexed++;
-    }
-    db2.clearAllImports();
-    db2.clearAllReferences();
-    for (const [filePath, imports] of fileImports) {
-      const fileSymbolRows = db2.getSymbolsByFile(filePath);
-      const sourceSymbols = fileSymbolRows.map((sym) => ({
-        name: sym.name,
-        id: sym.id,
-        startLine: sym.start_line,
-        endLine: sym.end_line
-      }));
-      const allImportedNames = /* @__PURE__ */ new Set();
-      for (const imp of imports) {
-        for (const specName of imp.specifiers) {
-          const cleanName = specName.startsWith("* as ") ? specName.slice(5) : specName;
-          allImportedNames.add(cleanName);
-        }
-      }
-      const content = fileContents.get(filePath);
-      const usages = content ? findIdentifierUsages(content, allImportedNames) : [];
-      for (const imp of imports) {
-        const targetFile = resolveImportPath(
-          imp.source,
-          filePath,
-          absRoot,
-          allFiles
-        );
-        for (const specName of imp.specifiers) {
-          const cleanName = specName.startsWith("* as ") ? specName.slice(5) : specName;
-          db2.insertImport({
-            file_path: filePath,
-            specifier: cleanName,
-            source_path: targetFile,
-            raw_module: imp.source,
-            is_type_only: imp.isTypeOnly ? 1 : 0
-          });
-          importsFound++;
-        }
-        if (!targetFile) continue;
-        const refType = imp.isTypeOnly ? "type_ref" : "import";
-        for (const specName of imp.specifiers) {
-          const cleanName = specName.startsWith("* as ") ? specName.slice(5) : specName;
-          const targetKey = `${targetFile}:${cleanName}`;
-          const targetId = symbolIdMap.get(targetKey);
-          if (!targetId) continue;
-          const nameUsages = usages.filter((u) => u.name === cleanName);
-          if (nameUsages.length > 0) {
-            const referencingSymbolIds = /* @__PURE__ */ new Set();
-            for (const usage of nameUsages) {
-              for (const srcSym of sourceSymbols) {
-                if (srcSym.id !== targetId && usage.line >= srcSym.startLine && usage.line <= srcSym.endLine) {
-                  referencingSymbolIds.add(srcSym.id);
-                }
-              }
-            }
-            for (const sourceId of referencingSymbolIds) {
-              db2.insertReference({
-                source_symbol_id: sourceId,
-                target_symbol_id: targetId,
-                ref_type: refType
-              });
-              referencesCreated++;
-            }
-          } else {
-            for (const srcSym of sourceSymbols) {
-              if (srcSym.id !== targetId) {
-                db2.insertReference({
-                  source_symbol_id: srcSym.id,
-                  target_symbol_id: targetId,
-                  ref_type: refType
-                });
-                referencesCreated++;
-              }
-            }
-          }
-        }
-      }
-    }
-  });
-  db2.close();
-  return {
-    filesIndexed,
-    filesSkipped,
-    symbolsExtracted,
-    importsFound,
-    referencesCreated,
-    timeMs: Date.now() - startTime
-  };
-}
-
-// src/mcp.ts
-var require4 = createRequire3(import.meta.url);
-var pkg = require4("../package.json");
+var pkg = require2("../package.json");
 var db = null;
 var rootDir = "";
 function getDb(root) {
   if (db && rootDir === root) return db;
-  const dbPath = resolve2(root, ".codefocus", "index.db");
+  const dbPath = resolve(root, ".codefocus", "index.db");
   if (!existsSync(dbPath)) {
     throw new Error(
       `no index found at ${dbPath}
@@ -660,7 +129,7 @@ function createMcpServer(defaultRoot) {
   return server;
 }
 async function captureQueryOutput(root, term, budget, depth) {
-  const { runQueryCore } = await import("./query-PS6QVPXP.js");
+  const { runQueryCore } = await import("./query-64CFCXTD.js");
   return runQueryCore(root, term, budget, depth);
 }
 function captureGraphOutput(root, target, direction) {
@@ -673,8 +142,8 @@ function captureGraphOutput(root, target, direction) {
   }
 }
 function renderFileGraphToString(database, target, direction) {
-  const require5 = createRequire3(import.meta.url);
-  const { DirectedGraph } = require5("graphology");
+  const require3 = createRequire(import.meta.url);
+  const { DirectedGraph } = require3("graphology");
   const graph = new DirectedGraph();
   for (const file of database.getAllFiles()) {
     graph.addNode(file.path);
@@ -762,10 +231,10 @@ ${lines.join("\n")}` : "Dependents (incoming): (none)"
 ${sections.join("\n\n")}`;
 }
 function captureMapOutput(root, budget) {
-  const require5 = createRequire3(import.meta.url);
-  const { DirectedGraph } = require5("graphology");
-  const pagerank = require5("graphology-metrics/centrality/pagerank");
-  const { getEncoding } = require5("js-tiktoken");
+  const require3 = createRequire(import.meta.url);
+  const { DirectedGraph } = require3("graphology");
+  const pagerank = require3("graphology-metrics/centrality/pagerank");
+  const { getEncoding } = require3("js-tiktoken");
   const database = getDb(root);
   const files = database.getAllFiles();
   if (files.length === 0) {
@@ -864,24 +333,42 @@ Usage with Claude Code:
     return;
   }
   const root = resolveRoot(flags2.root);
-  const dbPath = resolve2(root, ".codefocus", "index.db");
-  if (!existsSync(dbPath)) {
-    if (!existsSync(root)) {
-      console.error(
-        `Error: root directory does not exist: ${root}`
-      );
-      process.exitCode = 1;
-      return;
-    }
-    console.error(`[codefocus] No index found \u2014 auto-indexing ${root} ...`);
-    const stats = await indexProject(root, dbPath);
-    console.error(
-      `[codefocus] Index complete: ${stats.filesIndexed} files, ${stats.symbolsExtracted} symbols (${stats.timeMs}ms)`
-    );
+  const dbPath = resolve(root, ".codefocus", "index.db");
+  if (!existsSync(root)) {
+    console.error(`Error: root directory does not exist: ${root}`);
+    process.exitCode = 1;
+    return;
   }
+  console.error(`[codefocus] Indexing ${root} ...`);
+  const stats = await indexProject(root, dbPath);
+  console.error(
+    `[codefocus] Index complete: ${stats.filesIndexed} files, ${stats.symbolsExtracted} symbols (${stats.timeMs}ms)`
+  );
   getDb(root);
   console.error(`[codefocus] MCP server starting (root: ${root})`);
   console.error(`[codefocus] Database: ${dbPath}`);
+  const { startWatcher } = await import("./watcher-6WHIBMPS.js");
+  const watcher = await startWatcher({
+    rootDir: root,
+    dbPath,
+    onReindex: (stats2) => {
+      if (stats2.filesIndexed > 0) {
+        if (db) {
+          db.close();
+          db = null;
+        }
+        getDb(root);
+        console.error(
+          `[codefocus] Re-indexed: ${stats2.filesIndexed} files, ${stats2.symbolsExtracted} symbols (${stats2.timeMs}ms)`
+        );
+      }
+    }
+  });
+  process.on("SIGINT", () => {
+    watcher.close();
+    if (db) db.close();
+    process.exit(0);
+  });
   const server = createMcpServer(root);
   const transport = new StdioServerTransport();
   await server.connect(transport);