aihand 0.0.1 → 0.1.1

package/dist/chunk-G7KVJ7NF.js

@@ -0,0 +1,369 @@
+import {
+  getLang
+} from "./chunk-OWYK2IGV.js";
+
+// src/read/panel.ts
+import { readFileSync } from "fs";
+import { Parser, Query } from "web-tree-sitter";
+var ATTR_QUERY = `
+(jsx_attribute
+  (property_identifier) @name
+  (jsx_expression) @val) @attr
+`;
+function collapseWs(s) {
+  const tokens = [];
+  let cur = "";
+  for (const ch of s) {
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") {
+      if (cur) {
+        tokens.push(cur);
+        cur = "";
+      }
+    } else {
+      cur += ch;
+    }
+  }
+  if (cur) tokens.push(cur);
+  return tokens.join(" ");
+}
+function storeWritesIn(node) {
+  const out = [];
+  const walk = (n) => {
+    if (n.type === "assignment_expression") {
+      const left = n.childForFieldName("left");
+      const right = n.childForFieldName("right");
+      if (left?.type === "member_expression") {
+        const obj = left.childForFieldName("object");
+        const prop = left.childForFieldName("property");
+        if (obj?.type === "identifier" && obj.text.endsWith("Store") && prop)
+          out.push({ store: obj.text, field: prop.text, to: collapseWs(right?.text ?? "") });
+      }
+    } else if (n.type === "call_expression") {
+      const fn = n.childForFieldName("function");
+      if (fn?.type === "member_expression") {
+        const obj = fn.childForFieldName("object");
+        const method = fn.childForFieldName("property");
+        if (obj?.type === "identifier" && obj.text.endsWith("Store") && method) {
+          const argsNode = n.childForFieldName("arguments");
+          const inner = argsNode ? collapseWs(argsNode.text).slice(1, -1).trim() : "";
+          out.push({ store: obj.text, field: `${method.text}()`, to: "", args: inner });
+        }
+      }
+    }
+    for (let i = 0; i < n.namedChildCount; i++) walk(n.namedChild(i));
+  };
+  walk(node);
+  return out;
+}
+function labelOf(opening) {
+  for (let i = 0; i < opening.namedChildCount; i++) {
+    const a = opening.namedChild(i);
+    if (a.type !== "jsx_attribute") continue;
+    if (a.namedChild(0)?.text !== "label" && a.namedChild(0)?.text !== "title") continue;
+    const val = a.namedChild(1);
+    if (!val) continue;
+    if (val.type === "string") return val.text.slice(1, -1);
+    let found = null;
+    const dig = (n) => {
+      if (found) return;
+      if (n.type === "string") {
+        found = n.text.slice(1, -1);
+        return;
+      }
+      for (let j = 0; j < n.namedChildCount; j++) dig(n.namedChild(j));
+    };
+    dig(val);
+    if (found) return found;
+  }
+  const element = opening.parent;
+  if (element?.type === "jsx_element") {
+    const parts = [];
+    for (let i = 0; i < element.namedChildCount; i++) {
+      const child = element.namedChild(i);
+      if (child.type === "jsx_text") {
+        const t = collapseWs(child.text).trim();
+        if (t) parts.push(t);
+      }
+    }
+    if (parts.length) return parts.join(" ");
+  }
+  return null;
+}
+function extractKnobs(filePath, code, lang) {
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  const tree = parser.parse(code);
+  if (!tree) return [];
+  const knobs = [];
+  for (const c of new Query(lang, ATTR_QUERY).captures(tree.rootNode)) {
+    if (c.name !== "attr") continue;
+    const event = c.node.namedChild(0)?.text;
+    if (!event || !event.startsWith("on")) continue;
+    const writes = storeWritesIn(c.node);
+    if (!writes.length) continue;
+    const opening = c.node.parent;
+    const byField = /* @__PURE__ */ new Map();
+    for (const w of writes) byField.set(w.field, { to: w.to, args: w.args });
+    const transitions = [...byField].map(([field, v]) => v.args !== void 0 ? { field, to: v.to, args: v.args } : { field, to: v.to });
+    knobs.push({
+      label: labelOf(opening),
+      tag: opening.childForFieldName("name")?.text ?? "?",
+      event,
+      transitions,
+      store: writes[0].store,
+      filePath,
+      line: c.node.startPosition.row + 1
+    });
+  }
+  return knobs;
+}
+function fmtTransitions(ts) {
+  return ts.map((t) => t.to ? `${t.field}=${t.to}` : t.field).join(", ");
+}
+function formatPanel(knobs) {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const k of knobs) {
+    const arr = byFile.get(k.filePath) ?? [];
+    arr.push(k);
+    byFile.set(k.filePath, arr);
+  }
+  const lines = [];
+  for (const [file, ks] of byFile) {
+    lines.push(file);
+    for (const k of ks) {
+      const name = k.label ? `\u300C${k.label}\u300D` : `<${k.tag}>`;
+      lines.push(`  ${name} ${k.event} \u2192 ${k.store}.{ ${fmtTransitions(k.transitions)} }  :${k.line}`);
+    }
+  }
+  return lines.join("\n");
+}
+function isIdentChar(ch) {
+  return ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "_" || ch === "$";
+}
+function isLiteral(to) {
+  if (to === "true" || to === "false" || to === "null") return true;
+  if (to.length >= 2) {
+    const q = to[0];
+    if ((q === "'" || q === '"' || q === "`") && to[to.length - 1] === q) {
+      for (let i = 1; i < to.length - 1; i++) {
+        if (to[i] === q && to[i - 1] !== "\\") return false;
+      }
+      return true;
+    }
+  }
+  let dot = 0;
+  for (let i = 0; i < to.length; i++) {
+    const ch = to[i];
+    if (ch === "-" && i === 0) continue;
+    if (ch === ".") {
+      dot++;
+      if (dot > 1) return false;
+      continue;
+    }
+    if (ch < "0" || ch > "9") return false;
+  }
+  return to.length > 0 && to !== "-" && to !== ".";
+}
+function isMemberPath(s) {
+  if (!s || s[0] === "." || s[s.length - 1] === ".") return false;
+  let prevDot = false;
+  for (const ch of s) {
+    if (ch === ".") {
+      if (prevDot) return false;
+      prevDot = true;
+      continue;
+    }
+    if (!isIdentChar(ch)) return false;
+    prevDot = false;
+  }
+  return true;
+}
+function isPlaceholder(to) {
+  if (!isMemberPath(to)) return false;
+  const segs = to.split(".");
+  if (segs.length > 2) return false;
+  if (segs[0].endsWith("Store")) return false;
+  return true;
+}
+function lastSeg(path) {
+  const i = path.lastIndexOf(".");
+  return i < 0 ? path : path.slice(i + 1);
+}
+function classifyTransition(t) {
+  const field = t.field;
+  const to = t.to;
+  if (field.endsWith("()")) {
+    if (t.args && t.args.length > 0)
+      return { field, kind: "context", arity: "nullary", reason: `\u65B9\u6CD5\u5E26\u53C2 ${field.slice(0, -2)}(${t.args})\uFF0C\u5B9E\u53C2\u4F9D\u8D56\u8FD0\u884C\u65F6\u4E0A\u4E0B\u6587` };
+    return { field, kind: "call", arity: "nullary" };
+  }
+  if (isLiteral(to)) return { field, kind: "assign", arity: "nullary", to };
+  if (to.startsWith("!")) {
+    const inner = to.slice(1);
+    if (isMemberPath(inner)) return { field: lastSeg(inner), kind: "toggle", arity: "nullary" };
+  }
+  if (isPlaceholder(to)) return { field, kind: "assign", arity: "param" };
+  let reason = "\u4F9D\u8D56\u8FD0\u884C\u65F6\u4E0A\u4E0B\u6587";
+  if (to.includes("e.target") || to.includes(".target.")) reason = "\u4F9D\u8D56\u4E8B\u4EF6\u5BF9\u8C61 e.target";
+  else if (to.includes(".filter(") || to.includes(".map(") || to.includes(".find(")) reason = "\u6570\u7EC4\u8FD0\u7B97,\u4F9D\u8D56\u5F53\u524D\u96C6\u5408";
+  else if (to.includes("...")) reason = "\u5C55\u5F00\u8FD0\u7B97\u7B26,\u4F9D\u8D56\u5F53\u524D\u5FEB\u7167";
+  else if (to.includes("=>")) reason = "\u503C\u662F\u7BAD\u5934\u51FD\u6570/\u95ED\u5305";
+  else if (to.includes("?") && to.includes(":")) reason = "\u4E09\u5143\u8868\u8FBE\u5F0F,\u4F9D\u8D56\u8FD0\u884C\u65F6\u5206\u652F";
+  else if (to.includes(".message") || to.includes(".id") || to.includes(".name")) reason = "\u8BFB\u8FD0\u884C\u65F6\u5BF9\u8C61\u5C5E\u6027";
+  return { field, kind: "context", arity: "nullary", reason };
+}
+function classifyKnob(transitions) {
+  const ops = transitions.map(classifyTransition);
+  const executable = ops.length > 0 && ops.every((o) => o.kind !== "context");
+  const arity = ops.some((o) => o.arity === "param") ? "param" : "nullary";
+  return { ops, arity, executable };
+}
+async function buildPanel(filePaths, contents) {
+  await Parser.init();
+  const tsx = await getLang(".tsx");
+  if (!tsx) return [];
+  const panel = [];
+  for (const fp of filePaths) {
+    if (!fp.endsWith(".tsx") && !fp.endsWith(".jsx")) continue;
+    let code;
+    if (contents?.has(fp)) code = contents.get(fp);
+    else {
+      try {
+        code = readFileSync(fp, "utf-8");
+      } catch {
+        continue;
+      }
+    }
+    panel.push(...extractKnobs(fp, code, tsx));
+  }
+  return panel;
+}
+
+// src/read/stategraph.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+import process from "process";
+import { Node as TsNode, SyntaxKind } from "ts-morph";
+async function openProject(cwd = process.cwd()) {
+  const { Project } = await import("ts-morph");
+  const tsConfigFilePath = ["tsconfig.app.json", "tsconfig.json"].map((f) => resolve(cwd, f)).find(existsSync);
+  if (!tsConfigFilePath)
+    throw new Error(`stategraph: no tsconfig.json (or tsconfig.app.json) found under ${cwd}`);
+  return new Project({ tsConfigFilePath });
+}
+function isModuleLevel(v) {
+  const stmt = v.getVariableStatement();
+  return !!stmt && stmt.getParent()?.getKind() === SyntaxKind.SourceFile;
+}
+var DEFAULT_STORE_MARKER = "_loading";
+function isStateFactory(v, marker) {
+  const init = v.getInitializer();
+  if (!init || !TsNode.isCallExpression(init))
+    return false;
+  return !!v.getType().getProperty(marker);
+}
+function classify(v, marker = DEFAULT_STORE_MARKER) {
+  const init = v.getInitializer();
+  if (!init)
+    return null;
+  const k = init.getKind();
+  if (k === SyntaxKind.ArrowFunction || k === SyntaxKind.FunctionExpression || k === SyntaxKind.ClassExpression)
+    return "view";
+  if (isStateFactory(v, marker))
+    return "state";
+  return null;
+}
+function fieldOf(pa) {
+  if (!TsNode.isPropertyAssignment(pa))
+    return null;
+  const valueInit = pa.getInitializer();
+  if (!valueInit)
+    return null;
+  const init = TsNode.isAsExpression(valueInit) ? valueInit.getExpression().getText() : valueInit.getText();
+  const t = valueInit.getType();
+  const domain = t.isUnion() ? t.getUnionTypes().filter((u) => u.isStringLiteral()).map((u) => u.getLiteralValue()) : [];
+  return { name: pa.getName(), init, type: t.getText(valueInit), domain, line: pa.getStartLineNumber() };
+}
+function resolveStateObject(arg) {
+  if (TsNode.isObjectLiteralExpression(arg))
+    return arg;
+  if (TsNode.isIdentifier(arg)) {
+    const decl = arg.getSymbol()?.getDeclarations()?.[0];
+    if (decl && TsNode.isVariableDeclaration(decl)) {
+      const di = decl.getInitializer();
+      if (di && TsNode.isObjectLiteralExpression(di))
+        return di;
+    }
+  }
+  return null;
+}
+function extractStoreFields(v, marker = DEFAULT_STORE_MARKER) {
+  if (!isStateFactory(v, marker))
+    return [];
+  const init = v.getInitializer();
+  if (!TsNode.isCallExpression(init))
+    return [];
+  const arg = init.getArguments()[0];
+  const stateObj = arg && resolveStateObject(arg);
+  if (!stateObj || !TsNode.isObjectLiteralExpression(stateObj))
+    return [];
+  const out = [];
+  for (const pa of stateObj.getProperties()) {
+    const f = fieldOf(pa);
+    if (f)
+      out.push(f);
+  }
+  return out;
+}
+function growFromDecl(v, file, marker = DEFAULT_STORE_MARKER) {
+  const fields = extractStoreFields(v, marker).map((f) => ({
+    name: f.name,
+    type: f.type,
+    domain: f.domain,
+    line: f.line
+  }));
+  return {
+    store: v.getName(),
+    anchor: `${file}:${v.getStartLineNumber()}`,
+    fields
+  };
+}
+function buildStateGraph(project, fileFor = (p) => p.split("/").slice(-2).join("/"), marker = DEFAULT_STORE_MARKER) {
+  const nodes = [];
+  for (const sf of project.getSourceFiles()) {
+    const fp = sf.getFilePath();
+    if (fp.endsWith(".d.ts") || fp.includes("/node_modules/"))
+      continue;
+    const file = fileFor(fp);
+    for (const v of sf.getVariableDeclarations()) {
+      if (!isModuleLevel(v) || classify(v, marker) !== "state")
+        continue;
+      const grown = growFromDecl(v, file, marker);
+      const seen = /* @__PURE__ */ new Set();
+      let refs = 0;
+      try {
+        for (const ref of v.findReferencesAsNodes()) {
+          refs++;
+          seen.add(ref.getSourceFile().getFilePath());
+        }
+      } catch {
+      }
+      nodes.push({ ...grown, refs, files: seen.size, rank: refs + seen.size * 3 });
+    }
+  }
+  nodes.sort((a, b) => b.rank - a.rank);
+  return { nodes };
+}
+
+export {
+  extractKnobs,
+  fmtTransitions,
+  formatPanel,
+  classifyKnob,
+  buildPanel,
+  openProject,
+  classify,
+  extractStoreFields,
+  growFromDecl,
+  buildStateGraph
+};

package/dist/chunk-GNEUSRGP.js

@@ -0,0 +1,52 @@
+// src/read/scan.ts
+import { existsSync, readFileSync } from "fs";
+import { globSync } from "glob";
+import ignore from "ignore";
+function rootPriority(name) {
+  if (name === "package.json")
+    return 0;
+  if (name.endsWith(".html"))
+    return 1;
+  if (name.startsWith("tsconfig"))
+    return 2;
+  if (name.startsWith(".env"))
+    return 3;
+  return 4;
+}
+var hasGlob = (p) => p.includes("*") || p.includes("?") || p.includes("{") || p.includes("[");
+function filterAndSort(matched, gitignoreText, config, existingExplicit) {
+  const ig = ignore();
+  if (gitignoreText)
+    ig.add(gitignoreText);
+  if (config.read.ignore.length)
+    ig.add(config.read.ignore);
+  const explicit = new Set(existingExplicit);
+  return matched.filter((f) => explicit.has(f) || !ig.ignores(f)).sort((a, b) => {
+    const aRoot = !a.includes("/");
+    const bRoot = !b.includes("/");
+    if (aRoot !== bRoot)
+      return aRoot ? -1 : 1;
+    if (aRoot) {
+      const pa = rootPriority(a);
+      const pb = rootPriority(b);
+      if (pa !== pb)
+        return pa - pb;
+    }
+    return a.localeCompare(b);
+  });
+}
+function scan(config) {
+  const matched = globSync(config.read.include, {
+    nodir: true,
+    dot: true,
+    ignore: ["**/node_modules/**"]
+  });
+  const gitignoreText = existsSync(".gitignore") ? readFileSync(".gitignore", "utf-8") : "";
+  const existingExplicit = config.read.include.filter((p) => !hasGlob(p) && existsSync(p));
+  return filterAndSort(matched, gitignoreText, config, existingExplicit);
+}
+
+export {
+  filterAndSort,
+  scan
+};

package/dist/chunk-IGNEAOLT.cjs

@@ -0,0 +1,130 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkZ2Y65YOYcjs = require('./chunk-Z2Y65YOY.cjs');
+
+// src/read/config.ts
+var _fs = require('fs');
+var _path = require('path');
+var _url = require('url');
+var _jiti = require('jiti');
+
+// src/read/types.ts
+var READ_DEFAULTS = {
+  include: [
+    "package.json",
+    "index.html",
+    "tsconfig.json",
+    "tsconfig.*.json",
+    "*.config.{js,ts,mjs,cjs}"
+  ],
+  ignore: [],
+  fileDetailLevel: {
+    "package-lock.json": "tree",
+    "pnpm-lock.yaml": "tree",
+    "yarn.lock": "tree",
+    "bun.lock": "tree",
+    "**/*.test.ts": "tree",
+    "**/*.test.tsx": "tree",
+    "**/*.spec.ts": "tree",
+    "**/*.spec.tsx": "tree"
+  },
+  injectDetailLevel: "tree",
+  injectTargetFiles: ["CLAUDE.md", "AGENTS.md"],
+  showNoParamFn: false,
+  treeFoldThreshold: 8,
+  injectDevToolInstructions: true,
+  injectCodemap: true,
+  maxTokens: 5e3
+};
+var DEFAULT_CONFIG = {
+  read: { enabled: true, ...READ_DEFAULTS },
+  refactor: { enabled: true },
+  runtime: { enabled: true, storeMarker: "_loading" }
+};
+function resolveModule(sw, defaults) {
+  if (sw === false)
+    return { enabled: false, ...defaults };
+  if (sw === void 0 || sw === true)
+    return { enabled: true, ...defaults };
+  return { enabled: true, ...defaults, ...sw };
+}
+function defineConfig(config) {
+  return config;
+}
+function configTemplate() {
+  return `    // aihand = three capability modules. Each: true (on, defaults) \xB7 false (off) \xB7 { ...overrides }.
+    // Most repos only need the three switches below \u2014 tuning knobs have smart defaults.
+
+    // Codemap injection into CLAUDE.md/AGENTS.md
+    read: true,
+    // AST refactor commands (move-file / rename / move-symbol)
+    refactor: true,
+    // Inspect & drive the running app (runtime browser probe \u2014 needs the vite plugin);
+    // set false on repos without a dev server.
+    // Non-MobX store factory? runtime: { storeMarker: 'getState' } \u2014 the reactive
+    // fingerprint field on the store's return type (zustand 'getState', default '_loading').
+    runtime: true,
+
+    // Need to tune read? Open it up (all optional, shown with defaults):
+    // read: {
+    //   include: ['src/**'],          // what to scan (root config files always included)
+    //   ignore: [],                    // extra skips (.gitignore already applied)
+    //   maxTokens: 5_000,              // budget \u2014 auto-downgrades less important files
+    //   injectCodemap: true,           // false \u2192 Overview + a pointer to \`aihand read --stdout\`
+    // },`;
+}
+
+// src/read/config.ts
+var CONFIG_PATH = "aihand.config.ts";
+var SELF_PATH = _url.fileURLToPath.call(void 0, _chunkZ2Y65YOYcjs.importMetaUrl);
+var TS_EXTS = [".ts", ".tsx", ".js", ".jsx"];
+var isTsFile = (p) => TS_EXTS.some((ext) => p.endsWith(ext));
+async function loadConfig(root = _path.resolve.call(void 0, ".")) {
+  const configFile = _path.join.call(void 0, root, CONFIG_PATH);
+  if (!_fs.existsSync.call(void 0, configFile))
+    return DEFAULT_CONFIG;
+  const selfDir = _path.dirname.call(void 0, SELF_PATH);
+  const aihandIndex = _nullishCoalesce([_path.join.call(void 0, selfDir, "index.js"), _path.resolve.call(void 0, selfDir, "../index.ts")].find(_fs.existsSync), () => ( _path.join.call(void 0, selfDir, "index.js")));
+  const jiti = _jiti.createJiti.call(void 0, root, {
+    alias: { aihand: aihandIndex },
+    moduleCache: false,
+    fsCache: false
+  });
+  const mod = await jiti.import(configFile);
+  const raw = _nullishCoalesce(mod.default, () => ( mod));
+  return normalizeConfig(raw);
+}
+function normalizeConfig(raw) {
+  const read = resolveModule(raw.read, {});
+  const d = DEFAULT_CONFIG.read;
+  return {
+    read: {
+      enabled: read.enabled,
+      include: [...d.include, ..._nullishCoalesce(read.include, () => ( ["src/**"]))],
+      ignore: _nullishCoalesce(read.ignore, () => ( d.ignore)),
+      fileDetailLevel: { ...d.fileDetailLevel, ...read.fileDetailLevel },
+      injectDetailLevel: _nullishCoalesce(read.injectDetailLevel, () => ( d.injectDetailLevel)),
+      injectTargetFiles: _nullishCoalesce(read.injectTargetFiles, () => ( d.injectTargetFiles)),
+      injectDevToolInstructions: _nullishCoalesce(read.injectDevToolInstructions, () => ( d.injectDevToolInstructions)),
+      injectCodemap: _nullishCoalesce(read.injectCodemap, () => ( d.injectCodemap)),
+      showNoParamFn: _nullishCoalesce(read.showNoParamFn, () => ( d.showNoParamFn)),
+      treeFoldThreshold: _nullishCoalesce(read.treeFoldThreshold, () => ( d.treeFoldThreshold)),
+      maxTokens: typeof read.maxTokens === "number" ? read.maxTokens : d.maxTokens
+    },
+    refactor: { enabled: raw.refactor !== false },
+    runtime: (() => {
+      const r = resolveModule(raw.runtime, {});
+      return { enabled: r.enabled, storeMarker: _nullishCoalesce(r.storeMarker, () => ( "_loading")) };
+    })()
+  };
+}
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG; exports.defineConfig = defineConfig; exports.configTemplate = configTemplate; exports.CONFIG_PATH = CONFIG_PATH; exports.isTsFile = isTsFile; exports.loadConfig = loadConfig; exports.normalizeConfig = normalizeConfig;

package/dist/chunk-IS5XFUDB.js

@@ -0,0 +1,125 @@
+import {
+  getLang
+} from "./chunk-OWYK2IGV.js";
+
+// src/read/graph.ts
+import { readFileSync } from "fs";
+import { Parser, Query } from "web-tree-sitter";
+var DEFS_QUERY = `
+(function_declaration name: (identifier) @name) @def
+(generator_function_declaration name: (identifier) @name) @def
+(class_declaration name: (type_identifier) @name) @def
+(method_definition name: (property_identifier) @name) @def
+(variable_declarator name: (identifier) @name value: (arrow_function)) @def
+`;
+var CALLS_QUERY = `
+(call_expression function: (identifier) @callee)
+(call_expression function: (member_expression property: (property_identifier) @callee))
+(new_expression constructor: (identifier) @callee)
+`;
+function extractFileGraph(code, parser, defsQuery, callsQuery) {
+  const tree = parser.parse(code);
+  if (!tree)
+    return { defs: [], attributed: [] };
+  const defs = [];
+  for (const match of defsQuery.matches(tree.rootNode)) {
+    const defCapture = match.captures.find((c) => c.name === "def");
+    const nameCapture = match.captures.find((c) => c.name === "name");
+    if (!defCapture || !nameCapture)
+      continue;
+    const KIND_MAP = {
+      class_declaration: "class",
+      method_definition: "method"
+    };
+    const kind = KIND_MAP[defCapture.node.type] ?? "function";
+    defs.push({
+      name: nameCapture.node.text,
+      kind,
+      startLine: defCapture.node.startPosition.row,
+      endLine: defCapture.node.endPosition.row
+    });
+  }
+  const rawCalls = [];
+  for (const { node } of callsQuery.captures(tree.rootNode))
+    rawCalls.push({ callee: node.text, row: node.startPosition.row });
+  const attributed = [];
+  for (const call of rawCalls) {
+    let best = null;
+    let bestSize = Infinity;
+    for (const def of defs) {
+      if (call.row >= def.startLine && call.row <= def.endLine) {
+        const size = def.endLine - def.startLine;
+        if (size < bestSize) {
+          best = def;
+          bestSize = size;
+        }
+      }
+    }
+    if (best)
+      attributed.push({ callerDef: best, callee: call.callee });
+  }
+  tree.delete();
+  return { defs, attributed };
+}
+async function buildCallGraph(filePaths, contents) {
+  await Parser.init();
+  const parser = new Parser();
+  let lang = null;
+  for (const fp of filePaths) {
+    const ext = fp.slice(fp.lastIndexOf("."));
+    lang = await getLang(ext);
+    if (lang)
+      break;
+  }
+  if (!lang)
+    return { symbols: {}, out: {}, in: {} };
+  parser.setLanguage(lang);
+  const defsQuery = new Query(lang, DEFS_QUERY);
+  const callsQuery = new Query(lang, CALLS_QUERY);
+  const symbols = {};
+  const nameToUids = /* @__PURE__ */ new Map();
+  const fileGraphs = [];
+  for (const filePath of filePaths) {
+    let code;
+    if (contents?.has(filePath)) {
+      code = contents.get(filePath);
+    } else {
+      try {
+        code = readFileSync(filePath, "utf-8");
+      } catch {
+        continue;
+      }
+    }
+    const { defs, attributed } = extractFileGraph(code, parser, defsQuery, callsQuery);
+    for (const def of defs) {
+      const uid = `${filePath}::${def.name}:${def.startLine}`;
+      symbols[uid] = { uid, name: def.name, kind: def.kind, filePath, startLine: def.startLine, endLine: def.endLine };
+      if (!nameToUids.has(def.name))
+        nameToUids.set(def.name, []);
+      nameToUids.get(def.name).push(uid);
+    }
+    fileGraphs.push({ filePath, attributed });
+  }
+  const outSets = {};
+  const inSets = {};
+  for (const { filePath, attributed } of fileGraphs) {
+    for (const { callerDef, callee } of attributed) {
+      const callerUid = `${filePath}::${callerDef.name}:${callerDef.startLine}`;
+      for (const calleeUid of nameToUids.get(callee) ?? []) {
+        ;
+        (outSets[callerUid] ??= /* @__PURE__ */ new Set()).add(calleeUid);
+        (inSets[calleeUid] ??= /* @__PURE__ */ new Set()).add(callerUid);
+      }
+    }
+  }
+  const out = Object.fromEntries(Object.entries(outSets).map(([k, v]) => [k, [...v]]));
+  const inEdges = Object.fromEntries(Object.entries(inSets).map(([k, v]) => [k, [...v]]));
+  defsQuery.delete();
+  callsQuery.delete();
+  parser.delete();
+  return { symbols, out, in: inEdges };
+}
+
+export {
+  buildCallGraph
+};