flavor-code 1.2.11 → 1.2.13

package/dist/astgraph/query.mjs

@@ -0,0 +1,165 @@
+// astgraph query layer — anchor search, K-hop traversal, blast radius and
+// subgraph context assembly. All coordinates are 1-based to match Read/editor use.
+
+const NODE_FIELDS = "id, kind, name, qualified_name, file_path, language, start_line, end_line, signature, docstring, is_exported, is_async";
+
+function mapNode(row) {
+  if (row === undefined) return undefined;
+  return {
+    id: row.id, kind: row.kind, name: row.name, qualifiedName: row.qualified_name,
+    filePath: row.file_path, language: row.language,
+    startLine: row.start_line, endLine: row.end_line,
+    signature: row.signature ?? undefined, docstring: row.docstring ?? undefined,
+    isExported: row.is_exported === 1, isAsync: row.is_async === 1,
+  };
+}
+
+/** Fetch one node by id, or undefined. */
+export function getNode(db, id) {
+  return mapNode(db.prepare(`SELECT ${NODE_FIELDS} FROM nodes WHERE id = ?`).get(id));
+}
+
+/** Split camelCase/PascalCase/snake_case identifiers into lowercase word segments. */
+export function identifierSegments(name) {
+  return name
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .split(/[^A-Za-z0-9]+/)
+    .filter(Boolean)
+    .map((segment) => segment.toLowerCase());
+}
+
+function queryWords(query) {
+  return query
+    .toLowerCase()
+    .split(/[^a-z0-9]+/)
+    .filter((word) => word.length > 0);
+}
+
+/**
+ * Anchor search: FTS5 first (prefix-matched terms), then identifier-segment
+ * matching so natural-language words ("order cancel") hit camelCase symbols.
+ * Returns scored node records, best first.
+ */
+export function search(db, query, { limit = 20 } = {}) {
+  const words = queryWords(query);
+  if (words.length === 0) return [];
+
+  const scored = new Map();
+
+  // FTS pass — each query word as a prefix term.
+  try {
+    const match = words.map((word) => `${word}*`).join(" ");
+    const rows = db.prepare(`
+      SELECT n.${NODE_FIELDS.split(", ").join(", n.")}, rank
+      FROM nodes_fts
+      JOIN nodes n ON n.rowid = nodes_fts.rowid
+      WHERE nodes_fts MATCH ?
+      ORDER BY rank LIMIT ?
+    `).all(match, limit * 2);
+    for (const row of rows) scored.set(row.id, { node: mapNode(row), score: 100 - Math.min(50, Math.max(0, row.rank)) });
+  } catch { /* Invalid MATCH syntax falls through to segment matching. */ }
+
+  // Segment pass — words of the query appear as camelCase segments of node names.
+  const candidates = db.prepare(`SELECT ${NODE_FIELDS} FROM nodes`).all();
+  for (const row of candidates) {
+    const segments = identifierSegments(row.name).concat(identifierSegments(row.qualified_name));
+    const matched = words.filter((word) => segments.some((segment) => segment === word || segment.startsWith(word)));
+    if (matched.length === 0) continue;
+    const score = matched.length * 25 + (matched.length === words.length ? 20 : 0);
+    const existing = scored.get(row.id);
+    if (existing === undefined || existing.score < score) {
+      scored.set(row.id, { node: mapNode(row), score });
+    }
+  }
+
+  return [...scored.values()]
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map((entry) => entry.node);
+}
+
+/** Nodes that call the target (reverse call edges). */
+export function callers(db, id) {
+  return db.prepare(`
+    SELECT DISTINCT n.${NODE_FIELDS.split(", ").join(", n.")}
+    FROM edges e JOIN nodes n ON n.id = e.source
+    WHERE e.target = ? AND e.kind IN ('calls', 'imports')
+  `).all(id).map(mapNode);
+}
+
+/** Nodes the target calls (forward call edges). */
+export function callees(db, id) {
+  return db.prepare(`
+    SELECT DISTINCT n.${NODE_FIELDS.split(", ").join(", n.")}
+    FROM edges e JOIN nodes n ON n.id = e.target
+    WHERE e.source = ? AND e.kind IN ('calls', 'imports')
+  `).all(id).map(mapNode);
+}
+
+/**
+ * K-hop blast radius from a node.
+ *   direction "up"   — who depends on me (callers chain)
+ *   direction "down" — what I depend on (callees chain)
+ *   direction "both" — union
+ */
+export function impact(db, id, { hops = 2, direction = "up", limit = 200 } = {}) {
+  const visited = new Map();
+  const frontier = [id];
+  for (let hop = 1; hop <= hops && frontier.length > 0; hop += 1) {
+    const next = [];
+    for (const current of frontier) {
+      let rows = [];
+      if (direction === "up" || direction === "both") {
+        rows = rows.concat(db.prepare("SELECT source AS other FROM edges WHERE target = ?").all(current));
+      }
+      if (direction === "down" || direction === "both") {
+        rows = rows.concat(db.prepare("SELECT target AS other FROM edges WHERE source = ?").all(current));
+      }
+      for (const row of rows) {
+        if (row.other === id || visited.has(row.other)) continue;
+        visited.set(row.other, hop);
+        next.push(row.other);
+        if (visited.size >= limit) break;
+      }
+      if (visited.size >= limit) break;
+    }
+    frontier.length = 0;
+    frontier.push(...next);
+  }
+  const nodes = [...visited.entries()]
+    .map(([nodeId, hop]) => ({ ...getNode(db, nodeId), hop }))
+    .filter((node) => node.name !== undefined)
+    .sort((a, b) => a.hop - b.hop);
+  return { origin: getNode(db, id), nodes, hops };
+}
+
+/**
+ * Subgraph context assembly: the anchor plus its K-hop callers and callees,
+ * rendered as precise file:start-end read ranges for the agent.
+ */
+export function subgraphContext(db, id, { hops = 1, limit = 50 } = {}) {
+  const origin = getNode(db, id);
+  if (origin === undefined) return { anchor: undefined, context: [] };
+
+  const result = impact(db, id, { hops, direction: "both", limit });
+  const seen = new Map([[origin.filePath, origin]]);
+  const entries = [origin, ...result.nodes];
+  for (const node of entries) {
+    const existing = seen.get(node.filePath);
+    if (existing === undefined || node.startLine < existing.startLine) {
+      // Prefer the widest node per file only when ranges are identical; otherwise
+      // keep each node individually below.
+      seen.set(node.filePath, node);
+    }
+  }
+
+  const context = entries
+    .map((node) => ({
+      nodeId: node.id, name: node.name, kind: node.kind,
+      filePath: node.filePath, startLine: node.startLine, endLine: node.endLine,
+      signature: node.signature, docstring: node.docstring,
+    }))
+    .sort((a, b) => a.filePath.localeCompare(b.filePath) || a.startLine - b.startLine);
+
+  return { anchor: origin, context };
+}

package/dist/astgraph/resolve.mjs

@@ -0,0 +1,93 @@
+// astgraph import resolution — maps module specifiers to workspace files and
+// turns pending unresolved references into concrete graph edges.
+
+import { posix } from "node:path";
+
+/** Candidate extensions tried for extensionless imports, in priority order. */
+const EXTENSION_CANDIDATES = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+
+/**
+ * Rewrite a `.js`/`.jsx` specifier to a TypeScript candidate (ESM-style TS code
+ * frequently imports "./util.js" while the source file is util.ts).
+ */
+function rebaseExtension(specifier) {
+  if (specifier.endsWith(".js")) return `${specifier.slice(0, -3)}.ts`;
+  if (specifier.endsWith(".jsx")) return `${specifier.slice(0, -4)}.tsx`;
+  if (specifier.endsWith(".mjs")) return `${specifier.slice(0, -4)}.mts`;
+  if (specifier.endsWith(".cjs")) return `${specifier.slice(0, -4)}.cts`;
+  return undefined;
+}
+
+function normalizePath(fromFile, specifier) {
+  const fromDir = posix.dirname(fromFile.split(/[/\\]/).join("/"));
+  return posix.normalize(posix.join(fromDir, specifier.split(/[/\\]/).join("/")));
+}
+
+/**
+ * Resolve an import specifier to a workspace-relative file path.
+ * Only relative specifiers are resolved; bare package imports return undefined.
+ * `exists(path)` is a predicate over workspace-relative paths.
+ */
+export function resolveImportPath(fromFile, specifier, exists) {
+  if (specifier === undefined) return undefined;
+  if (!specifier.startsWith("./") && !specifier.startsWith("../") && !specifier.startsWith("/")) return undefined;
+  const base = normalizePath(fromFile, specifier);
+
+  const direct = exists(base) ? base : undefined;
+  if (direct !== undefined) return direct;
+
+  const rebased = rebaseExtension(specifier);
+  if (rebased !== undefined) {
+    const candidate = normalizePath(fromFile, rebased);
+    if (exists(candidate)) return candidate;
+  }
+
+  for (const ext of EXTENSION_CANDIDATES) {
+    const candidate = base + ext;
+    if (exists(candidate)) return candidate;
+  }
+
+  for (const ext of EXTENSION_CANDIDATES) {
+    const candidate = posix.join(base, `index${ext}`);
+    if (exists(candidate)) return candidate;
+  }
+
+  return undefined;
+}
+
+/** Kept for API symmetry with codegraph-style resolution; thin wrapper. */
+export function resolveModulePath(fromFile, specifier, exists) {
+  return resolveImportPath(fromFile, specifier, exists);
+}
+
+/**
+ * Match pending references against the exported nodes of their target files.
+ *
+ * @param {Array<object>} refs unresolved_refs rows (from the database)
+ * @param {Map<string, Array<{id: string, name: string, isExported: boolean}>>} nodesByFile
+ * @param {(path: string) => boolean} exists workspace-relative file predicate
+ * @returns {{ edges: Array<object>, resolvedIds: number[] }}
+ */
+export function resolveRefs(refs, nodesByFile, exists) {
+  const edges = [];
+  const resolvedIds = [];
+
+  for (const ref of refs) {
+    if (ref.moduleSpecifier === undefined) continue;
+    const targetFile = resolveImportPath(ref.filePath, ref.moduleSpecifier, exists);
+    if (targetFile === undefined) continue;
+    const candidates = nodesByFile.get(targetFile) ?? [];
+    const match = candidates.find((node) => node.name === ref.referenceName && node.isExported);
+    if (match === undefined) continue;
+
+    const kind = ref.referenceKind === "import"
+      ? "imports"
+      : ref.referenceKind === "extends" || ref.referenceKind === "implements"
+        ? ref.referenceKind
+        : "calls";
+    edges.push({ source: ref.fromNodeId, target: match.id, kind, line: ref.line, col: ref.col });
+    resolvedIds.push(ref.id);
+  }
+
+  return { edges, resolvedIds };
+}