@ulpi/cli 0.1.0

package/dist/codemap-RRJIDBQ5.js

@@ -0,0 +1,636 @@
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/codemap.ts
+import chalk from "chalk";
+async function runCodemap(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "init":
+      return await initSubcommand(projectDir);
+    case "search":
+      return await searchSubcommand(args.slice(1), projectDir);
+    case "status":
+      return await statusSubcommand(projectDir);
+    case "reindex":
+      return await reindexSubcommand(projectDir);
+    case "config":
+      return await configSubcommand(args.slice(1), projectDir);
+    case "watch":
+      return await watchSubcommand(projectDir);
+    case "export":
+      return await exportSubcommand(projectDir);
+    case "import":
+      return await importSubcommand(projectDir);
+    case "serve":
+      return await serveSubcommand(projectDir);
+    case "eval":
+      return await evalSubcommand(args.slice(1), projectDir);
+    case "migrate-index":
+      return await migrateIndexSubcommand(projectDir);
+    case "deps":
+      return await depsSubcommand(args.slice(1), projectDir);
+    case "rdeps":
+    case "dependents":
+      return await dependentsSubcommand(args.slice(1), projectDir);
+    case "rank":
+      return await rankSubcommand(args.slice(1), projectDir);
+    case "cycles":
+      return await cyclesSubcommand(projectDir);
+    case "coupling":
+      return await couplingSubcommand(args.slice(1), projectDir);
+    default:
+      console.log(`
+Usage: ulpi codemap <subcommand>
+
+Subcommands:
+  init                    Index the current project
+  search <query>          Search code by intent
+  status                  Show index status and stats
+  reindex                 Force full re-index
+  watch                   Start file watcher for incremental updates
+  export                  Export index to shadow branch
+  import                  Import index from shadow branch
+  serve                   Start MCP server
+  config [key] [value]    View or update CodeMap configuration
+  eval                    Run quality evaluation harness
+  migrate-index           Migrate index to new format
+  deps <file>             Show files this file depends on
+  dependents <file>       Show files that depend on this file (alias: rdeps)
+  rank [--limit N]        Show top-ranked files by PageRank
+  cycles                  Detect circular dependencies
+  coupling [path]         Show coupling metrics for files
+`.trim());
+  }
+}
+async function initSubcommand(projectDir) {
+  console.log(chalk.bold("\nCodeMap \u2014 Index Project\n"));
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { runInitPipeline, loadCodemapConfig } = await import("./dist-LZKZFPVX.js");
+  const config = loadCodemapConfig(projectDir);
+  if (config.embedding.provider === "openai") {
+    const { resolveApiKey } = await import("./dist-RKOGLK7R.js");
+    if (!resolveApiKey("openai")) {
+      console.error(chalk.red("Error: OpenAI API key not found.\n"));
+      console.error(chalk.dim("  Set it:    ulpi config set openai-key <your-key>"));
+      console.error(chalk.dim("  Or switch: ulpi codemap config embedding.provider ulpi"));
+      process.exit(1);
+    }
+  } else if (config.embedding.provider === "ulpi") {
+    const { resolveApiKey } = await import("./dist-RKOGLK7R.js");
+    if (!resolveApiKey("ulpi")) {
+      console.error(chalk.red("Error: ULPI API key not found.\n"));
+      console.error(chalk.dim("  Set it: ulpi config set ulpi-key <your-key>"));
+      process.exit(1);
+    }
+  }
+  try {
+    const result = await runInitPipeline(projectDir, (progress) => {
+      const pct = progress.total > 0 ? ` (${Math.round(progress.current / progress.total * 100)}%)` : "";
+      process.stdout.write(`\r  ${chalk.dim(progress.phase)}${pct} ${progress.message}    `);
+    }, branch);
+    process.stdout.write("\r" + " ".repeat(80) + "\r");
+    console.log(chalk.green("\u2713 Indexing complete"));
+    console.log(chalk.dim(`  Files:     ${result.totalFiles}`));
+    console.log(chalk.dim(`  Chunks:    ${result.totalChunks}`));
+    console.log(chalk.dim(`  Provider:  ${result.embeddingProvider} (${result.embeddingModel})`));
+    console.log(chalk.dim(`  Duration:  ${(result.durationMs / 1e3).toFixed(1)}s`));
+    console.log(chalk.dim(`  Branch:    ${branch}`));
+    const { installMcpServer } = await import("./mcp-installer-NQCGKQ23.js");
+    const mcp = installMcpServer(projectDir);
+    if (mcp.installed) {
+      console.log(chalk.green("\u2713 MCP server registered"));
+      console.log(chalk.dim("  Claude Code will auto-start the codemap MCP server"));
+    } else {
+      console.log(chalk.dim(`  MCP: ${mcp.message}`));
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`
+Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function searchSubcommand(args, projectDir) {
+  const query = args.filter((a) => !a.startsWith("--")).join(" ");
+  if (!query) {
+    console.log(chalk.red("Usage: ulpi codemap search <query>"));
+    console.log(chalk.dim('  Example: ulpi codemap search "review decision handling"'));
+    return;
+  }
+  const limitFlag = args.find((a) => a.startsWith("--limit"));
+  let limit = 10;
+  if (limitFlag) {
+    const val = limitFlag.includes("=") ? limitFlag.split("=")[1] : args[args.indexOf(limitFlag) + 1];
+    if (val) limit = parseInt(val, 10) || 10;
+  }
+  const noTests = args.includes("--no-tests");
+  const noDocs = args.includes("--no-docs");
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { searchCode, getCodemapStatus } = await import("./dist-LZKZFPVX.js");
+  const status = getCodemapStatus(projectDir, branch);
+  if (!status.initialized) {
+    console.log(chalk.red("Error: CodeMap index not initialized."));
+    console.log(chalk.dim("Run 'ulpi codemap init' first."));
+    return;
+  }
+  try {
+    const result = await searchCode(projectDir, query, {
+      limit,
+      includeTests: !noTests,
+      includeDocs: !noDocs,
+      branch
+    });
+    if (result.results.length === 0) {
+      console.log(chalk.yellow("No results found."));
+      console.log(chalk.dim(`  Query:    "${query}"`));
+      console.log(chalk.dim(`  Duration: ${result.durationMs}ms`));
+      return;
+    }
+    console.log(chalk.bold(`
+CodeMap Search \u2014 "${query}"
+`));
+    console.log(chalk.dim(`  ${result.results.length} results in ${result.durationMs}ms
+`));
+    for (let i = 0; i < result.results.length; i++) {
+      const r = result.results[i];
+      const score = (r.score * 100).toFixed(1);
+      console.log(
+        chalk.cyan(`  ${i + 1}. `) + chalk.white(r.filePath) + chalk.dim(`:${r.startLine}-${r.endLine}`) + chalk.dim(` (${score}%)`)
+      );
+      const firstLine = r.snippet.split("\n")[0]?.trim();
+      if (firstLine) {
+        console.log(chalk.dim(`     ${truncate(firstLine, 80)}`));
+      }
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function statusSubcommand(projectDir) {
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { getCodemapStatus } = await import("./dist-LZKZFPVX.js");
+  const status = getCodemapStatus(projectDir, branch);
+  console.log(chalk.bold("\nCodeMap Status\n"));
+  if (!status.initialized) {
+    console.log(chalk.yellow("  Not initialized"));
+    console.log(chalk.dim("  Run 'ulpi codemap init' to index this project.\n"));
+    console.log(chalk.dim(`  Provider:   ${status.embeddingProvider} (${status.embeddingModel})`));
+    console.log(chalk.dim(`  Dimensions: ${status.dimensions}`));
+    console.log("");
+    return;
+  }
+  const modeColor = status.mode === "watching" ? chalk.green : status.mode === "error" ? chalk.red : chalk.dim;
+  console.log(`  ${chalk.dim("Mode:")}         ${modeColor(status.mode)}`);
+  console.log(`  ${chalk.dim("Branch:")}       ${status.branch ?? "unknown"}`);
+  console.log(`  ${chalk.dim("Provider:")}     ${status.embeddingProvider} (${status.embeddingModel})`);
+  console.log(`  ${chalk.dim("Dimensions:")}   ${status.dimensions}`);
+  console.log(`  ${chalk.dim("Files:")}        ${status.totalFiles}`);
+  console.log(`  ${chalk.dim("Chunks:")}       ${status.totalChunks}`);
+  if (status.staleFiles > 0) {
+    console.log(`  ${chalk.dim("Stale files:")} ${chalk.yellow(String(status.staleFiles))}`);
+  }
+  console.log(`  ${chalk.dim("Index size:")}   ${formatBytes(status.indexSizeBytes)}`);
+  if (status.lastUpdated) {
+    console.log(`  ${chalk.dim("Last updated:")} ${status.lastUpdated}`);
+  }
+  console.log("");
+}
+async function reindexSubcommand(projectDir) {
+  console.log(chalk.bold("\nCodeMap \u2014 Re-index Project\n"));
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { getCodemapStatus } = await import("./dist-LZKZFPVX.js");
+  const status = getCodemapStatus(projectDir, branch);
+  if (!status.initialized) {
+    console.log(chalk.yellow("Index not initialized. Running init instead..."));
+  }
+  return initSubcommand(projectDir);
+}
+async function configSubcommand(args, projectDir) {
+  const { loadCodemapConfig, saveCodemapConfig } = await import("./dist-LZKZFPVX.js");
+  const config = loadCodemapConfig(projectDir);
+  if (args.length === 0) {
+    console.log(chalk.bold("\nCodeMap Configuration\n"));
+    console.log(JSON.stringify(config, null, 2));
+    console.log("");
+    return;
+  }
+  const key = args[0];
+  const value = args[1];
+  if (!value) {
+    const val = getNestedValue(config, key);
+    if (val === void 0) {
+      console.log(chalk.red(`Unknown config key: ${key}`));
+      return;
+    }
+    console.log(String(val));
+    return;
+  }
+  try {
+    const { CodemapConfigSchema } = await import("./dist-6G7JC2RA.js");
+    const updated = setNestedValue(config, key, value);
+    const validated = CodemapConfigSchema.parse(updated);
+    saveCodemapConfig(projectDir, validated);
+    console.log(chalk.green(`\u2713 Set ${key} = ${value}`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(chalk.red(`Error: ${message}`));
+  }
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1);
+  const val = bytes / Math.pow(1024, i);
+  return `${val.toFixed(i === 0 ? 0 : 1)} ${units[i]}`;
+}
+function getNestedValue(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function setNestedValue(obj, path, value) {
+  const clone = JSON.parse(JSON.stringify(obj));
+  const parts = path.split(".");
+  let current = clone;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const part = parts[i];
+    if (typeof current[part] !== "object" || current[part] === null) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastKey = parts[parts.length - 1];
+  if (value === "true") current[lastKey] = true;
+  else if (value === "false") current[lastKey] = false;
+  else if (/^\d+$/.test(value)) current[lastKey] = parseInt(value, 10);
+  else if (/^\d+\.\d+$/.test(value)) current[lastKey] = parseFloat(value);
+  else current[lastKey] = value;
+  return clone;
+}
+async function watchSubcommand(projectDir) {
+  console.log(chalk.bold("\nCodeMap \u2014 Watch Mode\n"));
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { getCodemapStatus, CodemapWatcher } = await import("./dist-LZKZFPVX.js");
+  const status = getCodemapStatus(projectDir, branch);
+  if (!status.initialized) {
+    console.log(chalk.yellow("Index not initialized. Running init first..."));
+    await initSubcommand(projectDir);
+    console.log("");
+  }
+  const watcher = new CodemapWatcher({ projectDir, branch });
+  console.log(chalk.green("\u2713 Watcher started"));
+  console.log(chalk.dim("  Watching for file changes..."));
+  console.log(chalk.dim("  Press Ctrl+C to stop.\n"));
+  await watcher.start();
+  await new Promise((resolve) => {
+    const shutdown = async () => {
+      console.log(chalk.dim("\n  Stopping watcher..."));
+      await watcher.stop();
+      console.log(chalk.green("\u2713 Watcher stopped"));
+      resolve();
+    };
+    process.on("SIGINT", () => {
+      shutdown().catch(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+      shutdown().catch(() => process.exit(0));
+    });
+  });
+}
+async function exportSubcommand(projectDir) {
+  console.log(chalk.bold("\nCodeMap \u2014 Export Index\n"));
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { exportIndex } = await import("./dist-LZKZFPVX.js");
+  try {
+    const result = await exportIndex(projectDir, branch);
+    console.log(chalk.green("\u2713 Export complete"));
+    console.log(chalk.dim(`  Branch:  ${result.branchName}`));
+    console.log(chalk.dim(`  Commit:  ${result.commitSha.slice(0, 8)}`));
+    console.log(chalk.dim(`  Files:   ${result.filesExported}`));
+    console.log(chalk.dim(`  Size:    ${formatBytes(result.totalSizeBytes)}`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function importSubcommand(projectDir) {
+  console.log(chalk.bold("\nCodeMap \u2014 Import Index\n"));
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { importIndex } = await import("./dist-LZKZFPVX.js");
+  try {
+    const result = await importIndex(projectDir, branch);
+    if (!result.success) {
+      console.log(chalk.yellow(`Import skipped: ${result.message}`));
+      return;
+    }
+    console.log(chalk.green("\u2713 Import complete"));
+    console.log(chalk.dim(`  Files:   ${result.filesImported}`));
+    console.log(chalk.dim(`  Size:    ${formatBytes(result.totalSizeBytes)}`));
+    if (result.rebuildRecommended) {
+      console.log(chalk.yellow("\n  Warning: Embedding provider/model mismatch detected."));
+      console.log(chalk.yellow("    Run 'ulpi codemap reindex' to rebuild with current settings."));
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function serveSubcommand(projectDir) {
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { getCodemapStatus } = await import("./dist-LZKZFPVX.js");
+  const status = getCodemapStatus(projectDir, branch);
+  if (!status.initialized) {
+    console.error(chalk.red("Error: CodeMap index not initialized. Run 'ulpi codemap init' first."));
+    process.exit(1);
+  }
+  console.error(chalk.dim("[codemap-mcp] Starting MCP server..."));
+  console.error(chalk.dim(`[codemap-mcp] Project: ${projectDir}`));
+  console.error(chalk.dim(`[codemap-mcp] Index: ${status.totalFiles} files, ${status.totalChunks} chunks`));
+  const { startMcpServer } = await import("./dist-W7K4WPAF.js");
+  await startMcpServer({ projectDir, branch });
+}
+async function evalSubcommand(args, projectDir) {
+  const { runEvalHarness } = await import("./dist-LZKZFPVX.js");
+  const path = await import("path");
+  const datasetIdx = args.indexOf("--dataset");
+  let datasetPath;
+  if (datasetIdx !== -1 && args[datasetIdx + 1]) {
+    datasetPath = path.resolve(args[datasetIdx + 1]);
+  } else {
+    const { projectCodemapDir } = await import("./dist-RKOGLK7R.js");
+    datasetPath = path.join(projectCodemapDir(projectDir), "eval", "queries.json");
+  }
+  const jsonOutput = args.includes("--json");
+  console.log(chalk.bold("\nCodeMap \u2014 Eval Harness\n"));
+  console.log(chalk.dim(`  Dataset: ${datasetPath}`));
+  try {
+    const report = await runEvalHarness(projectDir, datasetPath);
+    if (jsonOutput) {
+      console.log(JSON.stringify(report, null, 2));
+      return;
+    }
+    console.log(chalk.bold("\n  Aggregate Metrics:"));
+    console.log(`    Recall@5:  ${(report.aggregate.recallAt5 * 100).toFixed(1)}%`);
+    console.log(`    MRR@10:    ${(report.aggregate.mrrAt10 * 100).toFixed(1)}%`);
+    console.log(`    nDCG@10:   ${(report.aggregate.ndcgAt10 * 100).toFixed(1)}%`);
+    console.log(chalk.dim(`
+    Queries: ${report.queriesCount}`));
+    console.log(chalk.dim(`    Total:   ${(report.timing.totalMs / 1e3).toFixed(1)}s`));
+    console.log(chalk.dim(`    Avg:     ${report.timing.avgPerQueryMs.toFixed(0)}ms/query`));
+    if (report.aggregate.recallAt5 < 0.8) {
+      console.log(chalk.yellow(`
+  Warning: Recall@5 (${(report.aggregate.recallAt5 * 100).toFixed(1)}%) below target (80%)`));
+    }
+    if (report.aggregate.mrrAt10 < 0.65) {
+      console.log(chalk.yellow(`  Warning: MRR@10 (${(report.aggregate.mrrAt10 * 100).toFixed(1)}%) below target (65%)`));
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function migrateIndexSubcommand(projectDir) {
+  console.log(chalk.bold("\nCodeMap \u2014 Migrate Legacy Index\n"));
+  const { migrateFromLegacy } = await import("./dist-LZKZFPVX.js");
+  try {
+    const result = await migrateFromLegacy(projectDir);
+    if (!result.migrated) {
+      console.log(chalk.yellow(`  ${result.message}`));
+    } else {
+      console.log(chalk.green("\u2713 Migration complete"));
+      console.log(chalk.dim(`  Files:   ${result.filesCount}`));
+      console.log(chalk.dim(`  Size:    ${formatBytes(result.totalSizeBytes)}`));
+    }
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function depsSubcommand(args, projectDir) {
+  const filePath = args.filter((a) => !a.startsWith("-"))[0];
+  if (!filePath) {
+    console.log(chalk.red("Usage: ulpi codemap deps <file> [--transitive|-t] [--depth N]"));
+    return;
+  }
+  const transitive = args.includes("--transitive") || args.includes("-t");
+  const depthIdx = args.indexOf("--depth");
+  const maxDepth = depthIdx >= 0 ? parseInt(args[depthIdx + 1], 10) || 5 : 5;
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { loadGraph, getOutgoingEdges, getTransitiveDeps } = await import("./dist-R5ZJ4LX5.js");
+  const graph = loadGraph(projectDir, branch);
+  if (!graph) {
+    console.log(chalk.yellow("No dependency graph found. Run 'ulpi codemap init' first."));
+    return;
+  }
+  if (transitive) {
+    const deps = getTransitiveDeps(graph, filePath, maxDepth);
+    console.log(chalk.bold(`
+Transitive dependencies of ${filePath} (depth ${maxDepth}):
+`));
+    if (deps.length === 0) {
+      console.log(chalk.dim("  No dependencies found."));
+    } else {
+      for (const dep of deps) {
+        console.log(chalk.dim("  - ") + dep);
+      }
+      console.log(chalk.dim(`
+  ${deps.length} files total`));
+    }
+  } else {
+    const edges = getOutgoingEdges(graph, filePath);
+    console.log(chalk.bold(`
+Direct dependencies of ${filePath}:
+`));
+    if (edges.length === 0) {
+      console.log(chalk.dim("  No dependencies found."));
+    } else {
+      for (const edge of edges) {
+        const count = edge.symbols.length;
+        const countColor = count >= 5 ? chalk.green : count >= 2 ? chalk.yellow : chalk.dim;
+        const symbols = edge.symbols.slice(0, 5).join(", ");
+        const more = count > 5 ? ` (+${count - 5} more)` : "";
+        console.log(chalk.dim("  - ") + edge.target + "  " + countColor(`[${count}]`) + chalk.dim(` ${symbols}${more}`));
+      }
+      console.log(chalk.dim(`
+  ${edges.length} direct dependencies`));
+    }
+  }
+}
+async function dependentsSubcommand(args, projectDir) {
+  const filePath = args.filter((a) => !a.startsWith("-"))[0];
+  if (!filePath) {
+    console.log(chalk.red("Usage: ulpi codemap dependents <file> [--transitive|-t] [--depth N]"));
+    return;
+  }
+  const transitive = args.includes("--transitive") || args.includes("-t");
+  const depthIdx = args.indexOf("--depth");
+  const maxDepth = depthIdx >= 0 ? parseInt(args[depthIdx + 1], 10) || 5 : 5;
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { loadGraph, getIncomingEdges, getTransitiveRdeps } = await import("./dist-R5ZJ4LX5.js");
+  const graph = loadGraph(projectDir, branch);
+  if (!graph) {
+    console.log(chalk.yellow("No dependency graph found. Run 'ulpi codemap init' first."));
+    return;
+  }
+  if (transitive) {
+    const rdeps = getTransitiveRdeps(graph, filePath, maxDepth);
+    console.log(chalk.bold(`
+Transitive dependents of ${filePath} (depth ${maxDepth}):
+`));
+    if (rdeps.length === 0) {
+      console.log(chalk.dim("  No dependents found."));
+    } else {
+      for (const dep of rdeps) {
+        console.log(chalk.dim("  - ") + dep);
+      }
+      console.log(chalk.dim(`
+  ${rdeps.length} files total`));
+    }
+  } else {
+    const edges = getIncomingEdges(graph, filePath);
+    console.log(chalk.bold(`
+Direct dependents of ${filePath}:
+`));
+    if (edges.length === 0) {
+      console.log(chalk.dim("  No dependents found."));
+    } else {
+      for (const edge of edges) {
+        const count = edge.symbols.length;
+        const countColor = count >= 5 ? chalk.green : count >= 2 ? chalk.yellow : chalk.dim;
+        const symbols = edge.symbols.slice(0, 5).join(", ");
+        const more = count > 5 ? ` (+${count - 5} more)` : "";
+        console.log(chalk.dim("  - ") + edge.source + "  " + countColor(`[${count}]`) + chalk.dim(` ${symbols}${more}`));
+      }
+      console.log(chalk.dim(`
+  ${edges.length} direct dependents`));
+    }
+  }
+}
+async function rankSubcommand(args, projectDir) {
+  const limitIdx = args.indexOf("--limit");
+  const limit = limitIdx >= 0 ? parseInt(args[limitIdx + 1], 10) || 20 : 20;
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { loadPageRank, loadGraph } = await import("./dist-R5ZJ4LX5.js");
+  const result = loadPageRank(projectDir, branch);
+  if (!result) {
+    console.log(chalk.yellow("No PageRank data found. Run 'ulpi codemap init' first."));
+    return;
+  }
+  const graph = loadGraph(projectDir, branch);
+  const sorted = Object.entries(result.ranks).sort((a, b) => b[1] - a[1]).slice(0, limit);
+  const topRank = sorted[0]?.[1] ?? 0;
+  console.log(chalk.bold(`
+Top ${sorted.length} files by PageRank
+`));
+  console.log(chalk.dim(`  d=${result.dampingFactor}, ${result.converged ? "converged" : "not converged"} in ${result.iterations} iterations
+`));
+  console.log(chalk.dim("   #   Score    Defs  Refs  File"));
+  console.log(chalk.dim("  " + "\u2014".repeat(70)));
+  for (let i = 0; i < sorted.length; i++) {
+    const [file, rank] = sorted[i];
+    const rankStr = (rank * 1e3).toFixed(3).padStart(7);
+    const node = graph?.nodes[file];
+    const defs = String(node?.definitionCount ?? 0).padStart(4);
+    const refs = String(node?.referenceCount ?? 0).padStart(5);
+    const ratio = topRank > 0 ? rank / topRank : 0;
+    const rankColor = ratio > 0.5 ? chalk.green : ratio > 0.2 ? chalk.yellow : chalk.dim;
+    console.log(`  ${chalk.dim((i + 1).toString().padStart(3) + ".")} ${rankColor(rankStr)}  ${chalk.dim(defs)}  ${chalk.dim(refs)}  ${file}`);
+  }
+  console.log(chalk.dim(`
+  ${Object.keys(result.ranks).length} total files`));
+}
+async function cyclesSubcommand(projectDir) {
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { loadMetrics, loadGraph, detectCycles } = await import("./dist-R5ZJ4LX5.js");
+  let cycles;
+  const metrics = loadMetrics(projectDir, branch);
+  if (metrics) {
+    cycles = metrics.cycles;
+  } else {
+    const graph = loadGraph(projectDir, branch);
+    if (!graph) {
+      console.log(chalk.yellow("No dependency graph found. Run 'ulpi codemap init' first."));
+      return;
+    }
+    cycles = detectCycles(graph);
+  }
+  if (cycles.length === 0) {
+    console.log(chalk.green("\nNo circular dependencies detected.\n"));
+    return;
+  }
+  console.log(chalk.bold(`
+Circular Dependencies
+`));
+  for (let i = 0; i < cycles.length; i++) {
+    const cycle = cycles[i];
+    const color = cycle.files.length <= 2 ? chalk.red : chalk.yellow;
+    const chain = cycle.files.join(chalk.dim(" -> "));
+    console.log(`  ${color(`${i + 1}.`)} ${chain} ${chalk.dim("->")} ${color(cycle.files[0])}`);
+  }
+  console.log(chalk.dim(`
+Found ${cycles.length} circular dependency cycle${cycles.length === 1 ? "" : "s"}`));
+}
+async function couplingSubcommand(args, projectDir) {
+  const modulePath = args.filter((a) => !a.startsWith("--"))[0] || "";
+  const { getCurrentBranch } = await import("./dist-RKOGLK7R.js");
+  const branch = getCurrentBranch(projectDir);
+  const { loadGraph, computeCoupling } = await import("./dist-R5ZJ4LX5.js");
+  const graph = loadGraph(projectDir, branch);
+  if (!graph) {
+    console.log(chalk.yellow("No dependency graph found. Run 'ulpi codemap init' first."));
+    return;
+  }
+  const allCoupling = computeCoupling(graph);
+  const filtered = modulePath ? allCoupling.filter((c) => c.filePath.startsWith(modulePath)) : allCoupling;
+  const sorted = filtered.sort((a, b) => b.instability - a.instability);
+  console.log(chalk.bold(`
+Coupling Metrics${modulePath ? ` for ${modulePath}` : ""}:
+`));
+  console.log(chalk.dim("  File                                           Ca    Ce    Instability"));
+  console.log(chalk.dim("  " + "\u2014".repeat(70)));
+  for (const m of sorted.slice(0, 30)) {
+    const instColor = m.instability > 0.8 ? chalk.red : m.instability > 0.5 ? chalk.yellow : chalk.green;
+    const name = m.filePath.length > 45 ? "..." + m.filePath.slice(-42) : m.filePath.padEnd(45);
+    console.log(`  ${name} ${String(m.afferentCoupling).padStart(4)}  ${String(m.efferentCoupling).padStart(4)}  ${instColor(m.instability.toFixed(3))}`);
+  }
+  if (sorted.length > 30) {
+    console.log(chalk.dim(`
+  ... and ${sorted.length - 30} more files`));
+  }
+  console.log(chalk.dim(`
+  ${sorted.length} files analyzed`));
+}
+export {
+  runCodemap
+};