@dreamtree-org/graphify 1.1.2 → 1.2.0

package/README.md

@@ -31,6 +31,14 @@ npm install -g @dreamtree-org/graphify
 npx @dreamtree-org/graphify .
 ```
 
+A default run does more than build the graph — it also makes it instantly usable by the AI
+agents your project already has: it installs the graphify skill/rules files and registers the
+project-scoped MCP server. Claude Code is always set up (`.claude/skills/graphify/SKILL.md` +
+`.mcp.json`); Cursor, Windsurf, Cline, AGENTS.md hosts, and Gemini CLI are set up when their
+config dir/file is detected in the project. All writes are idempotent and never touch your
+existing config (`.mcp.json` entries for other servers, user content in `AGENTS.md`, ...).
+Opt out with `--no-install`.
+
 ## Build the graph
 
 ```bash
@@ -43,6 +51,7 @@ graphify . --leiden             # Leiden instead of Louvain community detection
 graphify . --watch              # rebuild on file change
 graphify . --mysql <dsn>        # also extract a MySQL schema (mysql://user:pass@host:port/db) into the same graph
 graphify . --mcp                # start the MCP stdio server instead of running the pipeline
+graphify . --no-install         # skip the automatic agent skill + MCP config install
 ```
 
 Outputs land in `graphify-out/`: `graph.json` (GraphRAG-ready), `graph.html` (interactive,
@@ -79,8 +88,10 @@ graphify save-result --question Q --answer A --nodes id... --outcome useful|dead
 graphify reflect                # aggregate results into graphify-out/reflections/LESSONS.md
                                 #   (recency-weighted; agents read it at session start)
 graphify hook install           # auto-rebuild (incremental) after every commit and pull
-graphify install --platform all # install the agent skill/rules: claude, cursor, windsurf, cline,
-                                #   agents (AGENTS.md: Codex/opencode/Amp), gemini
+graphify install --platform all # install the agent skill/rules + project MCP config: claude,
+                                #   cursor, windsurf, cline, agents (AGENTS.md: Codex/opencode/Amp),
+                                #   gemini — a plain `graphify .` run already does this for
+                                #   detected hosts
 ```
 
 With hooks installed the MCP server always serves a fresh graph — it re-reads `graph.json`
@@ -102,6 +113,11 @@ so repos that use the same packages are automatically bridged in the merged grap
 `graphify --mcp` (or the `graphify-mcp` binary) exposes `context`, `query`, `path`,
 `explain`, `affected`, and `tests` as MCP tools over stdio. No network listener.
 
+You normally never start it by hand: the default pipeline run registers it in the project's
+MCP config (`.mcp.json` for Claude Code, `.cursor/mcp.json` for Cursor, `.gemini/settings.json`
+for Gemini CLI) as `npx -y @dreamtree-org/graphify --mcp`, so the host launches it on demand —
+and teammates who pull the repo get it with zero setup.
+
 ## Guardrails file
 
 `graphify.rules.json` at the repo root (this repo dogfoods its own):

package/dist/{chunk-PXVI2L45.js → chunk-NS5HB65S.js}

@@ -1,7 +1,7 @@
 import {
   affectedBy,
   testsForNode
-} from "./chunk-YT7B6DOD.js";
+} from "./chunk-ZK3TA6FW.js";
 import {
   escapeHtml,
   sanitizeLabel,
@@ -1609,13 +1609,11 @@ async function extractTypeScript(filePath, displayPath) {
     });
   }
   function importTargetId(binding, property) {
-    if (!binding.ref.external) {
-      if (binding.kind === "named" && binding.importedName) {
-        return entityId(binding.ref.id, binding.importedName);
-      }
-      if (binding.kind === "namespace" && property) {
-        return entityId(binding.ref.id, property);
-      }
+    if (binding.kind === "named" && binding.importedName) {
+      return entityId(binding.ref.id, binding.importedName);
+    }
+    if (binding.kind === "namespace" && property) {
+      return entityId(binding.ref.id, property);
     }
     return binding.ref.id;
   }
@@ -1653,24 +1651,35 @@ async function extractTypeScript(filePath, displayPath) {
       }
     }
   }
+  function unwrapExpression(node) {
+    let current = node;
+    while (current.type === "as_expression" || current.type === "satisfies_expression" || current.type === "non_null_expression" || current.type === "parenthesized_expression") {
+      const inner = namedChildren(current)[0];
+      if (!inner) break;
+      current = inner;
+    }
+    return current;
+  }
   function handleTopLevelVariableFunctions(node) {
+    const isExported = node.parent?.type === "export_statement";
     for (const declarator of namedChildren(node)) {
       if (declarator.type !== "variable_declarator") continue;
       const value = declarator.childForFieldName("value");
       if (!value) continue;
-      if (value.type === "arrow_function" || value.type === "function_expression") {
+      const core = unwrapExpression(value);
+      if (core.type === "arrow_function" || core.type === "function_expression") {
         const name = declarator.childForFieldName("name")?.text;
         if (!name) continue;
         const id = entityId(sourceFile, name);
         builder.addNode({ id, label: `function ${name}`, sourceFile, sourceLocation: lineOf(declarator) });
         builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
         nameIndex.set(name, id);
-        functionNodeMap.set(value.id, id);
+        functionNodeMap.set(core.id, id);
         continue;
       }
-      if (value.type === "call_expression") {
-        const callee = value.childForFieldName("function");
-        const specifier = callee?.type === "identifier" && callee.text === "require" ? firstStringArgument(value) : null;
+      if (core.type === "call_expression") {
+        const callee = core.childForFieldName("function");
+        const specifier = callee?.type === "identifier" && callee.text === "require" ? firstStringArgument(core) : null;
         if (specifier) {
           const nameNode = declarator.childForFieldName("name");
           if (nameNode) {
@@ -1678,6 +1687,21 @@ async function extractTypeScript(filePath, displayPath) {
             addModuleNode(ref);
             registerRequireBinding(nameNode, ref);
           }
+          continue;
+        }
+      }
+      if (isExported) {
+        const name = declarator.childForFieldName("name")?.text;
+        if (!name) continue;
+        const id = entityId(sourceFile, name);
+        builder.addNode({ id, label: `const ${name}`, sourceFile, sourceLocation: lineOf(declarator) });
+        builder.addEdge({ source: fileId, target: id, relation: "contains", confidence: "EXTRACTED" });
+        nameIndex.set(name, id);
+        if (core.type === "identifier") {
+          const aliased = nameIndex.get(core.text);
+          if (aliased !== void 0 && aliased !== id) {
+            builder.addEdge({ source: id, target: aliased, relation: "references", confidence: "EXTRACTED" });
+          }
         }
       }
     }
@@ -2077,13 +2101,12 @@ function candidatePaths(guessed) {
   }
   return candidates.filter((c) => c !== guessed);
 }
-function uniqueMatch(guessed, candidates, realIds) {
+function uniqueMatch(candidates, real) {
   const matches = /* @__PURE__ */ new Set();
   for (const candidate of candidates) {
-    if (realIds.has(candidate)) matches.add(candidate);
+    if (real.has(candidate)) matches.add(candidate);
   }
-  if (matches.size !== 1) return null;
-  return [...matches][0];
+  return matches.size === 1 ? [...matches][0] : null;
 }
 function resolveCrossFileReferences(extractions, options = {}) {
   const selfNames = options.selfNames ?? [];
@@ -2104,20 +2127,24 @@ function resolveCrossFileReferences(extractions, options = {}) {
     }
   }
   const remap = /* @__PURE__ */ new Map();
-  const resolveId = (id) => {
-    if (id.startsWith("module:") && selfNames.length > 0) {
-      const cachedSelf = remap.get(id);
-      if (cachedSelf !== void 0) return cachedSelf;
-      const candidates = selfImportCandidates(id.slice("module:".length), selfNames);
-      if (candidates !== null) {
-        const resolved2 = uniqueMatch(id, candidates, realFiles);
-        if (resolved2 !== null) {
-          remap.set(id, resolved2);
-          return resolved2;
+  let resolvedEndpoints = 0;
+  const applyRemap = (resolveId) => {
+    for (const extraction of extractions) {
+      for (const edge of extraction.edges) {
+        const source = resolveId(edge.source);
+        if (source !== null) {
+          edge.source = source;
+          resolvedEndpoints++;
+        }
+        const target = resolveId(edge.target);
+        if (target !== null) {
+          edge.target = target;
+          resolvedEndpoints++;
         }
       }
-      return null;
     }
+  };
+  const resolvePathId = (id) => {
     if (isOpaque(id)) return null;
     const cached = remap.get(id);
     if (cached !== void 0) return cached;
@@ -2127,30 +2154,77 @@ function resolveCrossFileReferences(extractions, options = {}) {
       if (realIds.has(id)) return null;
       const guessedPath = id.slice(0, sep2);
       const name = id.slice(sep2);
-      const candidates = candidatePaths(guessedPath).map((p) => `${p}${name}`);
-      resolved = uniqueMatch(id, candidates, realIds);
+      resolved = uniqueMatch(candidatePaths(guessedPath).map((p) => `${p}${name}`), realIds);
     } else {
       if (realFiles.has(id)) return null;
-      resolved = uniqueMatch(id, candidatePaths(id), realFiles);
+      resolved = uniqueMatch(candidatePaths(id), realFiles);
     }
     if (resolved !== null) remap.set(id, resolved);
     return resolved;
   };
-  let resolvedEndpoints = 0;
+  applyRemap(resolvePathId);
+  const namedAlias = /* @__PURE__ */ new Map();
+  const starTargets = /* @__PURE__ */ new Map();
   for (const extraction of extractions) {
     for (const edge of extraction.edges) {
-      const source = resolveId(edge.source);
-      if (source !== null) {
-        edge.source = source;
-        resolvedEndpoints++;
-      }
-      const target = resolveId(edge.target);
-      if (target !== null) {
-        edge.target = target;
-        resolvedEndpoints++;
+      if (edge.relation !== "re_exports" || !realFiles.has(edge.source)) continue;
+      const sep2 = edge.target.lastIndexOf("::");
+      if (sep2 > 0 && realIds.has(edge.target)) {
+        namedAlias.set(`${edge.source}|${edge.target.slice(sep2 + 2)}`, edge.target);
+      } else if (sep2 < 0 && realFiles.has(edge.target)) {
+        const targets = starTargets.get(edge.source) ?? [];
+        targets.push(edge.target);
+        starTargets.set(edge.source, targets);
       }
     }
   }
+  const throughBarrel = (file, name) => {
+    const direct = `${file}::${name}`;
+    if (realIds.has(direct)) return direct;
+    const aliased = namedAlias.get(`${file}|${name}`);
+    if (aliased !== void 0) return aliased;
+    const viaStar = (starTargets.get(file) ?? []).map((sf) => `${sf}::${name}`).filter((id) => realIds.has(id));
+    return viaStar.length === 1 ? viaStar[0] : null;
+  };
+  const resolveBarrelId = (id) => {
+    const cached = remap.get(id);
+    if (cached !== void 0) return cached;
+    if (id.startsWith("module:")) {
+      const spec = id.slice("module:".length);
+      const sep3 = spec.indexOf("::");
+      const moduleSpec = sep3 > 0 ? spec.slice(0, sep3) : spec;
+      const name = sep3 > 0 ? spec.slice(sep3 + 2) : null;
+      const candidates = selfImportCandidates(moduleSpec, selfNames);
+      if (candidates === null) {
+        if (name === null) return null;
+        remap.set(id, `module:${moduleSpec}`);
+        return `module:${moduleSpec}`;
+      }
+      const file = uniqueMatch(candidates, realFiles);
+      let resolved = null;
+      if (file !== null) {
+        resolved = name !== null ? throughBarrel(file, name) ?? file : file;
+      } else if (name !== null) {
+        resolved = `module:${moduleSpec}`;
+      }
+      if (resolved !== null) remap.set(id, resolved);
+      return resolved;
+    }
+    const sep2 = id.indexOf("::");
+    if (sep2 > 0 && !realIds.has(id)) {
+      const guessedPath = id.slice(0, sep2);
+      const name = id.slice(sep2 + 2);
+      const files = [guessedPath, ...candidatePaths(guessedPath)].filter((f) => realFiles.has(f));
+      const resolvedSet = new Set(files.map((f) => throughBarrel(f, name)).filter((r) => r !== null));
+      if (resolvedSet.size === 1) {
+        const resolved = [...resolvedSet][0];
+        remap.set(id, resolved);
+        return resolved;
+      }
+    }
+    return null;
+  };
+  applyRemap(resolveBarrelId);
   let droppedPlaceholders = 0;
   for (const extraction of extractions) {
     const before = extraction.nodes.length;
@@ -3046,4 +3120,4 @@ export {
   validateRules,
   checkRules
 };
-//# sourceMappingURL=chunk-PXVI2L45.js.map
+//# sourceMappingURL=chunk-NS5HB65S.js.map