@ulpi/cli 0.1.0

package/dist/chunk-DBMUNBNB.js

@@ -0,0 +1,3048 @@
+import {
+  commitInWorktree,
+  copyAndStage,
+  historyBranchExists,
+  withWorktree,
+  writeAndStage
+} from "./chunk-NNUWU6CV.js";
+import {
+  CodemapConfigSchema
+} from "./chunk-74WVVWJ4.js";
+import {
+  LOGS_DIR,
+  codemapBranchDir,
+  codemapConfigFile,
+  codemapLanceDir,
+  codemapManifestFile,
+  codemapMetadataDir,
+  codemapSchemaFile,
+  codemapStatsFile,
+  getCodemapBranch,
+  getCurrentBranch,
+  projectCodemapDir
+} from "./chunk-7LXY5UVC.js";
+
+// ../../packages/codemap-engine/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import { createHash } from "crypto";
+import { execFileSync } from "child_process";
+import * as fs3 from "fs";
+import * as path5 from "path";
+import { createHash as createHash3 } from "crypto";
+import { createHash as createHash2 } from "crypto";
+import * as path3 from "path";
+import * as path4 from "path";
+import { createRequire } from "module";
+import * as fs4 from "fs";
+import * as path6 from "path";
+import { createHash as createHash4 } from "crypto";
+import * as fs5 from "fs";
+import * as path7 from "path";
+import { connect } from "@lancedb/lancedb";
+import * as fs9 from "fs";
+import * as path11 from "path";
+import * as fs6 from "fs";
+import * as path8 from "path";
+import * as fs7 from "fs";
+import * as path9 from "path";
+import * as fs8 from "fs";
+import * as os from "os";
+import * as path10 from "path";
+import { createHash as createHash5 } from "crypto";
+import * as fs10 from "fs";
+import * as path12 from "path";
+import * as fs11 from "fs";
+import * as path13 from "path";
+import { createHash as createHash6 } from "crypto";
+import * as fs12 from "fs";
+import * as path14 from "path";
+import * as fs13 from "fs";
+import * as path15 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+import * as fs14 from "fs";
+import * as path16 from "path";
+import * as fs15 from "fs";
+import * as path17 from "path";
+import * as fs16 from "fs";
+var DEFAULT_CODEMAP_CONFIG = CodemapConfigSchema.parse({});
+function loadCodemapConfig(projectDir) {
+  const configPath = codemapConfigFile(projectDir);
+  if (!fs.existsSync(configPath)) {
+    return DEFAULT_CODEMAP_CONFIG;
+  }
+  try {
+    const raw = fs.readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return CodemapConfigSchema.parse(parsed);
+  } catch {
+    return DEFAULT_CODEMAP_CONFIG;
+  }
+}
+function saveCodemapConfig(projectDir, config) {
+  const configPath = codemapConfigFile(projectDir);
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+  const tmpPath = configPath + ".tmp";
+  fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+  fs.renameSync(tmpPath, configPath);
+}
+function minimatch(filePath, pattern) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "{{GLOBSTAR}}").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]").replace(/\{\{GLOBSTAR\}\}/g, ".*");
+  return new RegExp(`^${regex}$`).test(filePath);
+}
+function matchesDenyPattern(filePath, patterns) {
+  for (const pattern of patterns) {
+    if (minimatch(filePath, pattern)) return true;
+  }
+  return false;
+}
+function loadCodemapIgnore(projectDir) {
+  const ignorePath = path2.join(projectDir, ".codemapignore");
+  if (!fs2.existsSync(ignorePath)) return [];
+  try {
+    const content = fs2.readFileSync(ignorePath, "utf-8");
+    return content.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
+function hashFileContent(filePath) {
+  const content = fs2.readFileSync(filePath);
+  return createHash("sha256").update(content).digest("hex");
+}
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".rar",
+  ".7z",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".lock"
+  // package lock files can be huge
+]);
+function scanRepository(projectDir, config) {
+  let gitFiles;
+  try {
+    const output = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], {
+      cwd: projectDir,
+      encoding: "utf-8",
+      timeout: 3e4,
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer for large repos
+    });
+    gitFiles = output.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+  const ignorePatterns = loadCodemapIgnore(projectDir);
+  const denyPatterns = [...config.deny, ...ignorePatterns];
+  const results = [];
+  for (const relPath of gitFiles) {
+    const ext = path2.extname(relPath).toLowerCase();
+    if (BINARY_EXTENSIONS.has(ext)) continue;
+    if (matchesDenyPattern(relPath, denyPatterns)) continue;
+    const absPath = path2.join(projectDir, relPath);
+    let stat;
+    try {
+      stat = fs2.statSync(absPath);
+    } catch {
+      continue;
+    }
+    if (!stat.isFile()) continue;
+    if (stat.size > config.maxFileSize) continue;
+    if (stat.size === 0) continue;
+    try {
+      const contentHash = hashFileContent(absPath);
+      results.push({
+        filePath: relPath,
+        contentHash,
+        mtime: stat.mtimeMs,
+        sizeBytes: stat.size
+      });
+    } catch {
+      continue;
+    }
+  }
+  results.sort((a, b) => a.filePath.localeCompare(b.filePath));
+  return results;
+}
+var JS_DECLARATIONS = /* @__PURE__ */ new Map([
+  ["function_declaration", "function"],
+  ["generator_function_declaration", "function"],
+  ["class_declaration", "class"],
+  ["method_definition", "method"],
+  ["variable_declarator", "const"]
+]);
+var TS_DECLARATIONS = new Map([
+  ...JS_DECLARATIONS,
+  ["interface_declaration", "interface"],
+  ["type_alias_declaration", "type"],
+  ["enum_declaration", "enum"]
+]);
+var PY_DECLARATIONS = /* @__PURE__ */ new Map([
+  ["function_definition", "function"],
+  ["class_definition", "class"]
+]);
+var GO_DECLARATIONS = /* @__PURE__ */ new Map([
+  ["function_declaration", "function"],
+  ["method_declaration", "method"],
+  ["type_spec", "type"]
+]);
+var PHP_DECLARATIONS = /* @__PURE__ */ new Map([
+  ["function_definition", "function"],
+  ["class_declaration", "class"],
+  ["method_declaration", "method"],
+  ["interface_declaration", "interface"],
+  ["trait_declaration", "class"],
+  ["enum_declaration", "enum"]
+]);
+var JS_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "generator_function_declaration",
+  "class_declaration",
+  "export_statement",
+  "variable_declaration",
+  "lexical_declaration",
+  "expression_statement",
+  "import_statement",
+  "if_statement",
+  "for_statement",
+  "for_in_statement",
+  "while_statement",
+  "try_statement",
+  "switch_statement"
+]);
+var TS_TOP_LEVEL = /* @__PURE__ */ new Set([
+  ...JS_TOP_LEVEL,
+  "interface_declaration",
+  "type_alias_declaration",
+  "enum_declaration",
+  "module",
+  "ambient_declaration"
+]);
+var HTML_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "element",
+  "script_element",
+  "style_element",
+  "doctype",
+  "comment"
+]);
+var CSS_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "rule_set",
+  "media_statement",
+  "keyframes_statement",
+  "import_statement",
+  "charset_statement",
+  "namespace_statement",
+  "supports_statement",
+  "at_rule"
+]);
+var PHP_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "function_definition",
+  "class_declaration",
+  "namespace_definition",
+  "trait_declaration",
+  "interface_declaration",
+  "enum_declaration",
+  "expression_statement",
+  "if_statement",
+  "foreach_statement",
+  "for_statement",
+  "while_statement",
+  "try_statement",
+  "switch_statement"
+]);
+var PY_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "function_definition",
+  "class_definition",
+  "decorated_definition",
+  "import_statement",
+  "import_from_statement",
+  "if_statement",
+  "for_statement",
+  "while_statement",
+  "try_statement",
+  "with_statement",
+  "expression_statement",
+  "assignment"
+]);
+var GO_TOP_LEVEL = /* @__PURE__ */ new Set([
+  "function_declaration",
+  "method_declaration",
+  "type_declaration",
+  "var_declaration",
+  "const_declaration",
+  "import_declaration"
+]);
+var CONFIGS = {
+  javascript: {
+    grammarId: "javascript",
+    packageName: "tree-sitter-javascript",
+    wasmFile: "tree-sitter-javascript.wasm",
+    topLevelTypes: JS_TOP_LEVEL,
+    declarationTypes: JS_DECLARATIONS,
+    nameField: "name",
+    hasTagQuery: true
+  },
+  tsx: {
+    grammarId: "tsx",
+    packageName: "tree-sitter-typescript",
+    wasmFile: "tree-sitter-tsx.wasm",
+    topLevelTypes: TS_TOP_LEVEL,
+    declarationTypes: TS_DECLARATIONS,
+    nameField: "name",
+    hasTagQuery: true
+  },
+  typescript: {
+    grammarId: "typescript",
+    packageName: "tree-sitter-typescript",
+    wasmFile: "tree-sitter-typescript.wasm",
+    topLevelTypes: TS_TOP_LEVEL,
+    declarationTypes: TS_DECLARATIONS,
+    nameField: "name",
+    hasTagQuery: true
+  },
+  html: {
+    grammarId: "html",
+    packageName: "tree-sitter-html",
+    wasmFile: "tree-sitter-html.wasm",
+    topLevelTypes: HTML_TOP_LEVEL,
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "tag_name"
+  },
+  css: {
+    grammarId: "css",
+    packageName: "tree-sitter-css",
+    wasmFile: "tree-sitter-css.wasm",
+    topLevelTypes: CSS_TOP_LEVEL,
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name"
+  },
+  php: {
+    grammarId: "php",
+    packageName: "tree-sitter-php",
+    wasmFile: "tree-sitter-php.wasm",
+    topLevelTypes: PHP_TOP_LEVEL,
+    declarationTypes: PHP_DECLARATIONS,
+    nameField: "name",
+    hasTagQuery: true
+  },
+  python: {
+    grammarId: "python",
+    packageName: "tree-sitter-python",
+    wasmFile: "tree-sitter-python.wasm",
+    topLevelTypes: PY_TOP_LEVEL,
+    declarationTypes: PY_DECLARATIONS,
+    nameField: "name",
+    hasTagQuery: true
+  },
+  go: {
+    grammarId: "go",
+    packageName: "tree-sitter-go",
+    wasmFile: "tree-sitter-go.wasm",
+    topLevelTypes: GO_TOP_LEVEL,
+    declarationTypes: GO_DECLARATIONS,
+    nameField: "name",
+    hasTagQuery: true
+  },
+  // --- Tag-query-only languages (no AST chunking support yet — fall back to sliding window) ---
+  c: {
+    grammarId: "c",
+    packageName: "tree-sitter-c",
+    wasmFile: "tree-sitter-c.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  cpp: {
+    grammarId: "cpp",
+    packageName: "tree-sitter-cpp",
+    wasmFile: "tree-sitter-cpp.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  java: {
+    grammarId: "java",
+    packageName: "tree-sitter-java",
+    wasmFile: "tree-sitter-java.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  ruby: {
+    grammarId: "ruby",
+    packageName: "tree-sitter-ruby",
+    wasmFile: "tree-sitter-ruby.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  rust: {
+    grammarId: "rust",
+    packageName: "tree-sitter-rust",
+    wasmFile: "tree-sitter-rust.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  kotlin: {
+    grammarId: "kotlin",
+    packageName: "tree-sitter-kotlin",
+    wasmFile: "tree-sitter-kotlin.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  swift: {
+    grammarId: "swift",
+    packageName: "tree-sitter-swift",
+    wasmFile: "tree-sitter-swift.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  dart: {
+    grammarId: "dart",
+    packageName: "tree-sitter-dart",
+    wasmFile: "tree-sitter-dart.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  lua: {
+    grammarId: "lua",
+    packageName: "tree-sitter-lua",
+    wasmFile: "tree-sitter-lua.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  elixir: {
+    grammarId: "elixir",
+    packageName: "tree-sitter-elixir",
+    wasmFile: "tree-sitter-elixir.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  },
+  scala: {
+    grammarId: "scala",
+    packageName: "tree-sitter-scala",
+    wasmFile: "tree-sitter-scala.wasm",
+    topLevelTypes: /* @__PURE__ */ new Set(),
+    declarationTypes: /* @__PURE__ */ new Map(),
+    nameField: "name",
+    hasTagQuery: true
+  }
+};
+var EXTENSION_MAP = {
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".tsx": "tsx",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".php": "php",
+  ".py": "python",
+  ".go": "go",
+  // New tag-query-only languages
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".cc": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  ".hh": "cpp",
+  ".java": "java",
+  ".rb": "ruby",
+  ".rs": "rust",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".lua": "lua",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".scala": "scala",
+  ".sc": "scala"
+};
+var SUPPORTED_EXTENSIONS = new Set(Object.keys(EXTENSION_MAP));
+function getLanguageConfig(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  const langId = EXTENSION_MAP[ext];
+  if (!langId) return null;
+  return CONFIGS[langId] ?? null;
+}
+function getLanguageId(filePath) {
+  const ext = path3.extname(filePath).toLowerCase();
+  return EXTENSION_MAP[ext] ?? null;
+}
+var ParserCtor = null;
+var LanguageClass = null;
+var initialized = false;
+var languageCache = /* @__PURE__ */ new Map();
+var require2 = createRequire(import.meta.url);
+async function initTreeSitter() {
+  if (initialized) return;
+  const mod = await import("web-tree-sitter");
+  ParserCtor = mod.Parser;
+  LanguageClass = mod.Language;
+  const wasmPath = require2.resolve("web-tree-sitter/web-tree-sitter.wasm");
+  const wasmDir = path4.dirname(wasmPath) + "/";
+  await ParserCtor.init({
+    locateFile: (scriptName) => path4.join(wasmDir, scriptName)
+  });
+  initialized = true;
+}
+async function loadLanguage(langConfig) {
+  const cacheKey = langConfig.grammarId;
+  const cached = languageCache.get(cacheKey);
+  if (cached) return cached;
+  if (!LanguageClass) {
+    throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
+  }
+  const wasmPath = require2.resolve(
+    `${langConfig.packageName}/${langConfig.wasmFile}`
+  );
+  const language = await LanguageClass.load(wasmPath);
+  languageCache.set(cacheKey, language);
+  return language;
+}
+async function parseSource(content, langConfig) {
+  if (!ParserCtor) {
+    throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
+  }
+  const language = await loadLanguage(langConfig);
+  const parser = new ParserCtor();
+  parser.setLanguage(language);
+  const tree = parser.parse(content);
+  parser.delete();
+  return tree;
+}
+async function parseSourceWithLanguage(content, langConfig) {
+  if (!ParserCtor) {
+    throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
+  }
+  const language = await loadLanguage(langConfig);
+  const parser = new ParserCtor();
+  parser.setLanguage(language);
+  const tree = parser.parse(content);
+  parser.delete();
+  return { tree, language };
+}
+function hashContent(content) {
+  return createHash2("sha256").update(content, "utf-8").digest("hex");
+}
+async function chunkFileAST(filePath, content, config) {
+  if (!content || content.trim().length === 0) return [];
+  const langConfig = getLanguageConfig(filePath);
+  if (!langConfig) return [];
+  await initTreeSitter();
+  let tree;
+  try {
+    tree = await parseSource(content, langConfig);
+  } catch {
+    return [];
+  }
+  try {
+    const lines = content.split("\n");
+    const rootNode = tree.rootNode;
+    if (rootNode.hasError && rootNode.namedChildCount === 0) {
+      return [];
+    }
+    const chunks = [];
+    const topNodes = rootNode.namedChildren;
+    let pendingNodes = [];
+    let pendingLineCount = 0;
+    const flushPending = () => {
+      if (pendingNodes.length === 0) return;
+      const chunk = buildChunkFromNodes(pendingNodes, filePath, lines);
+      if (chunk) chunks.push(chunk);
+      pendingNodes = [];
+      pendingLineCount = 0;
+    };
+    for (const node of topNodes) {
+      const nodeLines = node.endPosition.row - node.startPosition.row + 1;
+      if (nodeLines < config.minChunkSize) {
+        pendingNodes.push(node);
+        pendingLineCount += nodeLines;
+        if (pendingLineCount >= config.minChunkSize) {
+          flushPending();
+        }
+        continue;
+      }
+      flushPending();
+      if (nodeLines <= config.maxChunkSize) {
+        const chunk = buildChunkFromNode(node, filePath, lines);
+        if (chunk) chunks.push(chunk);
+      } else {
+        splitLargeNode(node, filePath, lines, config, chunks);
+      }
+    }
+    flushPending();
+    if (chunks.length === 0 && content.trim().length > 0) {
+      return [];
+    }
+    return chunks;
+  } finally {
+    tree.delete();
+  }
+}
+function splitLargeNode(node, filePath, lines, config, chunks) {
+  const children = node.namedChildren;
+  if (children.length === 0) {
+    const chunk = buildChunkFromNode(node, filePath, lines);
+    if (chunk) chunks.push(chunk);
+    return;
+  }
+  const signatureStartRow = node.startPosition.row;
+  const firstChildRow = children[0].startPosition.row;
+  const signatureEndRow = Math.min(
+    firstChildRow > signatureStartRow ? firstChildRow : signatureStartRow + 1,
+    node.endPosition.row
+  );
+  const signature = lines.slice(signatureStartRow, signatureEndRow).join("\n");
+  let buffer = [];
+  let bufferLines = 0;
+  const flushBuffer = () => {
+    if (buffer.length === 0) return;
+    const chunk = buildChunkWithContext(signature, signatureStartRow, buffer, filePath, lines);
+    if (chunk) chunks.push(chunk);
+    buffer = [];
+    bufferLines = 0;
+  };
+  for (const child of children) {
+    const childLines = child.endPosition.row - child.startPosition.row + 1;
+    if (childLines > config.maxChunkSize) {
+      flushBuffer();
+      splitLargeNode(child, filePath, lines, config, chunks);
+      continue;
+    }
+    if (bufferLines + childLines > config.maxChunkSize) {
+      flushBuffer();
+    }
+    buffer.push(child);
+    bufferLines += childLines;
+  }
+  flushBuffer();
+}
+function buildChunkFromNode(node, filePath, lines) {
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const chunkContent = lines.slice(startLine - 1, endLine).join("\n");
+  if (chunkContent.trim().length === 0) return null;
+  return {
+    id: "",
+    filePath,
+    startLine,
+    endLine,
+    content: chunkContent,
+    chunkHash: hashContent(chunkContent)
+  };
+}
+function buildChunkFromNodes(nodes, filePath, lines) {
+  if (nodes.length === 0) return null;
+  const startLine = nodes[0].startPosition.row + 1;
+  const endLine = nodes[nodes.length - 1].endPosition.row + 1;
+  const chunkContent = lines.slice(startLine - 1, endLine).join("\n");
+  if (chunkContent.trim().length === 0) return null;
+  return {
+    id: "",
+    filePath,
+    startLine,
+    endLine,
+    content: chunkContent,
+    chunkHash: hashContent(chunkContent)
+  };
+}
+function buildChunkWithContext(signature, signatureRow, nodes, filePath, lines) {
+  if (nodes.length === 0) return null;
+  const startLine = nodes[0].startPosition.row + 1;
+  const endLine = nodes[nodes.length - 1].endPosition.row + 1;
+  const bodyContent = lines.slice(startLine - 1, endLine).join("\n");
+  if (bodyContent.trim().length === 0) return null;
+  const content = signature + "\n" + bodyContent;
+  return {
+    id: "",
+    filePath,
+    startLine: signatureRow + 1,
+    // Include signature in range
+    endLine,
+    content,
+    chunkHash: hashContent(content)
+  };
+}
+async function parseAndChunkFile(filePath, content, config) {
+  if (!content || content.trim().length === 0) {
+    return { chunks: [], tree: null, language: null, langId: null };
+  }
+  const langConfig = getLanguageConfig(filePath);
+  if (!langConfig) {
+    return { chunks: [], tree: null, language: null, langId: null };
+  }
+  const langId = getLanguageId(filePath);
+  await initTreeSitter();
+  let tree;
+  let language;
+  try {
+    const result = await parseSourceWithLanguage(content, langConfig);
+    tree = result.tree;
+    language = result.language;
+  } catch {
+    return { chunks: [], tree: null, language: null, langId };
+  }
+  const lines = content.split("\n");
+  const rootNode = tree.rootNode;
+  if (rootNode.hasError && rootNode.namedChildCount === 0) {
+    return { chunks: [], tree, language, langId };
+  }
+  const chunks = [];
+  const topNodes = rootNode.namedChildren;
+  let pendingNodes = [];
+  let pendingLineCount = 0;
+  const flushPending = () => {
+    if (pendingNodes.length === 0) return;
+    const chunk = buildChunkFromNodes(pendingNodes, filePath, lines);
+    if (chunk) chunks.push(chunk);
+    pendingNodes = [];
+    pendingLineCount = 0;
+  };
+  for (const node of topNodes) {
+    const nodeLines = node.endPosition.row - node.startPosition.row + 1;
+    if (nodeLines < config.minChunkSize) {
+      pendingNodes.push(node);
+      pendingLineCount += nodeLines;
+      if (pendingLineCount >= config.minChunkSize) {
+        flushPending();
+      }
+      continue;
+    }
+    flushPending();
+    if (nodeLines <= config.maxChunkSize) {
+      const chunk = buildChunkFromNode(node, filePath, lines);
+      if (chunk) chunks.push(chunk);
+    } else {
+      splitLargeNode(node, filePath, lines, config, chunks);
+    }
+  }
+  flushPending();
+  return { chunks, tree, language, langId };
+}
+function hashContent2(content) {
+  return createHash3("sha256").update(content, "utf-8").digest("hex");
+}
+async function chunkFile(filePath, content, config) {
+  if (!content || content.trim().length === 0) return [];
+  if (config.strategy === "ast") {
+    const langConfig = getLanguageConfig(filePath);
+    if (langConfig) {
+      const astChunks = await chunkFileAST(filePath, content, config);
+      if (astChunks.length > 0) return astChunks;
+    }
+  }
+  return chunkFileSlidingWindow(filePath, content, config);
+}
+function chunkFileSlidingWindow(filePath, content, config) {
+  const lines = content.split("\n");
+  const { windowSize, overlap } = config;
+  const chunks = [];
+  if (lines.length <= windowSize) {
+    const chunkHash = hashContent2(content);
+    chunks.push({
+      id: "",
+      filePath,
+      startLine: 1,
+      endLine: lines.length,
+      content,
+      chunkHash
+    });
+    return chunks;
+  }
+  const step = Math.max(1, windowSize - overlap);
+  for (let i = 0; i < lines.length; i += step) {
+    const startIdx = i;
+    const endIdx = Math.min(i + windowSize, lines.length);
+    const chunkLines = lines.slice(startIdx, endIdx);
+    const chunkContent = chunkLines.join("\n");
+    if (chunkContent.trim().length === 0) continue;
+    const chunkHash = hashContent2(chunkContent);
+    chunks.push({
+      id: "",
+      filePath,
+      startLine: startIdx + 1,
+      endLine: endIdx,
+      content: chunkContent,
+      chunkHash
+    });
+    if (endIdx >= lines.length) break;
+  }
+  return chunks;
+}
+async function chunkFiles(projectDir, filePaths, config) {
+  const allChunks = [];
+  for (const relPath of filePaths) {
+    const absPath = path5.join(projectDir, relPath);
+    try {
+      const content = fs3.readFileSync(absPath, "utf-8");
+      const chunks = await chunkFile(relPath, content, config);
+      allChunks.push(...chunks);
+    } catch {
+      continue;
+    }
+  }
+  return allChunks;
+}
+function generateChunkId(filePath, startLine, endLine, chunkHash, chunkerVersion) {
+  const input = `${filePath}:${startLine}:${endLine}:${chunkHash}:${chunkerVersion}`;
+  return createHash4("sha256").update(input, "utf-8").digest("hex");
+}
+function assignChunkIds(chunks, chunkerVersion) {
+  for (const chunk of chunks) {
+    chunk.id = generateChunkId(
+      chunk.filePath,
+      chunk.startLine,
+      chunk.endLine,
+      chunk.chunkHash,
+      chunkerVersion
+    );
+  }
+}
+function buildManifest(scannedFiles, chunks, chunkerVersion) {
+  const files = {};
+  const chunksByFile = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    const ids = chunksByFile.get(chunk.filePath) ?? [];
+    ids.push(chunk.id);
+    chunksByFile.set(chunk.filePath, ids);
+  }
+  for (const scanned of scannedFiles) {
+    files[scanned.filePath] = {
+      contentHash: scanned.contentHash,
+      mtime: scanned.mtime,
+      sizeBytes: scanned.sizeBytes,
+      chunkIds: chunksByFile.get(scanned.filePath) ?? []
+    };
+  }
+  return {
+    version: 1,
+    chunkerVersion,
+    files
+  };
+}
+function loadManifest(projectDir, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const manifestPath = codemapManifestFile(projectDir, resolvedBranch);
+  if (!fs4.existsSync(manifestPath)) return null;
+  try {
+    const raw = fs4.readFileSync(manifestPath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveManifest(projectDir, branch, manifest) {
+  const manifestPath = codemapManifestFile(projectDir, branch);
+  const dir = path6.dirname(manifestPath);
+  fs4.mkdirSync(dir, { recursive: true });
+  const tmpPath = manifestPath + ".tmp";
+  fs4.writeFileSync(tmpPath, JSON.stringify(manifest, null, 2) + "\n", "utf-8");
+  fs4.renameSync(tmpPath, manifestPath);
+}
+function diffManifest(oldManifest, newFiles) {
+  if (!oldManifest) {
+    return { added: newFiles, updated: [], removed: [] };
+  }
+  const oldFileMap = oldManifest.files;
+  const newFileSet = new Set(newFiles.map((f) => f.filePath));
+  const added = [];
+  const updated = [];
+  for (const file of newFiles) {
+    const old = oldFileMap[file.filePath];
+    if (!old) {
+      added.push(file);
+    } else if (old.contentHash !== file.contentHash) {
+      updated.push(file);
+    }
+  }
+  const removed = [];
+  for (const oldPath of Object.keys(oldFileMap)) {
+    if (!newFileSet.has(oldPath)) {
+      removed.push(oldPath);
+    }
+  }
+  return { added, updated, removed };
+}
+async function createEmbedder(config) {
+  switch (config.provider) {
+    case "openai": {
+      const { OpenAIEmbedder: OpenAIEmbedder2 } = await import("./openai-E7G2YAHU-UYY4ZWON.js");
+      return new OpenAIEmbedder2(config.model, config.dimensions);
+    }
+    case "ollama": {
+      const { OllamaEmbedder: OllamaEmbedder2 } = await import("./ollama-3XCUZMZT-FYKHW4TZ.js");
+      return new OllamaEmbedder2(config.model, config.dimensions);
+    }
+    case "ulpi": {
+      const { UlpiEmbedder } = await import("./ulpi-RMMCUAGP-JCJ273T6.js");
+      return new UlpiEmbedder(config.model, config.dimensions, config.baseUrl);
+    }
+    default:
+      throw new Error(`Unknown embedding provider: ${config.provider}`);
+  }
+}
+var CodemapStore = class {
+  db = null;
+  table = null;
+  indexDir;
+  constructor(projectDir, branch) {
+    const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+    this.indexDir = codemapLanceDir(projectDir, resolvedBranch);
+  }
+  /**
+   * Initialize the vector store. Creates the directory and opens the LanceDB connection.
+   * If a "chunks" table already exists, opens it.
+   */
+  async initialize() {
+    fs5.mkdirSync(this.indexDir, { recursive: true });
+    this.db = await connect(this.indexDir);
+    const tables = await this.db.tableNames();
+    if (tables.includes("chunks")) {
+      this.table = await this.db.openTable("chunks");
+    }
+  }
+  /**
+   * Drop the existing chunks table so the next upsert creates a fresh one.
+   * Used by full reindex when dimensions or schema change.
+   */
+  async dropTable() {
+    if (!this.db) return;
+    const tables = await this.db.tableNames();
+    if (tables.includes("chunks")) {
+      await this.db.dropTable("chunks");
+      this.table = null;
+    }
+  }
+  /**
+   * Add or update items in the store.
+   * Flattens metadata into top-level record columns for LanceDB.
+   * Uses merge-insert (upsert) semantics keyed on `id`.
+   */
+  async upsertItems(items) {
+    if (items.length === 0) return;
+    const records = items.map((item) => ({
+      id: item.id,
+      vector: item.vector,
+      filePath: item.metadata.filePath,
+      startLine: item.metadata.startLine,
+      endLine: item.metadata.endLine,
+      snippet: item.metadata.snippet
+    }));
+    if (!this.table) {
+      this.table = await this.db.createTable("chunks", records);
+    } else {
+      await this.table.mergeInsert("id").whenMatchedUpdateAll().whenNotMatchedInsertAll().execute(records);
+    }
+  }
+  /**
+   * Remove items by their chunk IDs.
+   * Uses SQL IN clause with properly escaped string literals.
+   */
+  async removeItems(chunkIds) {
+    if (!this.table || chunkIds.length === 0) return;
+    const quoted = chunkIds.map((id) => "'" + id.replace(/'/g, "''") + "'").join(", ");
+    await this.table.delete("id IN (" + quoted + ")");
+  }
+  /**
+   * Query the store for similar vectors.
+   * Returns results sorted by score (highest first, cosine similarity).
+   */
+  async query(vector, topK = 10) {
+    if (!this.table) return [];
+    const results = await this.table.vectorSearch(vector).distanceType("cosine").limit(topK).toArray();
+    return results.map((r) => ({
+      id: r.id,
+      filePath: r.filePath,
+      startLine: r.startLine,
+      endLine: r.endLine,
+      snippet: r.snippet,
+      score: 1 - (r._distance ?? 0)
+    }));
+  }
+  /**
+   * Get the approximate number of items in the store.
+   */
+  async getItemCount() {
+    if (!this.table) return 0;
+    return this.table.countRows();
+  }
+  /**
+   * Get the index directory size in bytes.
+   * Walks recursively since LanceDB stores data in subdirectories with fragment files.
+   */
+  getIndexSizeBytes() {
+    if (!fs5.existsSync(this.indexDir)) return 0;
+    return walkDirSize(this.indexDir);
+  }
+};
+function walkDirSize(dir) {
+  let totalSize = 0;
+  const entries = fs5.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path7.join(dir, entry);
+    try {
+      const stat = fs5.statSync(fullPath);
+      if (stat.isDirectory()) {
+        totalSize += walkDirSize(fullPath);
+      } else if (stat.isFile()) {
+        totalSize += stat.size;
+      }
+    } catch {
+    }
+  }
+  return totalSize;
+}
+function saveSchema(projectDir, branch, schema) {
+  const schemaPath = codemapSchemaFile(projectDir, branch);
+  const dir = path7.dirname(schemaPath);
+  fs5.mkdirSync(dir, { recursive: true });
+  const tmpPath = schemaPath + ".tmp";
+  fs5.writeFileSync(tmpPath, JSON.stringify(schema, null, 2) + "\n", "utf-8");
+  fs5.renameSync(tmpPath, schemaPath);
+}
+function loadSchema(projectDir, branch) {
+  const schemaPath = codemapSchemaFile(projectDir, branch);
+  if (!fs5.existsSync(schemaPath)) return null;
+  try {
+    return JSON.parse(fs5.readFileSync(schemaPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function getLanguage(filePath) {
+  const ext = path8.extname(filePath).toLowerCase();
+  if ([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs", ".cts", ".cjs"].includes(ext)) return "typescript";
+  if (ext === ".py") return "python";
+  if (ext === ".go") return "go";
+  return "unknown";
+}
+var TS_PATTERNS = [
+  { pattern: /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/gm, type: "function" },
+  { pattern: /^(?:export\s+)?class\s+(\w+)/gm, type: "class" },
+  { pattern: /^(?:export\s+)?interface\s+(\w+)/gm, type: "interface" },
+  { pattern: /^(?:export\s+)?type\s+(\w+)\s*[=<]/gm, type: "type" },
+  { pattern: /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*[=:]/gm, type: "const" },
+  { pattern: /^(?:export\s+)?enum\s+(\w+)/gm, type: "enum" },
+  { pattern: /^\s+(?:async\s+)?(\w+)\s*\([^)]*\)\s*(?::\s*\w+)?\s*\{/gm, type: "method" }
+];
+var PY_PATTERNS = [
+  { pattern: /^(?:async\s+)?def\s+(\w+)/gm, type: "function" },
+  { pattern: /^class\s+(\w+)/gm, type: "class" }
+];
+var GO_PATTERNS = [
+  { pattern: /^func\s+(?:\([^)]+\)\s+)?(\w+)/gm, type: "function" },
+  { pattern: /^type\s+(\w+)\s+struct\b/gm, type: "class" },
+  { pattern: /^type\s+(\w+)\s+interface\b/gm, type: "interface" }
+];
+function extractSymbols(filePath, content, startLine, endLine, chunkId) {
+  const lang = getLanguage(filePath);
+  if (lang === "unknown") return [];
+  const patterns = lang === "typescript" ? TS_PATTERNS : lang === "python" ? PY_PATTERNS : GO_PATTERNS;
+  const symbols = [];
+  const lines = content.split("\n");
+  for (const { pattern, type } of patterns) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      if (!name || name.startsWith("_")) continue;
+      const beforeMatch = content.slice(0, match.index);
+      const lineOffset = beforeMatch.split("\n").length - 1;
+      const symbolLine = startLine + lineOffset;
+      let symbolEndLine = symbolLine;
+      for (let i = lineOffset + 1; i < lines.length; i++) {
+        symbolEndLine = startLine + i;
+        if (i > lineOffset + 1 && lines[i].match(/^(?:export|function|class|interface|type|const|def |func )/)) {
+          symbolEndLine = startLine + i - 1;
+          break;
+        }
+      }
+      symbols.push({
+        name,
+        symbolType: type,
+        filePath,
+        startLine: symbolLine,
+        endLine: Math.min(symbolEndLine, endLine),
+        chunkId
+      });
+    }
+  }
+  return symbols;
+}
+function extractSymbolsFromChunks(chunks) {
+  const allSymbols = [];
+  for (const chunk of chunks) {
+    const symbols = extractSymbols(
+      chunk.filePath,
+      chunk.content,
+      chunk.startLine,
+      chunk.endLine,
+      chunk.id
+    );
+    allSymbols.push(...symbols);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return allSymbols.filter((s) => {
+    const key = `${s.name}:${s.filePath}:${s.startLine}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function symbolIndexPath(projectDir, branch) {
+  return path8.join(codemapMetadataDir(projectDir, branch), "symbols.jsonl");
+}
+function saveSymbolIndex(projectDir, branch, symbols) {
+  const indexPath = symbolIndexPath(projectDir, branch);
+  const dir = path8.dirname(indexPath);
+  fs6.mkdirSync(dir, { recursive: true });
+  const content = symbols.map((s) => JSON.stringify(s)).join("\n") + "\n";
+  const tmpPath = indexPath + ".tmp";
+  fs6.writeFileSync(tmpPath, content, "utf-8");
+  fs6.renameSync(tmpPath, indexPath);
+}
+function loadSymbolIndex(projectDir, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const indexPath = symbolIndexPath(projectDir, resolvedBranch);
+  if (!fs6.existsSync(indexPath)) return [];
+  try {
+    const content = fs6.readFileSync(indexPath, "utf-8");
+    return content.split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  } catch {
+    return [];
+  }
+}
+function searchSymbols(projectDir, query, options, branch) {
+  const symbols = loadSymbolIndex(projectDir, branch);
+  const limit = options?.limit ?? 20;
+  const queryLower = query.toLowerCase();
+  const results = [];
+  for (const symbol of symbols) {
+    if (options?.symbolType && symbol.symbolType !== options.symbolType) continue;
+    if (options?.pathPrefix && !symbol.filePath.startsWith(options.pathPrefix)) continue;
+    const nameLower = symbol.name.toLowerCase();
+    let score = 0;
+    if (nameLower === queryLower) {
+      score = 1;
+    } else if (nameLower.startsWith(queryLower)) {
+      score = 0.8;
+    } else if (nameLower.includes(queryLower)) {
+      score = 0.5;
+    } else {
+      continue;
+    }
+    results.push({
+      ...symbol,
+      score
+    });
+  }
+  results.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+  return results.slice(0, limit);
+}
+var BM25_K1 = 1.2;
+var BM25_B = 0.75;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "is",
+  "a",
+  "an",
+  "in",
+  "on",
+  "of",
+  "to",
+  "for",
+  "it",
+  "and",
+  "or",
+  "not",
+  "with",
+  "as",
+  "by",
+  "from",
+  "at",
+  "be",
+  "this",
+  "that",
+  "are",
+  "was",
+  "were",
+  "has",
+  "have",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "can",
+  "could",
+  "may",
+  "might",
+  "shall",
+  "should"
+]);
+function tokenize(text) {
+  return text.toLowerCase().split(/[^a-z0-9]+/).filter((t) => t.length >= 2 && !STOP_WORDS.has(t));
+}
+function buildBM25Index(documents) {
+  const index = {
+    docCount: 0,
+    avgDocLen: 0,
+    df: {},
+    tf: {},
+    docLen: {},
+    docPaths: {}
+  };
+  if (documents.length === 0) return index;
+  let totalLen = 0;
+  for (const doc of documents) {
+    index.docCount++;
+    index.docPaths[doc.id] = doc.filePath;
+    index.docLen[doc.id] = doc.terms.length;
+    totalLen += doc.terms.length;
+    const termCounts = {};
+    for (const term of doc.terms) {
+      termCounts[term] = (termCounts[term] ?? 0) + 1;
+    }
+    index.tf[doc.id] = termCounts;
+    const uniqueTerms = new Set(doc.terms);
+    for (const term of uniqueTerms) {
+      index.df[term] = (index.df[term] ?? 0) + 1;
+    }
+  }
+  index.avgDocLen = totalLen / index.docCount;
+  return index;
+}
+function addDocuments(index, documents) {
+  let totalLen = index.avgDocLen * index.docCount;
+  for (const doc of documents) {
+    if (index.tf[doc.id]) {
+      removeDocuments(index, [doc.id]);
+      totalLen = index.avgDocLen * index.docCount;
+    }
+    index.docCount++;
+    index.docPaths[doc.id] = doc.filePath;
+    index.docLen[doc.id] = doc.terms.length;
+    totalLen += doc.terms.length;
+    const termCounts = {};
+    for (const term of doc.terms) {
+      termCounts[term] = (termCounts[term] ?? 0) + 1;
+    }
+    index.tf[doc.id] = termCounts;
+    const uniqueTerms = new Set(doc.terms);
+    for (const term of uniqueTerms) {
+      index.df[term] = (index.df[term] ?? 0) + 1;
+    }
+  }
+  index.avgDocLen = index.docCount > 0 ? totalLen / index.docCount : 0;
+}
+function removeDocuments(index, docIds) {
+  for (const docId of docIds) {
+    const termCounts = index.tf[docId];
+    if (!termCounts) continue;
+    for (const term of Object.keys(termCounts)) {
+      if (index.df[term] !== void 0) {
+        index.df[term]--;
+        if (index.df[term] <= 0) {
+          delete index.df[term];
+        }
+      }
+    }
+    delete index.tf[docId];
+    delete index.docLen[docId];
+    delete index.docPaths[docId];
+    index.docCount--;
+  }
+  if (index.docCount > 0) {
+    let totalLen = 0;
+    for (const len of Object.values(index.docLen)) {
+      totalLen += len;
+    }
+    index.avgDocLen = totalLen / index.docCount;
+  } else {
+    index.avgDocLen = 0;
+  }
+}
+function queryBM25(index, queryTerms, topK) {
+  if (index.docCount === 0 || queryTerms.length === 0) return [];
+  const scores = {};
+  for (const term of queryTerms) {
+    const n = index.df[term] ?? 0;
+    if (n === 0) continue;
+    const idf = Math.log((index.docCount - n + 0.5) / (n + 0.5) + 1);
+    for (const docId of Object.keys(index.tf)) {
+      const tf = index.tf[docId][term] ?? 0;
+      if (tf === 0) continue;
+      const dl = index.docLen[docId];
+      const numerator = tf * (BM25_K1 + 1);
+      const denominator = tf + BM25_K1 * (1 - BM25_B + BM25_B * dl / index.avgDocLen);
+      const termScore = idf * numerator / denominator;
+      scores[docId] = (scores[docId] ?? 0) + termScore;
+    }
+  }
+  return Object.entries(scores).sort((a, b) => b[1] - a[1]).slice(0, topK).map(([id, score]) => ({
+    id,
+    filePath: index.docPaths[id] ?? "",
+    score
+  }));
+}
+function bm25IndexPath(projectDir, branch) {
+  return path9.join(codemapMetadataDir(projectDir, branch), "bm25.json");
+}
+function saveBM25Index(projectDir, branch, index) {
+  const indexPath = bm25IndexPath(projectDir, branch);
+  const dir = path9.dirname(indexPath);
+  fs7.mkdirSync(dir, { recursive: true });
+  const tmpPath = indexPath + ".tmp";
+  fs7.writeFileSync(tmpPath, JSON.stringify(index) + "\n", "utf-8");
+  fs7.renameSync(tmpPath, indexPath);
+}
+function loadBM25Index(projectDir, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const indexPath = bm25IndexPath(projectDir, resolvedBranch);
+  if (!fs7.existsSync(indexPath)) return null;
+  try {
+    return JSON.parse(fs7.readFileSync(indexPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var STALE_TIMEOUT_MS = 6e4;
+var ACQUIRE_TIMEOUT_MS = 1e4;
+var POLL_INTERVAL_MS = 500;
+function sanitizeSlug(projectDir, branch) {
+  const input = branch ? `${path10.resolve(projectDir)}:${branch}` : path10.resolve(projectDir);
+  const hash = createHash5("sha256").update(input).digest("hex").slice(0, 16);
+  const name = path10.basename(projectDir).replace(/[^a-z0-9-]/gi, "-").toLowerCase();
+  return branch ? `${name}-${branch.replace(/[^a-z0-9-]/gi, "-").toLowerCase()}-${hash}` : `${name}-${hash}`;
+}
+function lockFilePath(projectDir, branch) {
+  const slug = sanitizeSlug(projectDir, branch);
+  return path10.join(os.tmpdir(), `ulpi-codemap-${slug}.lock`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isLockStale(lockPath) {
+  try {
+    const content = fs8.readFileSync(lockPath, "utf-8");
+    const data = JSON.parse(content);
+    if (!isProcessAlive(data.pid)) return true;
+    const lockTime = new Date(data.timestamp).getTime();
+    if (Date.now() - lockTime > STALE_TIMEOUT_MS) return true;
+    return false;
+  } catch {
+    return true;
+  }
+}
+function acquireCodemapLock(projectDir, branch) {
+  const lockPath = lockFilePath(projectDir, branch);
+  const startTime = Date.now();
+  while (true) {
+    if (fs8.existsSync(lockPath)) {
+      if (isLockStale(lockPath)) {
+        try {
+          fs8.unlinkSync(lockPath);
+        } catch {
+        }
+      } else {
+        if (Date.now() - startTime > ACQUIRE_TIMEOUT_MS) {
+          throw new Error("Timeout acquiring codemap lock");
+        }
+        const waitUntil = Date.now() + POLL_INTERVAL_MS;
+        while (Date.now() < waitUntil) {
+        }
+        continue;
+      }
+    }
+    const lockData = {
+      pid: process.pid,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      fs8.writeFileSync(lockPath, JSON.stringify(lockData), { flag: "wx" });
+      return;
+    } catch {
+      if (Date.now() - startTime > ACQUIRE_TIMEOUT_MS) {
+        throw new Error("Timeout acquiring codemap lock");
+      }
+      const waitUntil = Date.now() + POLL_INTERVAL_MS;
+      while (Date.now() < waitUntil) {
+      }
+    }
+  }
+}
+function releaseCodemapLock(projectDir, branch) {
+  const lockPath = lockFilePath(projectDir, branch);
+  try {
+    const content = fs8.readFileSync(lockPath, "utf-8");
+    const data = JSON.parse(content);
+    if (data.pid === process.pid) {
+      fs8.unlinkSync(lockPath);
+    }
+  } catch {
+  }
+}
+function isCodemapLocked(projectDir, branch) {
+  const lockPath = lockFilePath(projectDir, branch);
+  if (!fs8.existsSync(lockPath)) return false;
+  return !isLockStale(lockPath);
+}
+function log(level, message) {
+  try {
+    fs9.mkdirSync(LOGS_DIR, { recursive: true });
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const line = `[${ts}] [${level.toUpperCase()}] ${message}
+`;
+    fs9.appendFileSync(path11.join(LOGS_DIR, "codemap.log"), line);
+  } catch {
+  }
+}
+function buildEmbeddingTexts(chunks, symbols) {
+  const symbolsByChunk = /* @__PURE__ */ new Map();
+  for (const s of symbols) {
+    const list = symbolsByChunk.get(s.chunkId) ?? [];
+    list.push(s);
+    symbolsByChunk.set(s.chunkId, list);
+  }
+  return chunks.map((c) => {
+    const chunkSymbols = symbolsByChunk.get(c.id) ?? [];
+    const symbolLine = chunkSymbols.map((s) => `${s.name} (${s.symbolType})`).join(", ");
+    const header = symbolLine ? `${c.filePath}
+${symbolLine}
+
+` : `${c.filePath}
+
+`;
+    return header + c.content;
+  });
+}
+async function runInitPipeline(projectDir, onProgress, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  acquireCodemapLock(projectDir, resolvedBranch);
+  try {
+    return await runPipelineInner(projectDir, onProgress, resolvedBranch);
+  } finally {
+    releaseCodemapLock(projectDir, resolvedBranch);
+  }
+}
+async function runPipelineInner(projectDir, onProgress, branch) {
+  const startTime = Date.now();
+  const config = loadCodemapConfig(projectDir);
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const codemapDir = codemapBranchDir(projectDir, resolvedBranch);
+  fs9.mkdirSync(codemapDir, { recursive: true });
+  onProgress?.({
+    phase: "scanning",
+    current: 0,
+    total: 0,
+    message: "Scanning repository..."
+  });
+  const scannedFiles = scanRepository(projectDir, config);
+  onProgress?.({
+    phase: "scanning",
+    current: scannedFiles.length,
+    total: scannedFiles.length,
+    message: `Found ${scannedFiles.length} files`
+  });
+  if (scannedFiles.length === 0) {
+    const emptyManifest = buildManifest([], [], config.chunking.version);
+    saveManifest(projectDir, resolvedBranch, emptyManifest);
+    writeStats(projectDir, resolvedBranch, {
+      totalFiles: 0,
+      totalChunks: 0,
+      staleFiles: 0,
+      indexSizeBytes: 0,
+      lastFullIndexMs: Date.now() - startTime,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      totalFiles: 0,
+      totalChunks: 0,
+      durationMs: Date.now() - startTime,
+      embeddingProvider: config.embedding.provider,
+      embeddingModel: config.embedding.model
+    };
+  }
+  onProgress?.({
+    phase: "chunking",
+    current: 0,
+    total: scannedFiles.length,
+    message: "Chunking files..."
+  });
+  let extractTagsFromTree = null;
+  try {
+    const depgraph = await import("./dist-R5ZJ4LX5.js");
+    extractTagsFromTree = depgraph.extractTagsFromTree;
+  } catch {
+  }
+  await initTreeSitter();
+  const allTags = /* @__PURE__ */ new Map();
+  const chunks = [];
+  const filePaths = scannedFiles.map((f) => f.filePath);
+  for (let i = 0; i < filePaths.length; i++) {
+    const filePath = filePaths[i];
+    const absPath = path11.join(projectDir, filePath);
+    let content;
+    try {
+      content = fs9.readFileSync(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const langConfig = getLanguageConfig(filePath);
+    const langId = getLanguageId(filePath);
+    if (langConfig) {
+      const result = await parseAndChunkFile(filePath, content, config.chunking);
+      if (result.chunks.length > 0) {
+        chunks.push(...result.chunks);
+      } else {
+        const fallbackChunks = await chunkFile(filePath, content, config.chunking);
+        chunks.push(...fallbackChunks);
+      }
+      if (extractTagsFromTree && result.tree && result.language && langId && langConfig.hasTagQuery) {
+        try {
+          const lang = result.language;
+          const createQuery = (source) => lang.query(source);
+          const tags = extractTagsFromTree(createQuery, result.tree.rootNode, filePath, langId);
+          if (tags.length > 0) {
+            allTags.set(filePath, tags);
+          }
+        } catch {
+        }
+      }
+      if (result.tree) {
+        result.tree.delete();
+      }
+    } else {
+      const fileChunks = await chunkFile(filePath, content, config.chunking);
+      chunks.push(...fileChunks);
+    }
+    if ((i + 1) % 100 === 0 || i === filePaths.length - 1) {
+      onProgress?.({
+        phase: "chunking",
+        current: i + 1,
+        total: scannedFiles.length,
+        message: `Chunked ${i + 1}/${scannedFiles.length} files (${chunks.length} chunks)`
+      });
+    }
+  }
+  onProgress?.({
+    phase: "chunking",
+    current: scannedFiles.length,
+    total: scannedFiles.length,
+    message: `Created ${chunks.length} chunks`
+  });
+  assignChunkIds(chunks, config.chunking.version);
+  onProgress?.({
+    phase: "finalizing",
+    current: 0,
+    total: 3,
+    message: "Extracting symbols..."
+  });
+  const symbols = extractSymbolsFromChunks(chunks);
+  saveSymbolIndex(projectDir, resolvedBranch, symbols);
+  onProgress?.({
+    phase: "finalizing",
+    current: 1,
+    total: 3,
+    message: "Building BM25 index..."
+  });
+  const bm25Docs = chunks.map((c) => ({
+    id: c.id,
+    filePath: c.filePath,
+    terms: tokenize(c.filePath + " " + c.content)
+  }));
+  const bm25Index = buildBM25Index(bm25Docs);
+  saveBM25Index(projectDir, resolvedBranch, bm25Index);
+  const store = new CodemapStore(projectDir, resolvedBranch);
+  await store.initialize();
+  await store.dropTable();
+  const embedder = await createEmbedder(config.embedding);
+  const schema = {
+    formatVersion: 1,
+    vectorStore: { engine: "lancedb", dimensions: embedder.dimensions },
+    embedding: { provider: embedder.provider, model: embedder.model },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveSchema(projectDir, resolvedBranch, schema);
+  const manifest = buildManifest(scannedFiles, chunks, config.chunking.version);
+  saveManifest(projectDir, resolvedBranch, manifest);
+  saveCodemapConfig(projectDir, config);
+  const allTexts = buildEmbeddingTexts(chunks, symbols);
+  const totalChars = allTexts.reduce((sum, t) => sum + t.length, 0);
+  const avgChunkChars = Math.round(totalChars / (allTexts.length || 1));
+  const maxChunkChars = allTexts.length > 0 ? Math.max(...allTexts.map((t) => t.length)) : 0;
+  log("info", `Embedding ${allTexts.length} chunks: totalChars=${totalChars}, avgChars=${avgChunkChars}, maxChars=${maxChunkChars}, provider=${embedder.provider}, model=${embedder.model}, dims=${embedder.dimensions}`);
+  let embeddingError = null;
+  try {
+    await embedAndStore(embedder, allTexts, chunks, store, config.batch, onProgress);
+  } catch (err) {
+    embeddingError = err instanceof Error ? err : new Error(String(err));
+    log("warn", `Embedding incomplete: ${embeddingError.message}`);
+  }
+  let depgraphResult;
+  if (allTags.size > 0) {
+    try {
+      const depgraph = await import("./dist-R5ZJ4LX5.js");
+      onProgress?.({
+        phase: "graph",
+        current: 0,
+        total: 3,
+        message: "Building dependency graph..."
+      });
+      const graph = depgraph.buildReferenceGraph(allTags, filePaths);
+      for (const sf of scannedFiles) {
+        if (graph.nodes[sf.filePath]) {
+          graph.nodes[sf.filePath].sizeBytes = sf.sizeBytes;
+        }
+      }
+      depgraph.saveGraph(graph, projectDir, resolvedBranch);
+      onProgress?.({
+        phase: "graph",
+        current: 1,
+        total: 3,
+        message: `Graph: ${Object.keys(graph.nodes).length} nodes, ${graph.edges.length} edges`
+      });
+      onProgress?.({
+        phase: "ranking",
+        current: 1,
+        total: 3,
+        message: "Computing PageRank..."
+      });
+      const pageRank = depgraph.computePageRank(graph);
+      depgraph.savePageRank(pageRank, projectDir, resolvedBranch);
+      onProgress?.({
+        phase: "ranking",
+        current: 2,
+        total: 3,
+        message: `PageRank: ${pageRank.iterations} iterations, converged=${pageRank.converged}`
+      });
+      onProgress?.({
+        phase: "metrics",
+        current: 2,
+        total: 3,
+        message: "Computing metrics..."
+      });
+      const metrics = depgraph.computeMetrics(graph, pageRank);
+      depgraph.saveMetrics(metrics, projectDir, resolvedBranch);
+      onProgress?.({
+        phase: "metrics",
+        current: 3,
+        total: 3,
+        message: `Metrics: ${metrics.cycles.length} cycles, ${metrics.totalDefinitions} defs, ${metrics.totalReferences} refs`
+      });
+      depgraphResult = {
+        nodeCount: metrics.totalFiles,
+        edgeCount: metrics.totalEdges,
+        definitionCount: metrics.totalDefinitions,
+        referenceCount: metrics.totalReferences,
+        cycleCount: metrics.cycles.length
+      };
+      log("info", `DepGraph: ${metrics.totalFiles} nodes, ${metrics.totalEdges} edges, ${metrics.totalDefinitions} defs, ${metrics.totalReferences} refs, ${metrics.cycles.length} cycles`);
+    } catch (err) {
+      log("warn", `DepGraph failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  const durationMs = Date.now() - startTime;
+  const storedCount = await store.getItemCount();
+  const stats = {
+    totalFiles: scannedFiles.length,
+    totalChunks: storedCount,
+    staleFiles: embeddingError ? chunks.length - storedCount : 0,
+    indexSizeBytes: store.getIndexSizeBytes(),
+    lastFullIndexMs: durationMs,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeStats(projectDir, resolvedBranch, stats);
+  if (embeddingError) {
+    onProgress?.({
+      phase: "finalizing",
+      current: 3,
+      total: 3,
+      message: `Partial: ${storedCount}/${chunks.length} chunks stored`
+    });
+    throw embeddingError;
+  }
+  onProgress?.({
+    phase: "finalizing",
+    current: 3,
+    total: 3,
+    message: "Done"
+  });
+  return {
+    totalFiles: scannedFiles.length,
+    totalChunks: chunks.length,
+    durationMs,
+    embeddingProvider: embedder.provider,
+    embeddingModel: embedder.model,
+    depgraph: depgraphResult
+  };
+}
+var STORE_BATCH_SIZE = 5e3;
+async function embedAndStore(embedder, texts, chunks, store, batchConfig, onProgress) {
+  if (texts.length === 0) return;
+  const total = texts.length;
+  if (embedder.supportsBatch && embedder.submitBatch && embedder.pollBatch) {
+    await embedAndStoreBatch(embedder, texts, chunks, store, batchConfig, onProgress);
+    return;
+  }
+  onProgress?.({
+    phase: "embedding",
+    current: 0,
+    total,
+    message: "Creating embeddings..."
+  });
+  const allEmbeddings = [];
+  for (let i = 0; i < texts.length; i += batchConfig.size) {
+    const batch = texts.slice(i, i + batchConfig.size);
+    const embeddings = await embedder.embed(batch);
+    allEmbeddings.push(...embeddings);
+    const processed = Math.min(i + batchConfig.size, total);
+    onProgress?.({
+      phase: "embedding",
+      current: processed,
+      total,
+      message: `Embedded ${processed}/${total} chunks`
+    });
+  }
+  onProgress?.({
+    phase: "storing",
+    current: 0,
+    total,
+    message: "Storing vectors..."
+  });
+  for (let i = 0; i < allEmbeddings.length; i += STORE_BATCH_SIZE) {
+    const items = buildVectorItems(chunks, allEmbeddings, i, Math.min(i + STORE_BATCH_SIZE, allEmbeddings.length));
+    await store.upsertItems(items);
+    const stored = Math.min(i + STORE_BATCH_SIZE, allEmbeddings.length);
+    onProgress?.({
+      phase: "storing",
+      current: stored,
+      total,
+      message: `Stored ${stored}/${total} vectors`
+    });
+  }
+}
+async function embedAndStoreBatch(embedder, texts, chunks, store, batchConfig, onProgress) {
+  const total = texts.length;
+  onProgress?.({
+    phase: "embedding",
+    current: 0,
+    total,
+    message: `Submitting batch of ${total} texts...`
+  });
+  const batchId = await embedder.submitBatch(texts);
+  log("info", `Batch submitted: id=${batchId}, texts=${total}`);
+  onProgress?.({
+    phase: "embedding",
+    current: 0,
+    total,
+    message: `Batch ${batchId.slice(0, 8)}... submitted, polling...`
+  });
+  await pollAndStoreProgressively(embedder, batchId, chunks, store, batchConfig, total, onProgress);
+}
+async function pollAndStoreProgressively(embedder, batchId, chunks, store, batchConfig, total, onProgress) {
+  const deadline = batchConfig.timeoutMs > 0 ? Date.now() + batchConfig.timeoutMs : 0;
+  let pollCount = 0;
+  let watermark = 0;
+  while (deadline === 0 || Date.now() < deadline) {
+    const status = await embedder.pollBatch(batchId);
+    pollCount++;
+    if (pollCount <= 3 || pollCount % 10 === 0) {
+      log("info", `Poll #${pollCount} batch=${batchId.slice(0, 8)}: status=${status.status}, processed=${status.processedInputs}/${status.totalInputs}, watermark=${watermark}`);
+    }
+    if (status.results && status.results.length > watermark) {
+      const newCount = status.results.length - watermark;
+      try {
+        for (let i = watermark; i < status.results.length; i += STORE_BATCH_SIZE) {
+          const end = Math.min(i + STORE_BATCH_SIZE, status.results.length);
+          const items = buildVectorItems(chunks, status.results, i, end);
+          await store.upsertItems(items);
+        }
+        const prevWatermark = watermark;
+        watermark = status.results.length;
+        log("info", `Stored ${newCount} new embeddings (${prevWatermark}\u2192${watermark}/${total})`);
+      } catch (storeErr) {
+        log("error", `Store failed at watermark=${watermark}: ${storeErr instanceof Error ? storeErr.message : String(storeErr)}`);
+      }
+    }
+    if (status.status === "failed") {
+      log("error", `Batch ${batchId.slice(0, 8)} failed (watermark=${watermark}/${total} stored)`);
+      throw new Error(`Batch embedding failed (batch ${batchId}). ${watermark} of ${total} chunks were stored before failure.`);
+    }
+    onProgress?.({
+      phase: "embedding",
+      current: watermark,
+      total,
+      message: `Embedded & stored ${watermark}/${total} chunks`
+    });
+    if (status.status === "completed") {
+      log("info", `Batch ${batchId.slice(0, 8)} completed: ${watermark}/${total} stored`);
+      onProgress?.({
+        phase: "embedding",
+        current: total,
+        total,
+        message: `Embedded & stored ${total}/${total} chunks`
+      });
+      return;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, batchConfig.pollIntervalMs));
+  }
+  log("error", `Batch ${batchId} timed out after ${Math.round(batchConfig.timeoutMs / 1e3)}s (${pollCount} polls, watermark=${watermark}/${total})`);
+  throw new Error(
+    `Batch embedding timed out after ${Math.round(batchConfig.timeoutMs / 1e3)}s (batch ${batchId}). ${watermark} of ${total} chunks were stored.`
+  );
+}
+function buildVectorItems(chunks, embeddings, from, to) {
+  const items = [];
+  for (let i = from; i < to; i++) {
+    const chunk = chunks[i];
+    items.push({
+      id: chunk.id,
+      vector: embeddings[i],
+      metadata: {
+        id: chunk.id,
+        filePath: chunk.filePath,
+        startLine: chunk.startLine,
+        endLine: chunk.endLine,
+        snippet: chunk.content.slice(0, 200)
+      }
+    });
+  }
+  return items;
+}
+function writeStats(projectDir, branch, stats) {
+  const statsPath = codemapStatsFile(projectDir, branch);
+  const dir = path11.dirname(statsPath);
+  fs9.mkdirSync(dir, { recursive: true });
+  const tmpPath = statsPath + ".tmp";
+  fs9.writeFileSync(tmpPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+  fs9.renameSync(tmpPath, statsPath);
+}
+var DEFAULT_HYBRID_WEIGHTS = {
+  vector: 0.6,
+  bm25: 0.25,
+  symbolBoost: 0.1,
+  pathBoost: 0.05,
+  graphRank: 0
+};
+function normalizeScores(values) {
+  if (values.length === 0) return [];
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) return values.map(() => 1);
+  return values.map((v) => (v - min) / (max - min));
+}
+function computePathBoost(filePath, queryTerms) {
+  if (queryTerms.length === 0) return 0;
+  const pathLower = filePath.toLowerCase();
+  let matches = 0;
+  for (const term of queryTerms) {
+    if (pathLower.includes(term.toLowerCase())) matches++;
+  }
+  return matches / queryTerms.length;
+}
+function fuseResults(vectorResults, bm25Results, queryTerms, symbolChunkIds, weights, graphRanks) {
+  const vectorScores = vectorResults.map((r) => r.score);
+  const normalizedVector = normalizeScores(vectorScores);
+  const bm25Scores = bm25Results.map((r) => r.score);
+  const normalizedBm25 = normalizeScores(bm25Scores);
+  const candidates = /* @__PURE__ */ new Map();
+  for (let i = 0; i < vectorResults.length; i++) {
+    const vr = vectorResults[i];
+    candidates.set(vr.id, {
+      vectorScore: normalizedVector[i],
+      bm25Score: 0,
+      result: vr,
+      filePath: vr.filePath
+    });
+  }
+  for (let i = 0; i < bm25Results.length; i++) {
+    const br = bm25Results[i];
+    const existing = candidates.get(br.id);
+    if (existing) {
+      existing.bm25Score = normalizedBm25[i];
+    } else {
+      candidates.set(br.id, {
+        vectorScore: 0,
+        bm25Score: normalizedBm25[i],
+        result: null,
+        filePath: br.filePath
+      });
+    }
+  }
+  const scored = [];
+  for (const [id, c] of candidates) {
+    const symbolScore = symbolChunkIds.has(id) ? 1 : 0;
+    const pathBoost = computePathBoost(c.filePath, queryTerms);
+    const graphRankScore = graphRanks?.get(c.filePath) ?? 0;
+    const fusedScore = weights.vector * c.vectorScore + weights.bm25 * c.bm25Score + weights.symbolBoost * symbolScore + weights.pathBoost * pathBoost + (weights.graphRank ?? 0) * graphRankScore;
+    const base = c.result ?? {
+      id,
+      filePath: c.filePath,
+      startLine: 0,
+      endLine: 0,
+      snippet: "",
+      score: 0
+    };
+    scored.push({
+      ...base,
+      score: fusedScore,
+      fusedScore
+    });
+  }
+  scored.sort((a, b) => b.fusedScore - a.fusedScore);
+  return scored.map(({ fusedScore: _, ...rest }) => rest);
+}
+async function searchCode(projectDir, query, options = {}) {
+  const startTime = Date.now();
+  const { limit = 10, threshold = 0, pathPrefix, includeTests = true, includeDocs = true } = options;
+  const resolvedBranch = options.branch ?? getCurrentBranch(projectDir);
+  const config = loadCodemapConfig(projectDir);
+  const embedder = await createEmbedder(config.embedding);
+  const [queryVector] = await embedder.embed([query]);
+  const store = new CodemapStore(projectDir, resolvedBranch);
+  await store.initialize();
+  const hybridConfig = config.hybrid;
+  const bm25Index = hybridConfig?.enabled ? loadBM25Index(projectDir, resolvedBranch) : null;
+  let results;
+  if (bm25Index && hybridConfig?.enabled) {
+    const vectorK = hybridConfig.vectorK ?? 30;
+    const bm25K = hybridConfig.bm25K ?? 30;
+    const weights = hybridConfig.weights ?? { vector: 0.6, bm25: 0.25, symbolBoost: 0.1, pathBoost: 0.05 };
+    const vectorResults = await store.query(queryVector, vectorK);
+    const queryTerms = tokenize(query);
+    const bm25Results = queryBM25(bm25Index, queryTerms, bm25K);
+    const matchingSymbols = searchSymbols(projectDir, query, { limit: 50 }, resolvedBranch);
+    const symbolChunkIds = new Set(matchingSymbols.map((s) => s.chunkId));
+    let graphRanks;
+    if (weights.graphRank && weights.graphRank > 0) {
+      try {
+        const { loadPageRankMap } = await import("./dist-R5ZJ4LX5.js");
+        graphRanks = loadPageRankMap(projectDir, resolvedBranch) ?? void 0;
+      } catch {
+      }
+    }
+    results = fuseResults(vectorResults, bm25Results, queryTerms, symbolChunkIds, weights, graphRanks);
+  } else {
+    const candidateK = Math.min(limit * 3, 80);
+    results = await store.query(queryVector, candidateK);
+  }
+  let filtered = results;
+  if (threshold > 0) {
+    filtered = filtered.filter((r) => r.score >= threshold);
+  }
+  if (pathPrefix) {
+    filtered = filtered.filter((r) => r.filePath.startsWith(pathPrefix));
+  }
+  if (!includeTests) {
+    filtered = filtered.filter((r) => {
+      const lower = r.filePath.toLowerCase();
+      return !lower.includes("__tests__") && !lower.includes(".test.") && !lower.includes(".spec.") && !lower.includes("/test/") && !lower.includes("/tests/");
+    });
+  }
+  if (!includeDocs) {
+    filtered = filtered.filter((r) => {
+      const lower = r.filePath.toLowerCase();
+      return !lower.endsWith(".md") && !lower.endsWith(".mdx");
+    });
+  }
+  filtered = filtered.slice(0, limit);
+  return {
+    query,
+    durationMs: Date.now() - startTime,
+    results: filtered
+  };
+}
+function getCodemapStatus(projectDir, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const codemapDir = codemapBranchDir(projectDir, resolvedBranch);
+  const exists = fs10.existsSync(codemapDir);
+  if (!exists) {
+    const config2 = loadCodemapConfig(projectDir);
+    return {
+      available: true,
+      initialized: false,
+      mode: "idle",
+      branch: resolvedBranch,
+      embeddingProvider: config2.embedding.provider,
+      embeddingModel: config2.embedding.model,
+      dimensions: config2.embedding.dimensions,
+      totalFiles: 0,
+      totalChunks: 0,
+      staleFiles: 0,
+      indexSizeBytes: 0
+    };
+  }
+  const config = loadCodemapConfig(projectDir);
+  const schema = loadSchema(projectDir, resolvedBranch);
+  const stats = loadStats(projectDir, resolvedBranch);
+  let mode = "idle";
+  const watcherPidPath = path12.join(codemapDir, "watcher.pid");
+  if (fs10.existsSync(watcherPidPath)) {
+    try {
+      const pidData = JSON.parse(fs10.readFileSync(watcherPidPath, "utf-8"));
+      if (pidData.pid && typeof pidData.pid === "number") {
+        try {
+          process.kill(pidData.pid, 0);
+          mode = "watching";
+        } catch {
+          try {
+            fs10.unlinkSync(watcherPidPath);
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const configMismatch = schema !== null && (schema.embedding.provider !== config.embedding.provider || schema.embedding.model !== config.embedding.model || schema.vectorStore.dimensions !== config.embedding.dimensions);
+  return {
+    available: true,
+    branch: resolvedBranch,
+    initialized: schema !== null,
+    mode,
+    embeddingProvider: config.embedding.provider,
+    embeddingModel: config.embedding.model,
+    dimensions: config.embedding.dimensions,
+    totalFiles: stats?.totalFiles ?? 0,
+    totalChunks: stats?.totalChunks ?? 0,
+    staleFiles: stats?.staleFiles ?? 0,
+    indexSizeBytes: stats?.indexSizeBytes ?? 0,
+    lastUpdated: stats?.lastUpdated,
+    configMismatch,
+    indexedProvider: schema?.embedding.provider,
+    indexedModel: schema?.embedding.model,
+    indexedDimensions: schema?.vectorStore.dimensions
+  };
+}
+function loadStats(projectDir, branch) {
+  const statsPath = codemapStatsFile(projectDir, branch);
+  if (!fs10.existsSync(statsPath)) return null;
+  try {
+    return JSON.parse(fs10.readFileSync(statsPath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+var DebounceQueue = class {
+  queue = /* @__PURE__ */ new Map();
+  timer = null;
+  debounceMs;
+  /** Callback invoked when the queue flushes */
+  onFlush = null;
+  constructor(debounceMs = 300) {
+    this.debounceMs = debounceMs;
+  }
+  /**
+   * Push an event into the queue. Resets the debounce timer.
+   */
+  push(event) {
+    this.queue.set(event.filePath, event);
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      this.doFlush();
+    }, this.debounceMs);
+  }
+  /**
+   * Immediately flush all queued events, canceling any pending timer.
+   */
+  flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    const events = Array.from(this.queue.values());
+    this.queue.clear();
+    return events;
+  }
+  /**
+   * Current number of queued events.
+   */
+  get depth() {
+    return this.queue.size;
+  }
+  /**
+   * Stop the queue: clear timer and events.
+   */
+  destroy() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    this.queue.clear();
+    this.onFlush = null;
+  }
+  doFlush() {
+    this.timer = null;
+    const events = Array.from(this.queue.values());
+    this.queue.clear();
+    if (events.length > 0 && this.onFlush) {
+      this.onFlush(events);
+    }
+  }
+};
+async function processIncremental(projectDir, events, config, store, embedder, branch) {
+  const startTime = Date.now();
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  let added = 0;
+  let updated = 0;
+  let removed = 0;
+  acquireCodemapLock(projectDir, resolvedBranch);
+  try {
+    const manifest = loadManifest(projectDir, resolvedBranch);
+    if (!manifest) {
+      throw new Error("No manifest found \u2014 run full index first");
+    }
+    const bm25Index = loadBM25Index(projectDir, resolvedBranch);
+    let symbols = loadSymbolIndex(projectDir, resolvedBranch);
+    const unlinkEvents = events.filter((e) => e.type === "unlink");
+    const addChangeEvents = events.filter((e) => e.type === "add" || e.type === "change");
+    for (const event of unlinkEvents) {
+      const entry = manifest.files[event.filePath];
+      if (!entry) continue;
+      await store.removeItems(entry.chunkIds);
+      if (bm25Index) {
+        removeDocuments(bm25Index, entry.chunkIds);
+      }
+      symbols = symbols.filter((s) => s.filePath !== event.filePath);
+      delete manifest.files[event.filePath];
+      removed++;
+    }
+    for (const event of addChangeEvents) {
+      const absPath = path13.join(projectDir, event.filePath);
+      let content;
+      try {
+        content = fs11.readFileSync(absPath, "utf-8");
+      } catch {
+        continue;
+      }
+      const contentHash = createHash6("sha256").update(content).digest("hex");
+      const existingEntry = manifest.files[event.filePath];
+      if (existingEntry && existingEntry.contentHash === contentHash) continue;
+      if (existingEntry) {
+        await store.removeItems(existingEntry.chunkIds);
+        if (bm25Index) {
+          removeDocuments(bm25Index, existingEntry.chunkIds);
+        }
+        symbols = symbols.filter((s) => s.filePath !== event.filePath);
+        updated++;
+      } else {
+        added++;
+      }
+      const chunks = await chunkFile(event.filePath, content, config.chunking);
+      assignChunkIds(chunks, config.chunking.version);
+      if (chunks.length === 0) continue;
+      const chunkSymbols = [];
+      for (const chunk of chunks) {
+        const extracted = extractSymbols(
+          chunk.filePath,
+          chunk.content,
+          chunk.startLine,
+          chunk.endLine,
+          chunk.id
+        );
+        chunkSymbols.push(...extracted);
+      }
+      symbols.push(...chunkSymbols);
+      const texts = buildEmbeddingTexts(chunks, chunkSymbols);
+      const embeddings = await embedder.embed(texts);
+      const vectorItems = chunks.map((chunk, idx) => ({
+        id: chunk.id,
+        vector: embeddings[idx],
+        metadata: {
+          id: chunk.id,
+          filePath: chunk.filePath,
+          startLine: chunk.startLine,
+          endLine: chunk.endLine,
+          snippet: chunk.content.slice(0, 200)
+        }
+      }));
+      await store.upsertItems(vectorItems);
+      if (bm25Index) {
+        const bm25Docs = chunks.map((c) => ({
+          id: c.id,
+          filePath: c.filePath,
+          terms: tokenize(c.filePath + " " + c.content)
+        }));
+        addDocuments(bm25Index, bm25Docs);
+      }
+      const stat = fs11.statSync(absPath);
+      manifest.files[event.filePath] = {
+        contentHash,
+        mtime: stat.mtimeMs,
+        sizeBytes: stat.size,
+        chunkIds: chunks.map((c) => c.id)
+      };
+    }
+    saveManifest(projectDir, resolvedBranch, manifest);
+    if (bm25Index) saveBM25Index(projectDir, resolvedBranch, bm25Index);
+    saveSymbolIndex(projectDir, resolvedBranch, symbols);
+    const statsPath = codemapStatsFile(projectDir, resolvedBranch);
+    try {
+      const statsContent = fs11.readFileSync(statsPath, "utf-8");
+      const stats = JSON.parse(statsContent);
+      stats.totalFiles = Object.keys(manifest.files).length;
+      stats.totalChunks = Object.values(manifest.files).reduce(
+        (sum, f) => sum + f.chunkIds.length,
+        0
+      );
+      stats.staleFiles = 0;
+      stats.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+      const tmpPath = statsPath + ".tmp";
+      fs11.writeFileSync(tmpPath, JSON.stringify(stats, null, 2) + "\n", "utf-8");
+      fs11.renameSync(tmpPath, statsPath);
+    } catch {
+    }
+  } finally {
+    releaseCodemapLock(projectDir, resolvedBranch);
+  }
+  return {
+    added,
+    updated,
+    removed,
+    durationMs: Date.now() - startTime
+  };
+}
+var DEFAULT_RECONCILE_INTERVAL_MS = 60 * 1e3;
+var BINARY_EXTENSIONS2 = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".svg",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".zip",
+  ".gz",
+  ".tar",
+  ".rar",
+  ".7z",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".pyc",
+  ".pyo",
+  ".class",
+  ".lock"
+]);
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".ulpi",
+  "dist",
+  "build",
+  ".next",
+  ".cache",
+  ".turbo",
+  ".parcel-cache",
+  "__pycache__",
+  ".tsbuildinfo"
+]);
+var MAX_RECENT_EVENTS = 20;
+var CodemapWatcher = class {
+  projectDir;
+  branch;
+  reconcileIntervalMs;
+  fsWatcher = null;
+  queue;
+  reconcileTimer = null;
+  running = false;
+  processing = false;
+  pendingEvents = [];
+  _recentEvents = [];
+  _totalEventsProcessed = 0;
+  _lastFlushAt = null;
+  constructor(options) {
+    this.projectDir = options.projectDir;
+    this.branch = options.branch ?? getCurrentBranch(options.projectDir);
+    this.reconcileIntervalMs = options.reconcileIntervalMs ?? DEFAULT_RECONCILE_INTERVAL_MS;
+    this.queue = new DebounceQueue(300);
+  }
+  get isRunning() {
+    return this.running;
+  }
+  get queueDepth() {
+    return this.queue.depth;
+  }
+  get recentEvents() {
+    return this._recentEvents;
+  }
+  get totalEventsProcessed() {
+    return this._totalEventsProcessed;
+  }
+  get lastFlushAt() {
+    return this._lastFlushAt;
+  }
+  trackEvent(type, filePath) {
+    this._recentEvents.push({ type, filePath, ts: (/* @__PURE__ */ new Date()).toISOString() });
+    if (this._recentEvents.length > MAX_RECENT_EVENTS) {
+      this._recentEvents.shift();
+    }
+  }
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    const config = loadCodemapConfig(this.projectDir);
+    const embedder = await createEmbedder(config.embedding);
+    const store = new CodemapStore(this.projectDir, this.branch);
+    await store.initialize();
+    const ignorePatterns = loadCodemapIgnore(this.projectDir);
+    const denyPatterns = [...config.deny, ...ignorePatterns];
+    const processBatch = async (initialEvents) => {
+      this.processing = true;
+      let events = initialEvents;
+      while (events.length > 0) {
+        try {
+          await processIncremental(this.projectDir, events, config, store, embedder, this.branch);
+          this._totalEventsProcessed += events.length;
+          this._lastFlushAt = (/* @__PURE__ */ new Date()).toISOString();
+        } catch (err) {
+          console.error(`[codemap-watcher] Incremental update error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        events = this.drainPendingEvents();
+      }
+      this.processing = false;
+    };
+    this.queue.onFlush = async (events) => {
+      if (events.length === 0) return;
+      if (this.processing) {
+        this.pendingEvents.push(...events);
+        return;
+      }
+      await processBatch(events);
+    };
+    const shouldWatch = (relPath) => {
+      const segments = relPath.split(path14.sep);
+      for (const seg of segments) {
+        if (IGNORED_DIRS.has(seg) || seg.startsWith(".")) return false;
+      }
+      const ext = path14.extname(relPath).toLowerCase();
+      if (BINARY_EXTENSIONS2.has(ext)) return false;
+      if (matchesDenyPattern(relPath, denyPatterns)) return false;
+      return true;
+    };
+    try {
+      this.fsWatcher = fs12.watch(this.projectDir, { recursive: true }, (eventType, filename) => {
+        if (!filename) return;
+        const relPath = filename;
+        if (!shouldWatch(relPath)) return;
+        const absPath = path14.join(this.projectDir, relPath);
+        let type;
+        try {
+          fs12.accessSync(absPath);
+          type = eventType === "rename" ? "add" : "change";
+        } catch {
+          type = "unlink";
+        }
+        this.trackEvent(type, relPath);
+        this.queue.push({ type, filePath: relPath, timestamp: Date.now() });
+      });
+      this.fsWatcher.on("error", (err) => {
+        console.error(`[codemap-watcher] fs.watch error: ${err.message}`);
+      });
+    } catch (err) {
+      console.error(`[codemap-watcher] Failed to start fs.watch: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    this.reconcileTimer = setInterval(async () => {
+      if (this.processing) return;
+      try {
+        const currentConfig = loadCodemapConfig(this.projectDir);
+        const scannedFiles = scanRepository(this.projectDir, currentConfig);
+        const manifest = loadManifest(this.projectDir, this.branch);
+        const diff = diffManifest(manifest, scannedFiles);
+        for (const file of diff.added) {
+          this.queue.push({ type: "add", filePath: file.filePath, timestamp: Date.now() });
+        }
+        for (const file of diff.updated) {
+          this.queue.push({ type: "change", filePath: file.filePath, timestamp: Date.now() });
+        }
+        for (const filePath of diff.removed) {
+          this.queue.push({ type: "unlink", filePath, timestamp: Date.now() });
+        }
+      } catch (err) {
+        console.error(`[codemap-watcher] Reconciliation error: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }, this.reconcileIntervalMs);
+    this.writePidFile();
+    const shutdown = () => {
+      this.stop().catch(() => {
+      });
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+  async stop() {
+    if (!this.running) return;
+    this.running = false;
+    if (this.fsWatcher) {
+      this.fsWatcher.close();
+      this.fsWatcher = null;
+    }
+    if (this.reconcileTimer) {
+      clearInterval(this.reconcileTimer);
+      this.reconcileTimer = null;
+    }
+    const queued = this.queue.flush();
+    const pending = this.drainPendingEvents();
+    const deduped = /* @__PURE__ */ new Map();
+    for (const e of [...queued, ...pending]) deduped.set(e.filePath, e);
+    const remaining = Array.from(deduped.values());
+    if (remaining.length > 0) {
+      try {
+        const config = loadCodemapConfig(this.projectDir);
+        const embedder = await createEmbedder(config.embedding);
+        const store = new CodemapStore(this.projectDir, this.branch);
+        await processIncremental(this.projectDir, remaining, config, store, embedder, this.branch);
+      } catch {
+      }
+    }
+    this.queue.destroy();
+    this.removePidFile();
+  }
+  /**
+   * Drain pending events buffer, deduplicating by file path (keep latest).
+   */
+  drainPendingEvents() {
+    if (this.pendingEvents.length === 0) return [];
+    const events = this.pendingEvents;
+    this.pendingEvents = [];
+    const deduped = /* @__PURE__ */ new Map();
+    for (const e of events) deduped.set(e.filePath, e);
+    return Array.from(deduped.values());
+  }
+  writePidFile() {
+    const pidPath = path14.join(codemapBranchDir(this.projectDir, this.branch), "watcher.pid");
+    try {
+      fs12.mkdirSync(path14.dirname(pidPath), { recursive: true });
+      const data = { pid: process.pid, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      fs12.writeFileSync(pidPath, JSON.stringify(data), "utf-8");
+    } catch {
+    }
+  }
+  removePidFile() {
+    const pidPath = path14.join(codemapBranchDir(this.projectDir, this.branch), "watcher.pid");
+    try {
+      fs12.unlinkSync(pidPath);
+    } catch {
+    }
+  }
+};
+var GITHUB_MAX_FILE_BYTES = 100 * 1024 * 1024;
+var GITHUB_WARN_FILE_BYTES = 50 * 1024 * 1024;
+function ensureBranch(projectDir, branchName) {
+  if (historyBranchExists(projectDir, branchName)) return;
+  const emptyBlob = execFileSync2("git", ["hash-object", "-t", "blob", "--stdin"], {
+    cwd: projectDir,
+    input: "",
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  const tree = execFileSync2("git", ["mktree"], {
+    cwd: projectDir,
+    input: `100644 blob ${emptyBlob}	.gitkeep
+`,
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  const commit = execFileSync2("git", ["commit-tree", tree, "-m", "init codemap index branch"], {
+    cwd: projectDir,
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  execFileSync2("git", ["update-ref", `refs/heads/${branchName}`, commit], {
+    cwd: projectDir,
+    timeout: 5e3
+  });
+}
+async function exportIndex(projectDir, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const schema = loadSchema(projectDir, resolvedBranch);
+  if (!schema) {
+    throw new Error("Index not initialized. Run 'ulpi codemap init' first.");
+  }
+  const branchName = getCodemapBranch(resolvedBranch);
+  ensureBranch(projectDir, branchName);
+  const codemapDir = codemapBranchDir(projectDir, resolvedBranch);
+  const lanceDir = codemapLanceDir(projectDir, resolvedBranch);
+  let filesExported = 0;
+  let totalSizeBytes = 0;
+  const commitSha = await withWorktree(projectDir, branchName, (worktreeDir) => {
+    const textFiles = [
+      ["schema.json", codemapSchemaFile(projectDir, resolvedBranch)],
+      ["manifest.json", codemapManifestFile(projectDir, resolvedBranch)],
+      ["config.json", codemapConfigFile(projectDir)],
+      ["stats.json", codemapStatsFile(projectDir, resolvedBranch)]
+    ];
+    for (const [name, sourcePath] of textFiles) {
+      if (fs13.existsSync(sourcePath)) {
+        const content = fs13.readFileSync(sourcePath, "utf-8");
+        writeAndStage(worktreeDir, name, content);
+        totalSizeBytes += Buffer.byteLength(content, "utf-8");
+        filesExported++;
+      }
+    }
+    if (fs13.existsSync(lanceDir)) {
+      const result = copyDirRecursive(lanceDir, worktreeDir, "index/lance");
+      filesExported += result.fileCount;
+      totalSizeBytes += result.totalBytes;
+      for (const w of result.warnings) {
+        process.stderr.write(`[ulpi codemap] Warning: ${w}
+`);
+      }
+    }
+    const metadataDir = codemapMetadataDir(projectDir, resolvedBranch);
+    if (fs13.existsSync(metadataDir)) {
+      const metadataFiles = fs13.readdirSync(metadataDir);
+      for (const file of metadataFiles) {
+        const sourcePath = path15.join(metadataDir, file);
+        const stat = fs13.statSync(sourcePath);
+        if (stat.isFile()) {
+          copyAndStage(worktreeDir, `index/metadata/${file}`, sourcePath);
+          totalSizeBytes += stat.size;
+          filesExported++;
+        }
+      }
+    }
+    const exportMeta = {
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      indexVersion: 1,
+      vectorStoreFormatVersion: 1,
+      engine: "lancedb"
+    };
+    writeAndStage(worktreeDir, "export-meta.json", JSON.stringify(exportMeta, null, 2) + "\n");
+    filesExported++;
+    return commitInWorktree(worktreeDir, `codemap: export index (${filesExported} files)`);
+  });
+  const commitMessage = `codemap: export index (${filesExported} files)`;
+  const tree = execFileSync2("git", ["rev-parse", `${commitSha}^{tree}`], {
+    cwd: projectDir,
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  const orphanSha = execFileSync2("git", ["commit-tree", tree, "-m", commitMessage], {
+    cwd: projectDir,
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  execFileSync2("git", ["update-ref", `refs/heads/${branchName}`, orphanSha], {
+    cwd: projectDir,
+    timeout: 5e3
+  });
+  return {
+    branchName,
+    commitSha: orphanSha,
+    filesExported,
+    totalSizeBytes
+  };
+}
+function copyDirRecursive(srcDir, worktreeDir, prefix) {
+  let fileCount = 0;
+  let totalBytes = 0;
+  const warnings = [];
+  const entries = fs13.readdirSync(srcDir);
+  for (const entry of entries) {
+    const srcPath = path15.join(srcDir, entry);
+    const destRelative = `${prefix}/${entry}`;
+    const stat = fs13.statSync(srcPath);
+    if (stat.isDirectory()) {
+      const sub = copyDirRecursive(srcPath, worktreeDir, destRelative);
+      fileCount += sub.fileCount;
+      totalBytes += sub.totalBytes;
+      warnings.push(...sub.warnings);
+    } else if (stat.isFile()) {
+      if (stat.size >= GITHUB_MAX_FILE_BYTES) {
+        throw new Error(
+          `File "${destRelative}" is ${Math.round(stat.size / 1024 / 1024)} MB, exceeding GitHub's 100 MB limit. Run a full reindex to regenerate the index with smaller fragment files.`
+        );
+      }
+      if (stat.size >= GITHUB_WARN_FILE_BYTES) {
+        warnings.push(
+          `File "${destRelative}" is ${Math.round(stat.size / 1024 / 1024)} MB (GitHub warns at 50 MB)`
+        );
+      }
+      copyAndStage(worktreeDir, destRelative, srcPath);
+      totalBytes += stat.size;
+      fileCount++;
+    }
+  }
+  return { fileCount, totalBytes, warnings };
+}
+async function importIndex(projectDir, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  const branchName = getCodemapBranch(resolvedBranch);
+  if (!historyBranchExists(projectDir, branchName)) {
+    throw new Error(`Branch '${branchName}' does not exist. Nothing to import.`);
+  }
+  const codemapDir = codemapBranchDir(projectDir, resolvedBranch);
+  let filesImported = 0;
+  let totalSizeBytes = 0;
+  let rebuildRecommended = false;
+  await withWorktree(projectDir, branchName, (worktreeDir) => {
+    const metaPath = path16.join(worktreeDir, "export-meta.json");
+    if (!fs14.existsSync(metaPath)) {
+      throw new Error("No export-meta.json found on branch. Invalid export.");
+    }
+    const meta = JSON.parse(fs14.readFileSync(metaPath, "utf-8"));
+    if (meta.indexVersion !== 1) {
+      throw new Error(`Unsupported index version: ${meta.indexVersion}`);
+    }
+    if (meta.engine !== "lancedb") {
+      throw new Error(`Unsupported engine: ${meta.engine}. Expected 'lancedb'.`);
+    }
+    const schemaPath = path16.join(worktreeDir, "schema.json");
+    if (!fs14.existsSync(schemaPath)) {
+      throw new Error("No schema.json found on branch.");
+    }
+    const schema = JSON.parse(fs14.readFileSync(schemaPath, "utf-8"));
+    const tmpDir = codemapDir + ".import-tmp";
+    fs14.mkdirSync(tmpDir, { recursive: true });
+    try {
+      const textFiles = ["schema.json", "manifest.json", "config.json", "stats.json"];
+      for (const file of textFiles) {
+        const src = path16.join(worktreeDir, file);
+        if (fs14.existsSync(src)) {
+          const content = fs14.readFileSync(src);
+          const dest = path16.join(tmpDir, file);
+          fs14.writeFileSync(dest, content);
+          totalSizeBytes += content.length;
+          filesImported++;
+        }
+      }
+      const lanceSrcDir = path16.join(worktreeDir, "index", "lance");
+      if (fs14.existsSync(lanceSrcDir)) {
+        const lanceDestDir = path16.join(tmpDir, "index", "lance");
+        const result = copyDirRecursiveImport(lanceSrcDir, lanceDestDir);
+        filesImported += result.fileCount;
+        totalSizeBytes += result.totalBytes;
+      }
+      const metadataSrcDir = path16.join(worktreeDir, "index", "metadata");
+      if (fs14.existsSync(metadataSrcDir)) {
+        const metadataDestDir = path16.join(tmpDir, "index", "metadata");
+        fs14.mkdirSync(metadataDestDir, { recursive: true });
+        const files = fs14.readdirSync(metadataSrcDir);
+        for (const file of files) {
+          const src = path16.join(metadataSrcDir, file);
+          const stat = fs14.statSync(src);
+          if (stat.isFile()) {
+            fs14.copyFileSync(src, path16.join(metadataDestDir, file));
+            totalSizeBytes += stat.size;
+            filesImported++;
+          }
+        }
+      }
+      if (fs14.existsSync(codemapDir)) {
+        fs14.rmSync(codemapDir, { recursive: true });
+      }
+      fs14.renameSync(tmpDir, codemapDir);
+    } catch (err) {
+      try {
+        fs14.rmSync(tmpDir, { recursive: true });
+      } catch {
+      }
+      throw err;
+    }
+    try {
+      const config = loadCodemapConfig(projectDir);
+      if (schema.embedding?.provider && schema.embedding.provider !== config.embedding.provider) {
+        rebuildRecommended = true;
+      }
+      if (schema.embedding?.model && schema.embedding.model !== config.embedding.model) {
+        rebuildRecommended = true;
+      }
+    } catch {
+    }
+  });
+  return {
+    success: true,
+    filesImported,
+    totalSizeBytes,
+    rebuildRecommended,
+    message: rebuildRecommended ? "Import complete. Rebuild recommended: embedding provider/model mismatch." : "Import complete."
+  };
+}
+function copyDirRecursiveImport(srcDir, destDir) {
+  let fileCount = 0;
+  let totalBytes = 0;
+  fs14.mkdirSync(destDir, { recursive: true });
+  const entries = fs14.readdirSync(srcDir);
+  for (const entry of entries) {
+    const srcPath = path16.join(srcDir, entry);
+    const destPath = path16.join(destDir, entry);
+    const stat = fs14.statSync(srcPath);
+    if (stat.isDirectory()) {
+      const sub = copyDirRecursiveImport(srcPath, destPath);
+      fileCount += sub.fileCount;
+      totalBytes += sub.totalBytes;
+    } else if (stat.isFile()) {
+      fs14.copyFileSync(srcPath, destPath);
+      totalBytes += stat.size;
+      fileCount++;
+    }
+  }
+  return { fileCount, totalBytes };
+}
+function copyDirRecursive2(src, dest) {
+  let files = 0;
+  let bytes = 0;
+  fs15.mkdirSync(dest, { recursive: true });
+  const entries = fs15.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path17.join(src, entry.name);
+    const destPath = path17.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      const sub = copyDirRecursive2(srcPath, destPath);
+      files += sub.files;
+      bytes += sub.bytes;
+    } else if (entry.isFile()) {
+      fs15.copyFileSync(srcPath, destPath);
+      const stat = fs15.statSync(srcPath);
+      bytes += stat.size;
+      files++;
+    }
+  }
+  return { files, bytes };
+}
+async function migrateFromLegacy(projectDir) {
+  const legacyDir = path17.join(projectDir, ".codemap");
+  const targetDir = projectCodemapDir(projectDir);
+  if (!fs15.existsSync(legacyDir)) {
+    return {
+      migrated: false,
+      filesCount: 0,
+      totalSizeBytes: 0,
+      message: "No legacy .codemap/ directory found."
+    };
+  }
+  const targetSchema = codemapSchemaFile(projectDir, "main");
+  if (fs15.existsSync(targetSchema)) {
+    return {
+      migrated: false,
+      filesCount: 0,
+      totalSizeBytes: 0,
+      message: "Target .ulpi/codemap/ already has an index. Skipping migration."
+    };
+  }
+  const legacySchema = path17.join(legacyDir, "schema.json");
+  if (fs15.existsSync(legacySchema)) {
+    try {
+      const schema = JSON.parse(fs15.readFileSync(legacySchema, "utf-8"));
+      if (schema.formatVersion !== 1) {
+        return {
+          migrated: false,
+          filesCount: 0,
+          totalSizeBytes: 0,
+          message: `Unsupported legacy schema version: ${schema.formatVersion}`
+        };
+      }
+    } catch {
+      return {
+        migrated: false,
+        filesCount: 0,
+        totalSizeBytes: 0,
+        message: "Invalid schema.json in legacy directory."
+      };
+    }
+  }
+  const { files, bytes } = copyDirRecursive2(legacyDir, targetDir);
+  return {
+    migrated: true,
+    filesCount: files,
+    totalSizeBytes: bytes,
+    message: `Migration complete. Copied ${files} files (${(bytes / 1024).toFixed(1)} KB). Legacy .codemap/ preserved.`
+  };
+}
+async function migrateToPerBranch(projectDir) {
+  const codemapDir = projectCodemapDir(projectDir);
+  const flatSchema = path17.join(codemapDir, "schema.json");
+  if (!fs15.existsSync(flatSchema)) {
+    return {
+      migrated: false,
+      filesCount: 0,
+      totalSizeBytes: 0,
+      message: "No flat codemap layout detected. Nothing to migrate."
+    };
+  }
+  const branch = getCurrentBranch(projectDir);
+  const branchDir = codemapBranchDir(projectDir, branch);
+  if (fs15.existsSync(path17.join(branchDir, "schema.json"))) {
+    return {
+      migrated: false,
+      filesCount: 0,
+      totalSizeBytes: 0,
+      message: `Per-branch layout already exists for branch "${branch}".`
+    };
+  }
+  const dataFiles = ["schema.json", "manifest.json", "stats.json"];
+  const dataDirs = ["index"];
+  let files = 0;
+  let bytes = 0;
+  fs15.mkdirSync(branchDir, { recursive: true });
+  for (const name of dataFiles) {
+    const src = path17.join(codemapDir, name);
+    if (fs15.existsSync(src)) {
+      const dest = path17.join(branchDir, name);
+      fs15.renameSync(src, dest);
+      try {
+        const stat = fs15.statSync(dest);
+        bytes += stat.size;
+      } catch {
+      }
+      files++;
+    }
+  }
+  for (const dir of dataDirs) {
+    const src = path17.join(codemapDir, dir);
+    if (fs15.existsSync(src)) {
+      const dest = path17.join(branchDir, dir);
+      fs15.renameSync(src, dest);
+      files++;
+    }
+  }
+  return {
+    migrated: true,
+    filesCount: files,
+    totalSizeBytes: bytes,
+    message: `Migrated flat layout to per-branch layout for "${branch}". ${files} items moved.`
+  };
+}
+function loadEvalDataset(datasetPath) {
+  if (!fs16.existsSync(datasetPath)) {
+    throw new Error(`Dataset file not found: ${datasetPath}`);
+  }
+  const raw = JSON.parse(fs16.readFileSync(datasetPath, "utf-8"));
+  if (raw.version !== 1) {
+    throw new Error(`Unsupported dataset version: ${raw.version}. Expected 1.`);
+  }
+  if (!Array.isArray(raw.queries) || raw.queries.length === 0) {
+    throw new Error("Dataset must have a non-empty 'queries' array.");
+  }
+  for (let i = 0; i < raw.queries.length; i++) {
+    const q = raw.queries[i];
+    if (typeof q.query !== "string" || !q.query.trim()) {
+      throw new Error(`Query at index ${i} must have a non-empty 'query' string.`);
+    }
+    if (!Array.isArray(q.expectedFiles) || q.expectedFiles.length === 0) {
+      throw new Error(`Query at index ${i} must have a non-empty 'expectedFiles' array.`);
+    }
+  }
+  return raw;
+}
+function recallAtK(expected, returned, k) {
+  if (expected.length === 0) return 0;
+  const topK = new Set(returned.slice(0, k));
+  let found = 0;
+  for (const item of expected) {
+    if (topK.has(item)) found++;
+  }
+  return found / expected.length;
+}
+function mrrAtK(expected, returned, k) {
+  const expectedSet = new Set(expected);
+  const topK = returned.slice(0, k);
+  for (let i = 0; i < topK.length; i++) {
+    if (expectedSet.has(topK[i])) {
+      return 1 / (i + 1);
+    }
+  }
+  return 0;
+}
+function ndcgAtK(expected, returned, k) {
+  if (expected.length === 0) return 0;
+  const expectedSet = new Set(expected);
+  const topK = returned.slice(0, k);
+  let dcg = 0;
+  for (let i = 0; i < topK.length; i++) {
+    if (expectedSet.has(topK[i])) {
+      dcg += 1 / Math.log2(i + 2);
+    }
+  }
+  const idealCount = Math.min(expected.length, k);
+  let idcg = 0;
+  for (let i = 0; i < idealCount; i++) {
+    idcg += 1 / Math.log2(i + 2);
+  }
+  if (idcg === 0) return 0;
+  return dcg / idcg;
+}
+async function runEvalHarness(projectDir, datasetPath) {
+  const dataset = loadEvalDataset(datasetPath);
+  const totalStart = Date.now();
+  const perQuery = [];
+  for (const evalQuery of dataset.queries) {
+    const queryStart = Date.now();
+    const result = await searchCode(projectDir, evalQuery.query, { limit: 10 });
+    const returnedFiles = [...new Set(result.results.map((r) => r.filePath))];
+    const recall5 = recallAtK(evalQuery.expectedFiles, returnedFiles, 5);
+    const mrr10 = mrrAtK(evalQuery.expectedFiles, returnedFiles, 10);
+    const ndcg10 = ndcgAtK(evalQuery.expectedFiles, returnedFiles, 10);
+    perQuery.push({
+      query: evalQuery.query,
+      returnedFiles,
+      expectedFiles: evalQuery.expectedFiles,
+      recallAt5: recall5,
+      mrrAt10: mrr10,
+      ndcgAt10: ndcg10,
+      durationMs: Date.now() - queryStart
+    });
+  }
+  const aggregate = {
+    recallAt5: perQuery.reduce((sum, q) => sum + q.recallAt5, 0) / perQuery.length,
+    mrrAt10: perQuery.reduce((sum, q) => sum + q.mrrAt10, 0) / perQuery.length,
+    ndcgAt10: perQuery.reduce((sum, q) => sum + q.ndcgAt10, 0) / perQuery.length
+  };
+  const totalMs = Date.now() - totalStart;
+  return {
+    aggregate,
+    perQuery,
+    timing: {
+      totalMs,
+      avgPerQueryMs: totalMs / perQuery.length
+    },
+    datasetVersion: dataset.version,
+    queriesCount: dataset.queries.length
+  };
+}
+
+export {
+  DEFAULT_CODEMAP_CONFIG,
+  loadCodemapConfig,
+  saveCodemapConfig,
+  matchesDenyPattern,
+  loadCodemapIgnore,
+  scanRepository,
+  SUPPORTED_EXTENSIONS,
+  getLanguageConfig,
+  getLanguageId,
+  initTreeSitter,
+  loadLanguage,
+  parseSourceWithLanguage,
+  chunkFileAST,
+  parseAndChunkFile,
+  chunkFile,
+  chunkFiles,
+  generateChunkId,
+  assignChunkIds,
+  buildManifest,
+  loadManifest,
+  saveManifest,
+  diffManifest,
+  createEmbedder,
+  CodemapStore,
+  saveSchema,
+  loadSchema,
+  extractSymbols,
+  extractSymbolsFromChunks,
+  saveSymbolIndex,
+  loadSymbolIndex,
+  searchSymbols,
+  tokenize,
+  buildBM25Index,
+  addDocuments,
+  removeDocuments,
+  queryBM25,
+  saveBM25Index,
+  loadBM25Index,
+  acquireCodemapLock,
+  releaseCodemapLock,
+  isCodemapLocked,
+  buildEmbeddingTexts,
+  runInitPipeline,
+  DEFAULT_HYBRID_WEIGHTS,
+  normalizeScores,
+  computePathBoost,
+  fuseResults,
+  searchCode,
+  getCodemapStatus,
+  DebounceQueue,
+  processIncremental,
+  CodemapWatcher,
+  exportIndex,
+  importIndex,
+  migrateFromLegacy,
+  migrateToPerBranch,
+  loadEvalDataset,
+  recallAtK,
+  mrrAtK,
+  ndcgAtK,
+  runEvalHarness
+};