@ulpi/cli 0.1.1 → 0.1.3

package/dist/auth-KQCJ43U2.js

@@ -0,0 +1,118 @@
+import {
+  extractCredentials,
+  getCredentialExpiry,
+  validateCredentials
+} from "./chunk-G6SVZ4Q5.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/auth.ts
+import * as fs from "fs";
+import chalk from "chalk";
+async function runAuth(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "setup":
+      return authSetup();
+    case "check":
+      return authCheck(args.slice(1));
+    case "refresh":
+      return authSetup();
+    // Same flow as setup
+    default:
+      console.log(`
+${chalk.bold("ulpi auth")} \u2014 Manage Claude Code credentials for CI workers
+
+Usage: ulpi auth <command>
+
+Commands:
+  setup     Extract Claude Code credentials for CI use (interactive)
+  check     Validate stored credentials
+  refresh   Re-authenticate and output new credentials
+
+How it works:
+  1. Run 'ulpi auth setup' on a machine with a browser
+  2. It extracts your Claude Code session credentials
+  3. Outputs a base64 blob you can store as a Docker secret
+  4. Set ULPI_CLAUDE_CREDENTIALS in your orchestrator config
+`.trim());
+  }
+}
+async function authSetup() {
+  console.log(chalk.blue("Extracting Claude Code credentials..."));
+  console.log();
+  const claudeDir = process.env.CLAUDE_CONFIG_DIR ?? `${process.env.HOME}/.claude`;
+  if (!fs.existsSync(claudeDir)) {
+    console.log(chalk.yellow("No Claude Code configuration found."));
+    console.log();
+    console.log("Please run 'claude login' first to authenticate with Anthropic.");
+    console.log("Then run 'ulpi auth setup' again.");
+    process.exit(1);
+  }
+  try {
+    const blob = extractCredentials(claudeDir);
+    const expiry = getCredentialExpiry(blob);
+    console.log(chalk.green("Credentials extracted successfully."));
+    console.log();
+    if (expiry) {
+      console.log(`  Expires: ${expiry}`);
+      console.log();
+    }
+    console.log(chalk.bold("Your credentials blob:"));
+    console.log();
+    console.log(blob);
+    console.log();
+    console.log(chalk.bold("To use in your orchestrator:"));
+    console.log();
+    console.log("  1. Set as environment variable:");
+    console.log(chalk.cyan(`     export ULPI_CLAUDE_CREDENTIALS="${blob.slice(0, 20)}..."`));
+    console.log();
+    console.log("  2. Or add to docker-compose.yml:");
+    console.log(chalk.cyan("     environment:"));
+    console.log(chalk.cyan("       - ULPI_CLAUDE_CREDENTIALS=${ULPI_CLAUDE_CREDENTIALS}"));
+    console.log();
+    console.log("  3. Or store as a Docker secret:");
+    console.log(chalk.cyan(`     echo "${blob.slice(0, 20)}..." | docker secret create ulpi-claude-creds -`));
+    console.log();
+    console.log(chalk.yellow("Keep this blob safe \u2014 it contains your Claude Code session credentials."));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function authCheck(args) {
+  const blob = args[0] ?? process.env.ULPI_CLAUDE_CREDENTIALS;
+  if (!blob) {
+    console.error(chalk.red("Error: No credentials provided."));
+    console.log("  Provide as argument: ulpi auth check <blob>");
+    console.log("  Or set ULPI_CLAUDE_CREDENTIALS env var");
+    process.exit(1);
+  }
+  console.log(chalk.blue("Validating credentials..."));
+  const valid = validateCredentials(blob);
+  const expiry = getCredentialExpiry(blob);
+  if (valid) {
+    console.log(chalk.green("Credentials are valid."));
+    if (expiry) {
+      const expiryDate = new Date(expiry);
+      const now = /* @__PURE__ */ new Date();
+      const hoursLeft = (expiryDate.getTime() - now.getTime()) / (60 * 60 * 1e3);
+      if (hoursLeft < 0) {
+        console.log(chalk.red(`  Expired: ${expiry}`));
+        console.log(chalk.yellow("  Run 'ulpi auth refresh' to re-authenticate."));
+      } else if (hoursLeft < 24) {
+        console.log(chalk.yellow(`  Expires soon: ${expiry} (${Math.floor(hoursLeft)}h remaining)`));
+        console.log(chalk.yellow("  Consider running 'ulpi auth refresh' soon."));
+      } else {
+        console.log(chalk.green(`  Expires: ${expiry}`));
+      }
+    }
+  } else {
+    console.log(chalk.red("Credentials are invalid or corrupted."));
+    console.log("Run 'ulpi auth setup' to generate new credentials.");
+    process.exit(1);
+  }
+}
+export {
+  runAuth
+};

package/dist/{chunk-Q4HIY43N.js → chunk-2VYFVYJL.js}

@@ -49,7 +49,7 @@ import {
   updateEntryEnrichment,
   withWorktree,
   writeAndStage
-} from "./chunk-NNUWU6CV.js";
+} from "./chunk-JGBXM5NC.js";
 import {
   JsonSessionStore,
   readEvents
@@ -74,7 +74,7 @@ import {
   saveUlpiSettings
 } from "./chunk-7LXY5UVC.js";
 
-// ../api/dist/chunk-3N5EEDFM.js
+// ../api/dist/chunk-P4BERD2G.js
 import * as http from "http";
 import * as fs12 from "fs";
 import * as path9 from "path";
@@ -394,33 +394,51 @@ async function putUsernameSettings(ctx) {
     resolvedHistoryBranch: getHistoryBranch()
   }, 200, ctx.req);
 }
+function yamlEscapeString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
 function writeYamlFields(obj, lines, indent) {
   const pad = " ".repeat(indent);
   for (const [k, v] of Object.entries(obj)) {
     if (k === "id" || k === "type" || k === "source") continue;
     if (typeof v === "string") {
-      lines.push(`${pad}${k}: "${v}"`);
+      lines.push(`${pad}${k}: "${yamlEscapeString(v)}"`);
     } else if (typeof v === "boolean" || typeof v === "number") {
       lines.push(`${pad}${k}: ${v}`);
     } else if (Array.isArray(v)) {
       lines.push(`${pad}${k}:`);
       for (const item of v) {
         if (typeof item === "string") {
-          lines.push(`${pad}  - "${item}"`);
+          lines.push(`${pad}  - "${yamlEscapeString(item)}"`);
+        } else if (item && typeof item === "object") {
+          const entries = Object.entries(item);
+          if (entries.length > 0) {
+            const [firstKey, firstVal] = entries[0];
+            lines.push(`${pad}  - ${firstKey}: ${formatScalar(firstVal)}`);
+            for (let i = 1; i < entries.length; i++) {
+              const [ek, ev] = entries[i];
+              lines.push(`${pad}    ${ek}: ${formatScalar(ev)}`);
+            }
+          }
         }
       }
     }
   }
 }
+function formatScalar(v) {
+  if (typeof v === "string") return `"${yamlEscapeString(v)}"`;
+  if (typeof v === "boolean" || typeof v === "number") return String(v);
+  return `"${String(v)}"`;
+}
 function writeRulesConfig(rulesPath, config) {
   const lines = [
     "# ULPI \u2014 Rules Configuration",
     "# Generated via Web UI",
     "",
     "project:",
-    `  name: "${config.project.name}"`,
-    `  runtime: "${config.project.runtime}"`,
-    `  package_manager: "${config.project.package_manager}"`,
+    `  name: "${yamlEscapeString(config.project.name)}"`,
+    `  runtime: "${yamlEscapeString(config.project.runtime)}"`,
+    `  package_manager: "${yamlEscapeString(config.project.package_manager)}"`,
     ""
   ];
   const sections = [
@@ -2245,7 +2263,7 @@ async function exportObsidian(ctx) {
   jsonResponse(ctx.res, { format: "obsidian", content: md }, 200, ctx.req);
 }
 async function getEngine() {
-  return await import("./dist-LZKZFPVX.js");
+  return await import("./dist-CB5D5LMO.js");
 }
 var runningPipelines = /* @__PURE__ */ new Map();
 var activeWatchers = /* @__PURE__ */ new Map();
@@ -2551,7 +2569,7 @@ async function codemapActionHandler(ctx) {
   }
 }
 async function getEngine2() {
-  return await import("./dist-R5F4MX3I.js");
+  return await import("./dist-GJYT2OQV.js");
 }
 async function memoryStatusHandler(ctx) {
   try {
@@ -2559,7 +2577,8 @@ async function memoryStatusHandler(ctx) {
     const stats = await engine.getMemoryStats(ctx.projectDir);
     const config = engine.loadMemoryConfig(ctx.projectDir);
     const initialized = engine.isMemoryInitialized(ctx.projectDir);
-    jsonResponse(ctx.res, { stats, config, initialized }, 200, ctx.req);
+    const classifyProgress = engine.readClassifyBatchProgress(ctx.projectDir);
+    jsonResponse(ctx.res, { stats, config, initialized, classifyProgress }, 200, ctx.req);
   } catch (err) {
     const message = err instanceof Error ? err.message : "Failed to get memory status";
     jsonResponse(ctx.res, { error: message }, 500, ctx.req);
@@ -2739,7 +2758,7 @@ async function memoryActionHandler(ctx) {
     return;
   }
   const action = data.action;
-  const validActions = ["init", "export", "import", "enable", "disable", "classify", "reindex"];
+  const validActions = ["init", "export", "import", "enable", "disable", "classify", "classify-all", "classify-clear", "reindex"];
   if (!validActions.includes(action)) {
     jsonResponse(
       ctx.res,
@@ -2765,12 +2784,12 @@ async function memoryActionHandler(ctx) {
         return;
       }
       case "export": {
-        const result = engine.exportMemories(ctx.projectDir);
+        const result = await engine.exportMemories(ctx.projectDir);
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
         return;
       }
       case "import": {
-        const result = engine.importMemories(ctx.projectDir);
+        const result = await engine.importMemories(ctx.projectDir);
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
         return;
       }
@@ -2796,6 +2815,32 @@ async function memoryActionHandler(ctx) {
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
         return;
       }
+      case "classify-all": {
+        const { spawn: spawn4 } = await import("child_process");
+        const ulpiBin = process.argv[1];
+        const args = ["memory", "classify", "-p", ctx.projectDir];
+        if (typeof data.branch === "string" && data.branch) {
+          args.push("--branch", data.branch);
+        }
+        if (data.export) args.push("--export");
+        const child = spawn4(process.execPath, [ulpiBin, ...args], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, ULPI_BG_CLASSIFY: "1" }
+        });
+        child.unref();
+        jsonResponse(ctx.res, {
+          ok: true,
+          action,
+          message: "Classification started"
+        }, 200, ctx.req);
+        return;
+      }
+      case "classify-clear": {
+        engine.clearClassifyBatchProgress(ctx.projectDir);
+        jsonResponse(ctx.res, { ok: true, action, message: "Classification progress cleared" }, 200, ctx.req);
+        return;
+      }
       case "reindex": {
         const result = await engine.reindexMemories(ctx.projectDir);
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
@@ -2855,7 +2900,7 @@ async function memoryConfigUpdateHandler(ctx) {
   }
 }
 async function getDepgraph() {
-  return await import("./dist-R5ZJ4LX5.js");
+  return await import("./dist-YA2BWZB2.js");
 }
 async function getBranch(projectDir) {
   const { getCurrentBranch: getCurrentBranch2 } = await import("./dist-RKOGLK7R.js");
@@ -3014,11 +3059,7 @@ async function depgraphMetricsHandler(ctx) {
     jsonResponse(ctx.res, { error: error ?? "Invalid request body" }, 400, ctx.req);
     return;
   }
-  const modulePath = data.modulePath;
-  if (typeof modulePath !== "string" || !modulePath.trim()) {
-    jsonResponse(ctx.res, { error: "Missing or empty 'modulePath' field" }, 400, ctx.req);
-    return;
-  }
+  const modulePath = typeof data.modulePath === "string" ? data.modulePath : "";
   try {
     const depgraph = await getDepgraph();
     const branch = await getBranch(ctx.projectDir);
@@ -3461,7 +3502,7 @@ async function historyInitHandler(ctx) {
     }
     let gitHooksResult = { installed: [], skipped: [] };
     try {
-      const { installGitHooks } = await import("./dist-RJGCUS3L.js");
+      const { installGitHooks } = await import("./dist-QAU3LGJN.js");
       const binaryPath = getBinaryPath();
       gitHooksResult = installGitHooks(projectDir, binaryPath);
     } catch {
@@ -3499,8 +3540,10 @@ async function historyBackfillHandler(ctx) {
   } catch {
   }
   const limit = Math.min(options.limit ?? 20, 100);
+  const branchOnly = options.branchOnly ?? false;
   const {
     listRecentCommits,
+    listBranchOnlyCommits,
     getCommitMetadata,
     getCommitDiffStats,
     getCommitRawDiff,
@@ -3510,8 +3553,8 @@ async function historyBackfillHandler(ctx) {
     entryExists,
     writeHistoryEntry,
     DEFAULT_HISTORY_CONFIG
-  } = await import("./dist-RJGCUS3L.js");
-  const commits = listRecentCommits(projectDir, limit);
+  } = await import("./dist-QAU3LGJN.js");
+  const commits = branchOnly ? listBranchOnlyCommits(projectDir, limit) : listRecentCommits(projectDir, limit);
   if (commits.length === 0) {
     jsonResponse(res, { captured: 0, skipped: 0, total: 0 }, 200, req);
     return;
@@ -3834,7 +3877,7 @@ async function historyEntryTagsHandler(ctx) {
     return;
   }
   try {
-    const { updateEntryTags } = await import("./dist-RJGCUS3L.js");
+    const { updateEntryTags } = await import("./dist-QAU3LGJN.js");
     await updateEntryTags(projectDir, sha, payload.tags);
     jsonResponse(res, { success: true, sha, tags: payload.tags }, 200, req);
   } catch (err) {
@@ -3850,7 +3893,7 @@ async function historyEntryTranscriptHandler(ctx) {
     jsonResponse(res, { error: "History branch not initialized" }, 400, req);
     return;
   }
-  const { readEntryTranscript } = await import("./dist-RJGCUS3L.js");
+  const { readEntryTranscript } = await import("./dist-QAU3LGJN.js");
   const transcript = readEntryTranscript(projectDir, sha);
   if (!transcript) {
     jsonResponse(res, { error: "No transcript for this entry" }, 404, req);

package/dist/{chunk-DBMUNBNB.js → chunk-5J6NLQUN.js}

@@ -4,10 +4,13 @@ import {
   historyBranchExists,
   withWorktree,
   writeAndStage
-} from "./chunk-NNUWU6CV.js";
+} from "./chunk-JGBXM5NC.js";
 import {
   CodemapConfigSchema
 } from "./chunk-74WVVWJ4.js";
+import {
+  extractTagsFromTree
+} from "./chunk-ZLYRPD7I.js";
 import {
   LOGS_DIR,
   codemapBranchDir,
@@ -527,6 +530,7 @@ function getLanguageId(filePath) {
 }
 var ParserCtor = null;
 var LanguageClass = null;
+var QueryCtor = null;
 var initialized = false;
 var languageCache = /* @__PURE__ */ new Map();
 var require2 = createRequire(import.meta.url);
@@ -535,6 +539,7 @@ async function initTreeSitter() {
   const mod = await import("web-tree-sitter");
   ParserCtor = mod.Parser;
   LanguageClass = mod.Language;
+  QueryCtor = mod.Query;
   const wasmPath = require2.resolve("web-tree-sitter/web-tree-sitter.wasm");
   const wasmDir = path4.dirname(wasmPath) + "/";
   await ParserCtor.init({
@@ -556,6 +561,12 @@ async function loadLanguage(langConfig) {
   languageCache.set(cacheKey, language);
   return language;
 }
+function createTreeSitterQuery(language, source) {
+  if (!QueryCtor) {
+    throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
+  }
+  return new QueryCtor(language, source);
+}
 async function parseSource(content, langConfig) {
   if (!ParserCtor) {
     throw new Error("Tree-sitter not initialized. Call initTreeSitter() first.");
@@ -1532,14 +1543,9 @@ async function runPipelineInner(projectDir, onProgress, branch) {
     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();
+  let tagExtractionFailures = 0;
   const chunks = [];
   const filePaths = scannedFiles.map((f) => f.filePath);
   for (let i = 0; i < filePaths.length; i++) {
@@ -1561,15 +1567,19 @@ async function runPipelineInner(projectDir, onProgress, branch) {
         const fallbackChunks = await chunkFile(filePath, content, config.chunking);
         chunks.push(...fallbackChunks);
       }
-      if (extractTagsFromTree && result.tree && result.language && langId && langConfig.hasTagQuery) {
+      if (result.tree && result.language && langId && langConfig.hasTagQuery) {
         try {
           const lang = result.language;
-          const createQuery = (source) => lang.query(source);
+          const createQuery = (source) => createTreeSitterQuery(lang, source);
           const tags = extractTagsFromTree(createQuery, result.tree.rootNode, filePath, langId);
           if (tags.length > 0) {
             allTags.set(filePath, tags);
           }
-        } catch {
+        } catch (tagErr) {
+          tagExtractionFailures++;
+          if (tagExtractionFailures <= 3) {
+            log("warn", `Tag extraction failed for ${filePath}: ${tagErr instanceof Error ? tagErr.message : String(tagErr)}`);
+          }
         }
       }
       if (result.tree) {
@@ -1594,6 +1604,13 @@ async function runPipelineInner(projectDir, onProgress, branch) {
     total: scannedFiles.length,
     message: `Created ${chunks.length} chunks`
   });
+  log("info", `Tag extraction: ${allTags.size} files tagged, ${tagExtractionFailures} failures out of ${scannedFiles.length} files`);
+  if (tagExtractionFailures > 3) {
+    log("warn", `Tag extraction failed for ${tagExtractionFailures} files (only first 3 logged above)`);
+  }
+  if (allTags.size === 0) {
+    log("warn", "No tags extracted \u2014 depgraph will be skipped. Check tree-sitter language support.");
+  }
   assignChunkIds(chunks, config.chunking.version);
   onProgress?.({
     phase: "finalizing",
@@ -1646,20 +1663,20 @@ async function runPipelineInner(projectDir, onProgress, branch) {
   let depgraphResult;
   if (allTags.size > 0) {
     try {
-      const depgraph = await import("./dist-R5ZJ4LX5.js");
+      const { buildReferenceGraph, computePageRank, savePageRank, computeMetrics, saveMetrics, saveGraph } = await import("./dist-YA2BWZB2.js");
       onProgress?.({
         phase: "graph",
         current: 0,
         total: 3,
         message: "Building dependency graph..."
       });
-      const graph = depgraph.buildReferenceGraph(allTags, filePaths);
+      const graph = 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);
+      saveGraph(graph, projectDir, resolvedBranch);
       onProgress?.({
         phase: "graph",
         current: 1,
@@ -1672,8 +1689,8 @@ async function runPipelineInner(projectDir, onProgress, branch) {
         total: 3,
         message: "Computing PageRank..."
       });
-      const pageRank = depgraph.computePageRank(graph);
-      depgraph.savePageRank(pageRank, projectDir, resolvedBranch);
+      const pageRank = computePageRank(graph);
+      savePageRank(pageRank, projectDir, resolvedBranch);
       onProgress?.({
         phase: "ranking",
         current: 2,
@@ -1686,8 +1703,8 @@ async function runPipelineInner(projectDir, onProgress, branch) {
         total: 3,
         message: "Computing metrics..."
       });
-      const metrics = depgraph.computeMetrics(graph, pageRank);
-      depgraph.saveMetrics(metrics, projectDir, resolvedBranch);
+      const metrics = computeMetrics(graph, pageRank);
+      saveMetrics(metrics, projectDir, resolvedBranch);
       onProgress?.({
         phase: "metrics",
         current: 3,
@@ -1741,6 +1758,98 @@ async function runPipelineInner(projectDir, onProgress, branch) {
     depgraph: depgraphResult
   };
 }
+async function rebuildDepgraph(projectDir, onProgress, branch) {
+  const resolvedBranch = branch ?? getCurrentBranch(projectDir);
+  acquireCodemapLock(projectDir, resolvedBranch);
+  try {
+    return await rebuildDepgraphInner(projectDir, onProgress, resolvedBranch);
+  } finally {
+    releaseCodemapLock(projectDir, resolvedBranch);
+  }
+}
+async function rebuildDepgraphInner(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);
+  const filePaths = scannedFiles.map((f) => f.filePath);
+  onProgress?.({ phase: "scanning", current: scannedFiles.length, total: scannedFiles.length, message: `Found ${scannedFiles.length} files` });
+  if (scannedFiles.length === 0) {
+    return { nodeCount: 0, edgeCount: 0, definitionCount: 0, referenceCount: 0, cycleCount: 0, durationMs: Date.now() - startTime, taggedFiles: 0, totalFiles: 0 };
+  }
+  await initTreeSitter();
+  const allTags = /* @__PURE__ */ new Map();
+  let tagFailures = 0;
+  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 && langConfig.hasTagQuery && langId) {
+      const result = await parseAndChunkFile(filePath, content, config.chunking);
+      if (result.tree && result.language) {
+        try {
+          const lang = result.language;
+          const createQuery = (source) => createTreeSitterQuery(lang, source);
+          const tags = extractTagsFromTree(createQuery, result.tree.rootNode, filePath, langId);
+          if (tags.length > 0) {
+            allTags.set(filePath, tags);
+          }
+        } catch {
+          tagFailures++;
+        }
+      }
+      if (result.tree) result.tree.delete();
+    }
+    if ((i + 1) % 100 === 0 || i === filePaths.length - 1) {
+      onProgress?.({ phase: "chunking", current: i + 1, total: scannedFiles.length, message: `Parsed ${i + 1}/${scannedFiles.length} files (${allTags.size} tagged)` });
+    }
+  }
+  log("info", `DepGraph rebuild: ${allTags.size} files tagged, ${tagFailures} failures out of ${scannedFiles.length} files`);
+  if (allTags.size === 0) {
+    log("warn", "No tags extracted \u2014 cannot build depgraph");
+    return { nodeCount: 0, edgeCount: 0, definitionCount: 0, referenceCount: 0, cycleCount: 0, durationMs: Date.now() - startTime, taggedFiles: 0, totalFiles: scannedFiles.length };
+  }
+  const { buildReferenceGraph, computePageRank, savePageRank, computeMetrics, saveMetrics, saveGraph } = await import("./dist-YA2BWZB2.js");
+  onProgress?.({ phase: "graph", current: 0, total: 3, message: "Building dependency graph..." });
+  const graph = buildReferenceGraph(allTags, filePaths);
+  for (const sf of scannedFiles) {
+    if (graph.nodes[sf.filePath]) {
+      graph.nodes[sf.filePath].sizeBytes = sf.sizeBytes;
+    }
+  }
+  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 = computePageRank(graph);
+  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 = computeMetrics(graph, pageRank);
+  saveMetrics(metrics, projectDir, resolvedBranch);
+  onProgress?.({ phase: "metrics", current: 3, total: 3, message: `Metrics: ${metrics.cycles.length} cycles, ${metrics.totalDefinitions} defs, ${metrics.totalReferences} refs` });
+  const durationMs = Date.now() - startTime;
+  log("info", `DepGraph rebuild: ${metrics.totalFiles} nodes, ${metrics.totalEdges} edges, ${metrics.totalDefinitions} defs, ${metrics.totalReferences} refs, ${metrics.cycles.length} cycles in ${(durationMs / 1e3).toFixed(1)}s`);
+  return {
+    nodeCount: metrics.totalFiles,
+    edgeCount: metrics.totalEdges,
+    definitionCount: metrics.totalDefinitions,
+    referenceCount: metrics.totalReferences,
+    cycleCount: metrics.cycles.length,
+    durationMs,
+    taggedFiles: allTags.size,
+    totalFiles: scannedFiles.length
+  };
+}
 var STORE_BATCH_SIZE = 5e3;
 async function embedAndStore(embedder, texts, chunks, store, batchConfig, onProgress) {
   if (texts.length === 0) return;
@@ -1981,7 +2090,7 @@ async function searchCode(projectDir, query, options = {}) {
     let graphRanks;
     if (weights.graphRank && weights.graphRank > 0) {
       try {
-        const { loadPageRankMap } = await import("./dist-R5ZJ4LX5.js");
+        const { loadPageRankMap } = await import("./dist-YA2BWZB2.js");
         graphRanks = loadPageRankMap(projectDir, resolvedBranch) ?? void 0;
       } catch {
       }
@@ -2511,7 +2620,7 @@ 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"], {
+  const emptyBlob = execFileSync2("git", ["hash-object", "-w", "-t", "blob", "--stdin"], {
     cwd: projectDir,
     input: "",
     encoding: "utf-8",
@@ -2591,6 +2700,26 @@ async function exportIndex(projectDir, branch) {
     };
     writeAndStage(worktreeDir, "export-meta.json", JSON.stringify(exportMeta, null, 2) + "\n");
     filesExported++;
+    const readme = [
+      "# ULPI CodeMap Index",
+      "",
+      "This branch stores the semantic code search index for this repository.",
+      "It is maintained automatically by [ULPI](https://github.com/ulpi-io/ulpi).",
+      "",
+      "## Contents",
+      "",
+      "- `schema.json` \u2014 Index schema (embedding provider, model, dimensions)",
+      "- `manifest.json` \u2014 File/chunk manifest for incremental updates",
+      "- `config.json` \u2014 CodeMap configuration",
+      "- `stats.json` \u2014 Index statistics",
+      "- `index/lance/` \u2014 LanceDB vector index",
+      "- `index/metadata/` \u2014 BM25 text index + symbol index",
+      "- `export-meta.json` \u2014 Export metadata",
+      "",
+      `_Exported: ${exportMeta.exportedAt}_`
+    ].join("\n") + "\n";
+    writeAndStage(worktreeDir, "README.md", readme);
+    filesExported++;
     return commitInWorktree(worktreeDir, `codemap: export index (${filesExported} files)`);
   });
   const commitMessage = `codemap: export index (${filesExported} files)`;
@@ -3027,6 +3156,7 @@ export {
   isCodemapLocked,
   buildEmbeddingTexts,
   runInitPipeline,
+  rebuildDepgraph,
   DEFAULT_HYBRID_WEIGHTS,
   normalizeScores,
   computePathBoost,

package/dist/{chunk-4KRVDKGB.js → chunk-F7OXF7Z3.js}

@@ -13,7 +13,7 @@ var REGISTRY_URL = CLI_REGISTRY_URL;
 var FETCH_TIMEOUT_MS = 5e3;
 function getCurrentVersion() {
   try {
-    return "0.1.1";
+    return "0.1.3";
   } catch {
     return "0.0.0";
   }