@dreamtree-org/graphify 1.0.0 → 1.1.1

package/dist/cli/index.js

@@ -1,28 +1,187 @@
 #!/usr/bin/env node
 import {
   analyze,
+  checkRules,
   cluster,
   exportGraph,
+  loadResults,
+  mergeGraphs,
+  renderLessons,
   renderReport,
-  runPipeline
-} from "../chunk-DG5FECXV.js";
+  renderReview,
+  reviewRevisions,
+  runPipeline,
+  saveResult,
+  validateRules
+} from "../chunk-EW23BLJC.js";
 import {
+  affectedBy,
+  buildContextPack,
   explainNode,
   loadGraph,
   queryGraph,
+  renderContextPack,
   shortestPath,
+  testsForChangedFiles,
+  testsForNode
+} from "../chunk-YT7B6DOD.js";
+import {
+  validateDsn,
   validateUrl
-} from "../chunk-5ANIDX3G.js";
+} from "../chunk-6JLEILYF.js";
 
 // src/cli/index.ts
-import { execFile } from "child_process";
-import * as fs2 from "fs/promises";
-import * as os from "os";
-import * as path2 from "path";
-import { promisify } from "util";
+import { execFile as execFile2 } from "child_process";
+import * as fs7 from "fs/promises";
+import * as os2 from "os";
+import * as path5 from "path";
+import { promisify as promisify2 } from "util";
 import { watch as watchFiles } from "chokidar";
 import { Command } from "commander";
 
+// src/cli/commands/affected.ts
+async function runAffected(nodeName, options = {}) {
+  const graph = await loadGraph();
+  const result = affectedBy(graph, nodeName, { maxDepth: options.depth, limit: options.limit });
+  if (!result) {
+    console.log(`No node matched "${nodeName}".`);
+    return;
+  }
+  console.log(`Impact of changing ${result.target.label} (${result.target.id}):`);
+  if (result.affected.length === 0) {
+    console.log("  Nothing in the graph depends on it \u2014 no incoming dependency edges.");
+    return;
+  }
+  let currentDepth = 0;
+  for (const node of result.affected) {
+    if (node.depth !== currentDepth) {
+      currentDepth = node.depth;
+      console.log("");
+      console.log(currentDepth === 1 ? "Directly affected:" : `Affected at depth ${currentDepth}:`);
+    }
+    const location = node.sourceLocation ? `:${node.sourceLocation}` : "";
+    console.log(
+      `  ${node.label} \u2014 ${node.sourceFile}${location} (--${node.via.relation}--> ${node.via.dependsOn}, ${node.via.confidence})`
+    );
+  }
+  console.log("");
+  const { EXTRACTED, INFERRED, AMBIGUOUS } = result.byConfidence;
+  console.log(
+    `Blast radius: ${result.affected.length} node(s) within ${result.maxDepth} hop(s) \u2014 ${EXTRACTED} certain (EXTRACTED), ${INFERRED} likely (INFERRED), ${AMBIGUOUS} uncertain (AMBIGUOUS).`
+  );
+  if (result.truncated) {
+    console.log("(List truncated \u2014 raise --limit to see more.)");
+  }
+}
+
+// src/cli/commands/benchmark.ts
+import * as fs from "fs/promises";
+var tokensOf = (text) => Math.ceil(text.length / 4);
+async function benchmarkQuestion(graph, question, readFile7) {
+  const result = queryGraph(graph, question);
+  const graphTokens = tokensOf(JSON.stringify(result));
+  const sourceFiles = /* @__PURE__ */ new Set();
+  for (const node of result.visited) {
+    if (node.sourceFile && !node.sourceFile.startsWith("<") && !node.sourceFile.includes("://")) {
+      sourceFiles.add(node.sourceFile);
+    }
+  }
+  let naiveTokens = 0;
+  let filesRead = 0;
+  let filesMissing = 0;
+  for (const file of [...sourceFiles].sort((a, b) => a.localeCompare(b))) {
+    try {
+      naiveTokens += tokensOf(await readFile7(file));
+      filesRead++;
+    } catch {
+      filesMissing++;
+    }
+  }
+  return {
+    question,
+    graphTokens,
+    naiveTokens,
+    reduction: graphTokens > 0 && naiveTokens > 0 ? naiveTokens / graphTokens : 0,
+    filesRead,
+    filesMissing
+  };
+}
+function defaultQuestions(graph, count = 5) {
+  const entries = [...graph.nodes()].map((id) => ({
+    id,
+    degree: graph.degree(id),
+    label: graph.getNodeAttribute(id, "label") ?? id
+  })).filter((e) => e.id.includes("::")).sort((a, b) => b.degree - a.degree || a.id.localeCompare(b.id));
+  return entries.slice(0, count).map((e) => `how does ${e.label} work`);
+}
+async function runBenchmark(questions) {
+  const graph = await loadGraph();
+  const effective = questions.length > 0 ? questions : defaultQuestions(graph);
+  if (effective.length === 0) {
+    console.log("The graph has no entity nodes to benchmark against \u2014 build it first.");
+    return [];
+  }
+  const rows = [];
+  for (const question of effective) {
+    rows.push(await benchmarkQuestion(graph, question, (p) => fs.readFile(p, "utf-8")));
+  }
+  console.log("Token cost per question \u2014 graph answer vs reading the files it touches:\n");
+  for (const row of rows) {
+    const reduction = row.reduction > 0 ? `${row.reduction.toFixed(1)}x` : "n/a";
+    console.log(`  "${row.question}"`);
+    console.log(
+      `    graph: ~${row.graphTokens} tokens | files: ~${row.naiveTokens} tokens (${row.filesRead} file(s)${row.filesMissing ? `, ${row.filesMissing} unreadable` : ""}) | reduction: ${reduction}`
+    );
+  }
+  const scored = rows.filter((r) => r.reduction > 0);
+  if (scored.length > 0) {
+    const avg = scored.reduce((s, r) => s + r.reduction, 0) / scored.length;
+    console.log(`
+Average reduction: ${avg.toFixed(1)}x across ${scored.length} question(s).`);
+  } else {
+    console.log("\nNo reduction could be measured \u2014 run from the project root so source files are readable.");
+  }
+  return rows;
+}
+
+// src/cli/commands/check.ts
+import * as fs2 from "fs/promises";
+import * as path from "path";
+async function runCheck(options = {}) {
+  const rulesPath = path.resolve(options.rules ?? "graphify.rules.json");
+  let raw;
+  try {
+    raw = await fs2.readFile(rulesPath, "utf-8");
+  } catch {
+    throw new Error(
+      `No rules file at ${rulesPath} \u2014 create graphify.rules.json with { "rules": [{ "name": "...", "from": "src/a/**", "disallow": ["src/b/**"] }] }.`
+    );
+  }
+  const config = validateRules(JSON.parse(raw));
+  const graph = await loadGraph();
+  const violations = checkRules(graph, config);
+  if (violations.length === 0) {
+    console.log(`OK \u2014 ${config.rules.length} rule(s), no violations.`);
+    return;
+  }
+  console.log(`${violations.length} violation(s):`);
+  for (const v of violations) {
+    console.log(`  [${v.rule}] ${v.fromNode} --${v.relation}--> ${v.toNode}`);
+    console.log(`    ${v.fromFile} must not depend on ${v.toFile}${v.reason ? ` \u2014 ${v.reason}` : ""}`);
+  }
+  process.exitCode = 1;
+}
+
+// src/cli/commands/context.ts
+import * as fs3 from "fs/promises";
+async function runContext(task, options = {}) {
+  const graph = await loadGraph();
+  const pack = await buildContextPack(graph, task, (p) => fs3.readFile(p, "utf-8"), {
+    tokenBudget: options.budget
+  });
+  console.log(renderContextPack(pack));
+}
+
 // src/cli/commands/explain.ts
 async function runExplain(nodeName) {
   const graph = await loadGraph();
@@ -57,31 +216,372 @@ async function runExplain(nodeName) {
   }
 }
 
+// src/cli/commands/review.ts
+async function runReview(base, head) {
+  const diff = await reviewRevisions(process.cwd(), base, head ?? "HEAD");
+  console.log(renderReview(diff));
+}
+
+// src/cli/commands/tests.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runTests(nodeQuery, options = {}) {
+  const graph = await loadGraph();
+  let selection;
+  if (options.changed !== void 0 && options.changed !== false) {
+    const args = ["diff", "--name-only"];
+    if (typeof options.changed === "string") args.push(options.changed);
+    const { stdout } = await execFileAsync("git", args);
+    const changedFiles = stdout.split("\n").map((l) => l.trim()).filter(Boolean);
+    if (changedFiles.length === 0) {
+      console.log("No changed files in the diff.");
+      return;
+    }
+    selection = testsForChangedFiles(graph, changedFiles);
+  } else if (nodeQuery) {
+    selection = testsForNode(graph, nodeQuery);
+    if (!selection) {
+      console.log(`No node matched "${nodeQuery}".`);
+      return;
+    }
+  } else {
+    console.log("Provide a node to select tests for, or --changed for the working-tree diff.");
+    return;
+  }
+  if (selection.testFiles.length === 0) {
+    console.log(
+      `No test files found in the blast radius of ${selection.target} (${selection.affectedNodeCount} affected node(s) checked) \u2014 either it's untested or the tests reach it through a path the graph does not capture.`
+    );
+    return;
+  }
+  console.log(`Test files for ${selection.target} (most direct first):`);
+  for (const test of selection.testFiles) {
+    const via = test.depth === 0 ? test.via : `depth ${test.depth}, via ${test.via}`;
+    console.log(`  ${test.file}  (${via})`);
+  }
+}
+
+// src/cli/commands/global.ts
+import * as fs4 from "fs/promises";
+import * as os from "os";
+import * as path2 from "path";
+function registryDir() {
+  return path2.join(os.homedir(), ".graphify");
+}
+function registryPath() {
+  return path2.join(registryDir(), "global.json");
+}
+async function readRegistry() {
+  try {
+    const raw = await fs4.readFile(registryPath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    const projects = parsed.projects;
+    if (!Array.isArray(projects)) return { projects: [] };
+    return { projects: projects.filter((p) => typeof p?.name === "string" && typeof p?.root === "string") };
+  } catch {
+    return { projects: [] };
+  }
+}
+async function writeRegistry(registry) {
+  await fs4.mkdir(registryDir(), { recursive: true });
+  await fs4.writeFile(registryPath(), JSON.stringify(registry, null, 2), "utf-8");
+}
+async function projectNameFor(root) {
+  try {
+    const raw = await fs4.readFile(path2.join(root, "package.json"), "utf-8");
+    const name = JSON.parse(raw).name;
+    if (typeof name === "string" && name.length > 0) return name;
+  } catch {
+  }
+  return path2.basename(root);
+}
+async function runGlobalAdd(target = ".") {
+  const root = path2.resolve(target);
+  const graphJson = path2.join(root, "graphify-out", "graph.json");
+  try {
+    await fs4.access(graphJson);
+  } catch {
+    throw new Error(`${root} has no graphify-out/graph.json \u2014 run \`graphify ${target}\` first, then add it.`);
+  }
+  const name = await projectNameFor(root);
+  const registry = await readRegistry();
+  const existing = registry.projects.find((p) => p.name === name);
+  if (existing) {
+    if (existing.root === root) {
+      console.log(`${name} is already registered (${root}).`);
+      return;
+    }
+    throw new Error(
+      `A different project is already registered as "${name}" (${existing.root}). Remove it first with \`graphify global remove\`.`
+    );
+  }
+  registry.projects.push({ name, root });
+  registry.projects.sort((a, b) => a.name.localeCompare(b.name));
+  await writeRegistry(registry);
+  console.log(`Registered ${name} (${root}). ${registry.projects.length} project(s) in the global graph.`);
+}
+async function runGlobalRemove(name) {
+  const registry = await readRegistry();
+  const before = registry.projects.length;
+  registry.projects = registry.projects.filter((p) => p.name !== name);
+  if (registry.projects.length === before) {
+    throw new Error(`No project named "${name}" is registered. See \`graphify global list\`.`);
+  }
+  await writeRegistry(registry);
+  console.log(`Removed ${name}. ${registry.projects.length} project(s) remain.`);
+}
+async function runGlobalList() {
+  const registry = await readRegistry();
+  if (registry.projects.length === 0) {
+    console.log("No projects registered. Add one with `graphify global add <path>`.");
+    return;
+  }
+  for (const project of registry.projects) {
+    console.log(`${project.name}  ${project.root}`);
+  }
+}
+async function loadEntries(sources) {
+  const entries = [];
+  for (const source of sources) {
+    try {
+      entries.push({ name: source.name, graph: await loadGraph(source.outDir) });
+    } catch (error) {
+      console.warn(`Skipping ${source.name}: ${error.message}`);
+    }
+  }
+  return entries;
+}
+async function mergeAndExport(entries, outDir) {
+  if (entries.length === 0) {
+    throw new Error("Nothing to merge \u2014 no project graphs could be loaded.");
+  }
+  const merged = mergeGraphs(entries);
+  cluster(merged);
+  const analysis = analyze(merged);
+  const report = renderReport(merged, analysis);
+  await exportGraph(merged, { outDir }, report);
+  console.log(
+    `Merged ${entries.length} project(s) into ${outDir} \u2014 ${merged.order} node(s), ${merged.size} edge(s).`
+  );
+}
+async function runGlobalBuild(options = {}) {
+  const registry = await readRegistry();
+  if (registry.projects.length === 0) {
+    throw new Error("No projects registered. Add some with `graphify global add <path>` first.");
+  }
+  const entries = await loadEntries(
+    registry.projects.map((p) => ({ name: p.name, outDir: path2.join(p.root, "graphify-out") }))
+  );
+  await mergeAndExport(entries, path2.resolve(options.out ?? path2.join(registryDir(), "global-out")));
+}
+async function runMerge(targets, options = {}) {
+  if (targets.length < 2) {
+    throw new Error("Provide at least two project directories to merge.");
+  }
+  const sources = [];
+  for (const target of targets) {
+    const root = path2.resolve(target);
+    sources.push({ name: await projectNameFor(root), outDir: path2.join(root, "graphify-out") });
+  }
+  const names = sources.map((s) => s.name);
+  const duplicate = names.find((name, i) => names.indexOf(name) !== i);
+  if (duplicate !== void 0) {
+    throw new Error(`Two of the given projects resolve to the same name ("${duplicate}") \u2014 rename one.`);
+  }
+  const entries = await loadEntries(sources);
+  await mergeAndExport(entries, path2.resolve(options.out ?? "graphify-merged"));
+}
+
+// src/cli/commands/hook.ts
+import * as fs5 from "fs/promises";
+import * as path3 from "path";
+var MARKER_BEGIN = "# >>> graphify >>>";
+var MARKER_END = "# <<< graphify <<<";
+var HOOK_NAMES = ["post-commit", "post-merge"];
+var HOOK_BLOCK = `${MARKER_BEGIN}
+# Rebuild the graphify knowledge graph in the background so the hook never
+# slows down the commit. Errors are silenced \u2014 a failed rebuild should never
+# break a git operation. Installed by \`graphify hook install\`.
+(graphify . --update --no-viz >/dev/null 2>&1 &)
+${MARKER_END}`;
+async function hooksDir(cwd) {
+  const gitDir = path3.join(cwd, ".git");
+  let stats;
+  try {
+    stats = await fs5.stat(gitDir);
+  } catch {
+    throw new Error(`${cwd} is not a git repository (no .git directory) \u2014 run this from the repo root.`);
+  }
+  if (!stats.isDirectory()) {
+    const content = (await fs5.readFile(gitDir, "utf-8")).trim();
+    const match = /^gitdir:\s*(.+)$/.exec(content);
+    if (!match) throw new Error(`${gitDir} exists but is neither a directory nor a gitdir pointer.`);
+    return path3.resolve(cwd, match[1], "hooks");
+  }
+  return path3.join(gitDir, "hooks");
+}
+async function runHookInstall(cwd = process.cwd()) {
+  const dir = await hooksDir(cwd);
+  await fs5.mkdir(dir, { recursive: true });
+  const results = [];
+  for (const hook of HOOK_NAMES) {
+    const hookPath = path3.join(dir, hook);
+    let existing = null;
+    try {
+      existing = await fs5.readFile(hookPath, "utf-8");
+    } catch {
+    }
+    if (existing === null) {
+      await fs5.writeFile(hookPath, `#!/bin/sh
+${HOOK_BLOCK}
+`, { mode: 493 });
+      results.push({ hook, path: hookPath, action: "created" });
+    } else if (existing.includes(MARKER_BEGIN)) {
+      results.push({ hook, path: hookPath, action: "already-installed" });
+    } else {
+      const separator = existing.endsWith("\n") ? "" : "\n";
+      await fs5.writeFile(hookPath, `${existing}${separator}${HOOK_BLOCK}
+`, "utf-8");
+      await fs5.chmod(hookPath, 493);
+      results.push({ hook, path: hookPath, action: "appended" });
+    }
+  }
+  for (const result of results) {
+    console.log(`${result.hook}: ${result.action} (${result.path})`);
+  }
+  console.log("");
+  console.log("The graph will rebuild in the background after each commit and pull.");
+  console.log("Remove with `graphify hook uninstall`.");
+  return results;
+}
+async function runHookUninstall(cwd = process.cwd()) {
+  const dir = await hooksDir(cwd);
+  const results = [];
+  for (const hook of HOOK_NAMES) {
+    const hookPath = path3.join(dir, hook);
+    let existing = null;
+    try {
+      existing = await fs5.readFile(hookPath, "utf-8");
+    } catch {
+    }
+    if (existing === null || !existing.includes(MARKER_BEGIN)) {
+      results.push({ hook, path: hookPath, action: "not-installed" });
+      continue;
+    }
+    const blockPattern = new RegExp(`\\n?${MARKER_BEGIN}[\\s\\S]*?${MARKER_END}\\n?`);
+    const remaining = existing.replace(blockPattern, "\n").trim();
+    if (remaining === "" || remaining === "#!/bin/sh") {
+      await fs5.unlink(hookPath);
+    } else {
+      await fs5.writeFile(hookPath, `${remaining}
+`, "utf-8");
+    }
+    results.push({ hook, path: hookPath, action: "removed" });
+  }
+  for (const result of results) {
+    console.log(`${result.hook}: ${result.action}`);
+  }
+  return results;
+}
+
 // src/cli/commands/install.ts
 import { createRequire } from "module";
-import * as fs from "fs/promises";
-import * as path from "path";
+import * as fs6 from "fs/promises";
+import * as path4 from "path";
 var require2 = createRequire(import.meta.url);
 function packageRoot() {
   const packageJsonPath = require2.resolve("@dreamtree-org/graphify/package.json");
-  return path.dirname(packageJsonPath);
+  return path4.dirname(packageJsonPath);
+}
+var MD_MARKER_BEGIN = "<!-- >>> graphify >>> -->";
+var MD_MARKER_END = "<!-- <<< graphify <<< -->";
+async function writeOwnedFile(filePath, content) {
+  await fs6.mkdir(path4.dirname(filePath), { recursive: true });
+  await fs6.writeFile(filePath, content, "utf-8");
+}
+async function upsertMarkedBlock(filePath, content) {
+  const block = `${MD_MARKER_BEGIN}
+${content.trim()}
+${MD_MARKER_END}`;
+  let existing = null;
+  try {
+    existing = await fs6.readFile(filePath, "utf-8");
+  } catch {
+  }
+  if (existing === null) {
+    await fs6.mkdir(path4.dirname(filePath), { recursive: true });
+    await fs6.writeFile(filePath, `${block}
+`, "utf-8");
+    return;
+  }
+  if (existing.includes(MD_MARKER_BEGIN)) {
+    const pattern = new RegExp(`${MD_MARKER_BEGIN}[\\s\\S]*?${MD_MARKER_END}`);
+    await fs6.writeFile(filePath, existing.replace(pattern, block), "utf-8");
+    return;
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  await fs6.writeFile(filePath, `${existing}${separator}${block}
+`, "utf-8");
 }
-async function runInstall(cwd = process.cwd()) {
-  const sourcePath = path.join(packageRoot(), "src", "skill", "SKILL.md");
-  const content = await fs.readFile(sourcePath, "utf-8");
+var PLATFORMS = {
+  claude: async (cwd, content) => {
+    const target = path4.join(cwd, ".claude", "skills", "graphify", "SKILL.md");
+    await writeOwnedFile(target, content);
+    return { host: "Claude Code", path: target };
+  },
+  cursor: async (cwd, content) => {
+    const target = path4.join(cwd, ".cursor", "rules", "graphify.mdc");
+    const body = content.replace(/^---[\s\S]*?---\n/, "");
+    await writeOwnedFile(
+      target,
+      `---
+description: Query the graphify knowledge graph for codebase structure questions
+alwaysApply: false
+---
+${body}`
+    );
+    return { host: "Cursor", path: target };
+  },
+  windsurf: async (cwd, content) => {
+    const target = path4.join(cwd, ".windsurf", "rules", "graphify.md");
+    await writeOwnedFile(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "Windsurf", path: target };
+  },
+  cline: async (cwd, content) => {
+    const target = path4.join(cwd, ".clinerules", "graphify.md");
+    await writeOwnedFile(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "Cline", path: target };
+  },
+  agents: async (cwd, content) => {
+    const target = path4.join(cwd, "AGENTS.md");
+    await upsertMarkedBlock(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "AGENTS.md agents (Codex, opencode, Amp, ...)", path: target };
+  },
+  gemini: async (cwd, content) => {
+    const target = path4.join(cwd, "GEMINI.md");
+    await upsertMarkedBlock(target, content.replace(/^---[\s\S]*?---\n/, ""));
+    return { host: "Gemini CLI", path: target };
+  }
+};
+var SUPPORTED_PLATFORMS = Object.keys(PLATFORMS).sort((a, b) => a.localeCompare(b));
+async function runInstall(platforms = ["claude"], cwd = process.cwd()) {
+  const sourcePath = path4.join(packageRoot(), "src", "skill", "SKILL.md");
+  const content = await fs6.readFile(sourcePath, "utf-8");
+  const requested = platforms.includes("all") ? SUPPORTED_PLATFORMS : platforms;
   const results = [];
-  const claudeCodeDir = path.join(cwd, ".claude", "skills", "graphify");
-  await fs.mkdir(claudeCodeDir, { recursive: true });
-  const claudeCodePath = path.join(claudeCodeDir, "SKILL.md");
-  await fs.writeFile(claudeCodePath, content, "utf-8");
-  results.push({ host: "Claude Code", path: claudeCodePath });
+  for (const platform of requested) {
+    const installer = PLATFORMS[platform];
+    if (!installer) {
+      throw new Error(
+        `Unknown platform "${platform}" \u2014 supported: ${SUPPORTED_PLATFORMS.join(", ")}, or "all".`
+      );
+    }
+    results.push(await installer(cwd, content));
+  }
   for (const result of results) {
-    console.log(`Installed graphify skill for ${result.host} -> ${result.path}`);
+    console.log(`Installed graphify for ${result.host} -> ${result.path}`);
   }
-  console.log("");
-  console.log(
-    "Other hosts (Cursor, etc.) are not implemented yet by `graphify install` \u2014 see ARCHITECTURE.md."
-  );
   return results;
 }
 
@@ -113,7 +613,7 @@ async function runPath(fromNode, toNode) {
 // src/cli/commands/query.ts
 async function runQuery(question, options = {}) {
   const graph = await loadGraph();
-  const result = queryGraph(graph, question, { dfs: options.dfs, budget: options.budget });
+  const result = queryGraph(graph, question, { dfs: options.dfs, tokenBudget: options.budget });
   if (result.seeds.length === 0) {
     console.log(
       `No nodes matched "${question}". Try different keywords, or run \`graphify explain <node>\` if you already know the name.`
@@ -138,15 +638,15 @@ async function runQuery(question, options = {}) {
 }
 
 // src/cli/index.ts
-var execFileAsync = promisify(execFile);
+var execFileAsync2 = promisify2(execFile2);
 function looksLikeGitUrl(value) {
   if (!/^https?:\/\//i.test(value)) return false;
   return /github\.com|gitlab\.com|bitbucket\.org/i.test(value) || value.endsWith(".git");
 }
 async function cloneRepo(url) {
   const validated = validateUrl(url);
-  const dest = await fs2.mkdtemp(path2.join(os.tmpdir(), "graphify-clone-"));
-  await execFileAsync("git", ["clone", "--depth", "1", validated, dest]);
+  const dest = await fs7.mkdtemp(path5.join(os2.tmpdir(), "graphify-clone-"));
+  await execFileAsync2("git", ["clone", "--depth", "1", validated, dest]);
   return dest;
 }
 function exportOptionsFrom(options) {
@@ -159,7 +659,7 @@ function clusterOptionsFrom(options) {
   };
 }
 async function runClusterOnly(root, options) {
-  const outDir = path2.join(root, "graphify-out");
+  const outDir = path5.join(root, "graphify-out");
   const graph = await loadGraph(outDir);
   cluster(graph, clusterOptionsFrom(options));
   const analysis = analyze(graph);
@@ -190,12 +690,12 @@ async function watchAndRebuild(root, runOnce) {
   });
 }
 var program = new Command();
-program.name("graphify").description("Turn a folder of code/docs/papers into a queryable knowledge graph.").argument("[path]", "path to scan, or a GitHub URL", ".").option("--mode <mode>", "extraction mode (deep for richer INFERRED edges \u2014 reserved, no-op in v1)").option("--update", "incremental re-extract of changed files only (not implemented in v1 \u2014 runs full pipeline)").option("--watch", "rebuild on file change").option("--cluster-only", "rerun clustering on an existing graph").option("--leiden", "use Leiden instead of Louvain for community detection (v2 \u2014 better community quality)").option("--max-iterations <n>", "Leiden only: cap on outer iterations for very large graphs", Number).option("--no-viz", "skip graph.html").option("--svg", "also export graph.svg (not implemented in v1)").option("--graphml", "also export graph.graphml (not implemented in v1)").option("--neo4j", "generate graphify-out/cypher.txt for Neo4j (not implemented in v1)").option("--mcp", "start MCP stdio server instead of running the pipeline").action(async (targetArg, options) => {
+program.name("graphify").description("Turn a folder of code/docs/papers into a queryable knowledge graph.").argument("[path]", "path to scan, or a GitHub URL", ".").option("--mode <mode>", "extraction mode (deep for richer INFERRED edges \u2014 reserved, no-op in v1)").option("--update", "incremental rebuild \u2014 reuse cached extractions for unchanged files").option("--watch", "rebuild on file change").option("--cluster-only", "rerun clustering on an existing graph").option("--leiden", "use Leiden instead of Louvain for community detection (v2 \u2014 better community quality)").option("--max-iterations <n>", "Leiden only: cap on outer iterations for very large graphs", Number).option("--no-viz", "skip graph.html").option("--svg", "also export graph.svg (not implemented in v1)").option("--graphml", "also export graph.graphml (not implemented in v1)").option("--neo4j", "generate graphify-out/cypher.txt for Neo4j (not implemented in v1)").option("--mcp", "start MCP stdio server instead of running the pipeline").option("--mysql <dsn>", "also extract a MySQL schema (mysql://user:pass@host:port/db) into the graph").action(async (targetArg, options) => {
   try {
     if (options.mcp) {
-      const outDir = path2.resolve(targetArg === "." ? process.cwd() : targetArg, "graphify-out");
+      const outDir = path5.resolve(targetArg === "." ? process.cwd() : targetArg, "graphify-out");
       const { startServer } = await import("../mcp/server.js");
-      await startServer(path2.join(outDir, "graph.json"));
+      await startServer(path5.join(outDir, "graph.json"));
       return;
     }
     let root = targetArg;
@@ -203,12 +703,7 @@ program.name("graphify").description("Turn a folder of code/docs/papers into a q
       console.error(`Cloning ${targetArg} ...`);
       root = await cloneRepo(targetArg);
     }
-    root = path2.resolve(root);
-    if (options.update) {
-      console.error(
-        "--update (incremental re-extract) is not implemented yet in v1 \u2014 running the full pipeline instead."
-      );
-    }
+    root = path5.resolve(root);
     if (options.mode) {
       console.error(`--mode ${options.mode} is reserved for a future richer-INFERRED-edges pass \u2014 currently a no-op.`);
     }
@@ -216,9 +711,17 @@ program.name("graphify").description("Turn a folder of code/docs/papers into a q
       await runClusterOnly(root, options);
       return;
     }
+    let extraExtractions;
+    if (options.mysql) {
+      const { extractMysql } = await import("../mysql-EJ6XOWR4.js");
+      console.error(`Extracting MySQL schema from ${validateDsn(options.mysql).safeDisplay} ...`);
+      extraExtractions = [await extractMysql(options.mysql)];
+    }
     const runOnce = () => runPipeline(root, {
       ...exportOptionsFrom(options),
       ...clusterOptionsFrom(options),
+      extraExtractions,
+      update: options.update,
       onProgress: (m) => console.error(m)
     });
     await runOnce();
@@ -255,13 +758,153 @@ program.command("explain <node>").description("plain-language explanation of a n
     process.exitCode = 1;
   }
 });
-program.command("install").description("install the skill files into the local agent(s)").action(async () => {
+program.command("affected <node>").description("reverse impact analysis \u2014 everything that (transitively) depends on a node").option("--depth <n>", "how many reverse hops to follow (default 3)", Number).option("--limit <n>", "cap on affected nodes reported (default 200)", Number).action(async (node, options) => {
+  try {
+    await runAffected(node, options);
+  } catch (error) {
+    console.error(`graphify affected: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("context <task>").description("token-budgeted working-set pack \u2014 the actual code for a task, in one call").option("--budget <tokens>", "approximate token cap for the pack (default 4000)", Number).action(async (task, options) => {
+  try {
+    await runContext(task, options);
+  } catch (error) {
+    console.error(`graphify context: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("tests [node]").description("structural test selection \u2014 the minimal test files worth running for a change").option("--changed [rev]", "select for the working-tree diff (optionally vs a revision) instead of a node").action(async (node, options) => {
   try {
-    await runInstall();
+    await runTests(node, options);
+  } catch (error) {
+    console.error(`graphify tests: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("review <base> [head]").description("structural review between two git revisions: added/removed/rewired symbols with blast radius + tests").action(async (base, head) => {
+  try {
+    await runReview(base, head);
+  } catch (error) {
+    console.error(`graphify review: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("check").description("check the graph against dependency rules (graphify.rules.json) \u2014 exits 1 on violations").option("--rules <file>", "rules file (default ./graphify.rules.json)").action(async (options) => {
+  try {
+    await runCheck(options);
+  } catch (error) {
+    console.error(`graphify check: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("benchmark [questions...]").description("measure token savings of graph answers vs reading the files they touch").action(async (questions) => {
+  try {
+    await runBenchmark(questions);
+  } catch (error) {
+    console.error(`graphify benchmark: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("install").description("install the skill/rules files into local agents (claude, cursor, windsurf, cline, agents, gemini, all)").option("--platform <names...>", "platform(s) to install for", ["claude"]).action(async (options) => {
+  try {
+    await runInstall(options.platform);
   } catch (error) {
     console.error(`graphify install: ${error.message}`);
     process.exitCode = 1;
   }
 });
+var globalCommand = program.command("global").description("manage the cross-project global graph (registry at ~/.graphify/global.json)");
+globalCommand.command("add [path]").description("register a project (must already have graphify-out/graph.json)").action(async (target) => {
+  try {
+    await runGlobalAdd(target);
+  } catch (error) {
+    console.error(`graphify global add: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+globalCommand.command("remove <name>").description("unregister a project by name").action(async (name) => {
+  try {
+    await runGlobalRemove(name);
+  } catch (error) {
+    console.error(`graphify global remove: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+globalCommand.command("list").description("list registered projects").action(async () => {
+  try {
+    await runGlobalList();
+  } catch (error) {
+    console.error(`graphify global list: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+globalCommand.command("build").description("merge every registered project into one global graph").option("--out <dir>", "output directory (default ~/.graphify/global-out)").action(async (options) => {
+  try {
+    await runGlobalBuild(options);
+  } catch (error) {
+    console.error(`graphify global build: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("merge <dirs...>").description("one-shot merge of two or more built project graphs into one").option("--out <dir>", "output directory (default ./graphify-merged)").action(async (dirs, options) => {
+  try {
+    await runMerge(dirs, options);
+  } catch (error) {
+    console.error(`graphify merge: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("save-result").description("save a Q&A result to graphify-out/memory/ for the graph feedback loop").requiredOption("--question <q>", "the question that was asked").requiredOption("--answer <a>", "the answer that was given").option("--nodes <ids...>", "node ids/labels cited in the answer", []).option("--type <t>", "query|path|explain|affected", "query").option("--outcome <o>", "useful|dead_end|corrected", "useful").option("--correction <text>", "what the right answer was (pairs with --outcome corrected)").action(async (options) => {
+  try {
+    const memoryDir = path5.join(process.cwd(), "graphify-out", "memory");
+    const file = await saveResult(
+      {
+        question: options.question,
+        answer: options.answer,
+        nodes: options.nodes,
+        type: options.type,
+        outcome: options.outcome,
+        correction: options.correction
+      },
+      memoryDir
+    );
+    console.log(`Saved -> ${file}`);
+  } catch (error) {
+    console.error(`graphify save-result: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+program.command("reflect").description("aggregate graphify-out/memory/ into a recency-weighted lessons doc").option("--half-life-days <n>", "a result loses half its weight every N days (default 30)", Number).option("--out <file>", "output path (default graphify-out/reflections/LESSONS.md)").action(async (options) => {
+  try {
+    const memoryDir = path5.join(process.cwd(), "graphify-out", "memory");
+    const results = await loadResults(memoryDir);
+    const lessons = renderLessons(results, { halfLifeDays: options.halfLifeDays });
+    const outPath = path5.resolve(options.out ?? path5.join(process.cwd(), "graphify-out", "reflections", "LESSONS.md"));
+    await fs7.mkdir(path5.dirname(outPath), { recursive: true });
+    await fs7.writeFile(outPath, lessons, "utf-8");
+    console.log(`Reflected ${results.length} result(s) -> ${outPath}`);
+  } catch (error) {
+    console.error(`graphify reflect: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+var hookCommand = program.command("hook").description("manage the git hooks that auto-rebuild the graph on commit/pull");
+hookCommand.command("install").description("install post-commit and post-merge hooks (preserves existing hook content)").action(async () => {
+  try {
+    await runHookInstall();
+  } catch (error) {
+    console.error(`graphify hook install: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
+hookCommand.command("uninstall").description("remove the graphify block from the git hooks").action(async () => {
+  try {
+    await runHookUninstall();
+  } catch (error) {
+    console.error(`graphify hook uninstall: ${error.message}`);
+    process.exitCode = 1;
+  }
+});
 program.parseAsync(process.argv);
 //# sourceMappingURL=index.js.map