@optave/codegraph 3.1.3 → 3.1.5

package/src/db/repository/sqlite-repository.js

@@ -0,0 +1,219 @@
+import { Repository } from './base.js';
+import { hasCfgTables } from './cfg.js';
+import { getComplexityForNode } from './complexity.js';
+import { hasDataflowTable } from './dataflow.js';
+import {
+  countCrossFileCallers,
+  findAllIncomingEdges,
+  findAllOutgoingEdges,
+  findCalleeNames,
+  findCallees,
+  findCallerNames,
+  findCallers,
+  findCrossFileCallTargets,
+  findDistinctCallers,
+  findImportDependents,
+  findImportSources,
+  findImportTargets,
+  findIntraFileCallEdges,
+  getClassHierarchy,
+} from './edges.js';
+import { hasEmbeddings } from './embeddings.js';
+import { getCallableNodes, getCallEdges, getFileNodesAll, getImportEdges } from './graph-read.js';
+import {
+  bulkNodeIdsByFile,
+  countEdges,
+  countFiles,
+  countNodes,
+  findFileNodes,
+  findNodeById,
+  findNodeByQualifiedName,
+  findNodeChildren,
+  findNodesByFile,
+  findNodesByScope,
+  findNodesForTriage,
+  findNodesWithFanIn,
+  getFunctionNodeId,
+  getNodeId,
+  iterateFunctionNodes,
+  listFunctionNodes,
+} from './nodes.js';
+
+/**
+ * SqliteRepository — wraps existing `fn(db, ...)` repository functions
+ * behind the Repository interface so callers can use `repo.method(...)`.
+ */
+export class SqliteRepository extends Repository {
+  #db;
+
+  /** @param {object} db - better-sqlite3 Database instance */
+  constructor(db) {
+    super();
+    this.#db = db;
+  }
+
+  /** Expose the underlying db for code that still needs raw access. */
+  get db() {
+    return this.#db;
+  }
+
+  // ── Node lookups ──────────────────────────────────────────────────
+
+  findNodeById(id) {
+    return findNodeById(this.#db, id);
+  }
+
+  findNodesByFile(file) {
+    return findNodesByFile(this.#db, file);
+  }
+
+  findFileNodes(fileLike) {
+    return findFileNodes(this.#db, fileLike);
+  }
+
+  findNodesWithFanIn(namePattern, opts) {
+    return findNodesWithFanIn(this.#db, namePattern, opts);
+  }
+
+  countNodes() {
+    return countNodes(this.#db);
+  }
+
+  countEdges() {
+    return countEdges(this.#db);
+  }
+
+  countFiles() {
+    return countFiles(this.#db);
+  }
+
+  getNodeId(name, kind, file, line) {
+    return getNodeId(this.#db, name, kind, file, line);
+  }
+
+  getFunctionNodeId(name, file, line) {
+    return getFunctionNodeId(this.#db, name, file, line);
+  }
+
+  bulkNodeIdsByFile(file) {
+    return bulkNodeIdsByFile(this.#db, file);
+  }
+
+  findNodeChildren(parentId) {
+    return findNodeChildren(this.#db, parentId);
+  }
+
+  findNodesByScope(scopeName, opts) {
+    return findNodesByScope(this.#db, scopeName, opts);
+  }
+
+  findNodeByQualifiedName(qualifiedName, opts) {
+    return findNodeByQualifiedName(this.#db, qualifiedName, opts);
+  }
+
+  listFunctionNodes(opts) {
+    return listFunctionNodes(this.#db, opts);
+  }
+
+  iterateFunctionNodes(opts) {
+    return iterateFunctionNodes(this.#db, opts);
+  }
+
+  findNodesForTriage(opts) {
+    return findNodesForTriage(this.#db, opts);
+  }
+
+  // ── Edge queries ──────────────────────────────────────────────────
+
+  findCallees(nodeId) {
+    return findCallees(this.#db, nodeId);
+  }
+
+  findCallers(nodeId) {
+    return findCallers(this.#db, nodeId);
+  }
+
+  findDistinctCallers(nodeId) {
+    return findDistinctCallers(this.#db, nodeId);
+  }
+
+  findAllOutgoingEdges(nodeId) {
+    return findAllOutgoingEdges(this.#db, nodeId);
+  }
+
+  findAllIncomingEdges(nodeId) {
+    return findAllIncomingEdges(this.#db, nodeId);
+  }
+
+  findCalleeNames(nodeId) {
+    return findCalleeNames(this.#db, nodeId);
+  }
+
+  findCallerNames(nodeId) {
+    return findCallerNames(this.#db, nodeId);
+  }
+
+  findImportTargets(nodeId) {
+    return findImportTargets(this.#db, nodeId);
+  }
+
+  findImportSources(nodeId) {
+    return findImportSources(this.#db, nodeId);
+  }
+
+  findImportDependents(nodeId) {
+    return findImportDependents(this.#db, nodeId);
+  }
+
+  findCrossFileCallTargets(file) {
+    return findCrossFileCallTargets(this.#db, file);
+  }
+
+  countCrossFileCallers(nodeId, file) {
+    return countCrossFileCallers(this.#db, nodeId, file);
+  }
+
+  getClassHierarchy(classNodeId) {
+    return getClassHierarchy(this.#db, classNodeId);
+  }
+
+  findIntraFileCallEdges(file) {
+    return findIntraFileCallEdges(this.#db, file);
+  }
+
+  // ── Graph-read queries ────────────────────────────────────────────
+
+  getCallableNodes() {
+    return getCallableNodes(this.#db);
+  }
+
+  getCallEdges() {
+    return getCallEdges(this.#db);
+  }
+
+  getFileNodesAll() {
+    return getFileNodesAll(this.#db);
+  }
+
+  getImportEdges() {
+    return getImportEdges(this.#db);
+  }
+
+  // ── Optional table checks ─────────────────────────────────────────
+
+  hasCfgTables() {
+    return hasCfgTables(this.#db);
+  }
+
+  hasEmbeddings() {
+    return hasEmbeddings(this.#db);
+  }
+
+  hasDataflowTable() {
+    return hasDataflowTable(this.#db);
+  }
+
+  getComplexityForNode(nodeId) {
+    return getComplexityForNode(this.#db, nodeId);
+  }
+}

package/src/domain/analysis/context.js

@@ -0,0 +1,408 @@
+import path from 'node:path';
+import {
+  findCallees,
+  findCallers,
+  findCrossFileCallTargets,
+  findDbPath,
+  findFileNodes,
+  findImportSources,
+  findImportTargets,
+  findIntraFileCallEdges,
+  findNodeChildren,
+  findNodesByFile,
+  getComplexityForNode,
+  openReadonlyOrFail,
+} from '../../db/index.js';
+import { isTestFile } from '../../infrastructure/test-filter.js';
+import {
+  createFileLinesReader,
+  extractSignature,
+  extractSummary,
+  isFileLikeTarget,
+  readSourceRange,
+} from '../../shared/file-utils.js';
+import { resolveMethodViaHierarchy } from '../../shared/hierarchy.js';
+import { normalizeSymbol } from '../../shared/normalize.js';
+import { paginateResult } from '../../shared/paginate.js';
+import { findMatchingNodes } from './symbol-lookup.js';
+
+function explainFileImpl(db, target, getFileLines) {
+  const fileNodes = findFileNodes(db, `%${target}%`);
+  if (fileNodes.length === 0) return [];
+
+  return fileNodes.map((fn) => {
+    const symbols = findNodesByFile(db, fn.file);
+
+    // IDs of symbols that have incoming calls from other files (public)
+    const publicIds = findCrossFileCallTargets(db, fn.file);
+
+    const fileLines = getFileLines(fn.file);
+    const mapSymbol = (s) => ({
+      name: s.name,
+      kind: s.kind,
+      line: s.line,
+      role: s.role || null,
+      summary: fileLines ? extractSummary(fileLines, s.line) : null,
+      signature: fileLines ? extractSignature(fileLines, s.line) : null,
+    });
+
+    const publicApi = symbols.filter((s) => publicIds.has(s.id)).map(mapSymbol);
+    const internal = symbols.filter((s) => !publicIds.has(s.id)).map(mapSymbol);
+
+    // Imports / importedBy
+    const imports = findImportTargets(db, fn.id).map((r) => ({ file: r.file }));
+
+    const importedBy = findImportSources(db, fn.id).map((r) => ({ file: r.file }));
+
+    // Intra-file data flow
+    const intraEdges = findIntraFileCallEdges(db, fn.file);
+
+    const dataFlowMap = new Map();
+    for (const edge of intraEdges) {
+      if (!dataFlowMap.has(edge.caller_name)) dataFlowMap.set(edge.caller_name, []);
+      dataFlowMap.get(edge.caller_name).push(edge.callee_name);
+    }
+    const dataFlow = [...dataFlowMap.entries()].map(([caller, callees]) => ({
+      caller,
+      callees,
+    }));
+
+    // Line count: prefer node_metrics (actual), fall back to MAX(end_line)
+    const metric = db
+      .prepare(`SELECT nm.line_count FROM node_metrics nm WHERE nm.node_id = ?`)
+      .get(fn.id);
+    let lineCount = metric?.line_count || null;
+    if (!lineCount) {
+      const maxLine = db
+        .prepare(`SELECT MAX(end_line) as max_end FROM nodes WHERE file = ?`)
+        .get(fn.file);
+      lineCount = maxLine?.max_end || null;
+    }
+
+    return {
+      file: fn.file,
+      lineCount,
+      symbolCount: symbols.length,
+      publicApi,
+      internal,
+      imports,
+      importedBy,
+      dataFlow,
+    };
+  });
+}
+
+function explainFunctionImpl(db, target, noTests, getFileLines) {
+  let nodes = db
+    .prepare(
+      `SELECT * FROM nodes WHERE name LIKE ? AND kind IN ('function','method','class','interface','type','struct','enum','trait','record','module') ORDER BY file, line`,
+    )
+    .all(`%${target}%`);
+  if (noTests) nodes = nodes.filter((n) => !isTestFile(n.file));
+  if (nodes.length === 0) return [];
+
+  const hc = new Map();
+  return nodes.slice(0, 10).map((node) => {
+    const fileLines = getFileLines(node.file);
+    const lineCount = node.end_line ? node.end_line - node.line + 1 : null;
+    const summary = fileLines ? extractSummary(fileLines, node.line) : null;
+    const signature = fileLines ? extractSignature(fileLines, node.line) : null;
+
+    const callees = findCallees(db, node.id).map((c) => ({
+      name: c.name,
+      kind: c.kind,
+      file: c.file,
+      line: c.line,
+    }));
+
+    let callers = findCallers(db, node.id).map((c) => ({
+      name: c.name,
+      kind: c.kind,
+      file: c.file,
+      line: c.line,
+    }));
+    if (noTests) callers = callers.filter((c) => !isTestFile(c.file));
+
+    const testCallerRows = findCallers(db, node.id);
+    const seenFiles = new Set();
+    const relatedTests = testCallerRows
+      .filter((r) => isTestFile(r.file) && !seenFiles.has(r.file) && seenFiles.add(r.file))
+      .map((r) => ({ file: r.file }));
+
+    // Complexity metrics
+    let complexityMetrics = null;
+    try {
+      const cRow = getComplexityForNode(db, node.id);
+      if (cRow) {
+        complexityMetrics = {
+          cognitive: cRow.cognitive,
+          cyclomatic: cRow.cyclomatic,
+          maxNesting: cRow.max_nesting,
+          maintainabilityIndex: cRow.maintainability_index || 0,
+          halsteadVolume: cRow.halstead_volume || 0,
+        };
+      }
+    } catch {
+      /* table may not exist */
+    }
+
+    return {
+      ...normalizeSymbol(node, db, hc),
+      lineCount,
+      summary,
+      signature,
+      complexity: complexityMetrics,
+      callees,
+      callers,
+      relatedTests,
+    };
+  });
+}
+
+// ─── Exported functions ──────────────────────────────────────────────────
+
+export function contextData(name, customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const depth = opts.depth || 0;
+    const noSource = opts.noSource || false;
+    const noTests = opts.noTests || false;
+    const includeTests = opts.includeTests || false;
+
+    const dbPath = findDbPath(customDbPath);
+    const repoRoot = path.resolve(path.dirname(dbPath), '..');
+
+    const nodes = findMatchingNodes(db, name, { noTests, file: opts.file, kind: opts.kind });
+    if (nodes.length === 0) {
+      return { name, results: [] };
+    }
+
+    // No hardcoded slice — pagination handles bounding via limit/offset
+
+    const getFileLines = createFileLinesReader(repoRoot);
+
+    const results = nodes.map((node) => {
+      const fileLines = getFileLines(node.file);
+
+      // Source
+      const source = noSource
+        ? null
+        : readSourceRange(repoRoot, node.file, node.line, node.end_line);
+
+      // Signature
+      const signature = fileLines ? extractSignature(fileLines, node.line) : null;
+
+      // Callees
+      const calleeRows = findCallees(db, node.id);
+      const filteredCallees = noTests ? calleeRows.filter((c) => !isTestFile(c.file)) : calleeRows;
+
+      const callees = filteredCallees.map((c) => {
+        const cLines = getFileLines(c.file);
+        const summary = cLines ? extractSummary(cLines, c.line) : null;
+        let calleeSource = null;
+        if (depth >= 1) {
+          calleeSource = readSourceRange(repoRoot, c.file, c.line, c.end_line);
+        }
+        return {
+          name: c.name,
+          kind: c.kind,
+          file: c.file,
+          line: c.line,
+          endLine: c.end_line || null,
+          summary,
+          source: calleeSource,
+        };
+      });
+
+      // Deep callee expansion via BFS (depth > 1, capped at 5)
+      if (depth > 1) {
+        const visited = new Set(filteredCallees.map((c) => c.id));
+        visited.add(node.id);
+        let frontier = filteredCallees.map((c) => c.id);
+        const maxDepth = Math.min(depth, 5);
+        for (let d = 2; d <= maxDepth; d++) {
+          const nextFrontier = [];
+          for (const fid of frontier) {
+            const deeper = findCallees(db, fid);
+            for (const c of deeper) {
+              if (!visited.has(c.id) && (!noTests || !isTestFile(c.file))) {
+                visited.add(c.id);
+                nextFrontier.push(c.id);
+                const cLines = getFileLines(c.file);
+                callees.push({
+                  name: c.name,
+                  kind: c.kind,
+                  file: c.file,
+                  line: c.line,
+                  endLine: c.end_line || null,
+                  summary: cLines ? extractSummary(cLines, c.line) : null,
+                  source: readSourceRange(repoRoot, c.file, c.line, c.end_line),
+                });
+              }
+            }
+          }
+          frontier = nextFrontier;
+          if (frontier.length === 0) break;
+        }
+      }
+
+      // Callers
+      let callerRows = findCallers(db, node.id);
+
+      // Method hierarchy resolution
+      if (node.kind === 'method' && node.name.includes('.')) {
+        const methodName = node.name.split('.').pop();
+        const relatedMethods = resolveMethodViaHierarchy(db, methodName);
+        for (const rm of relatedMethods) {
+          if (rm.id === node.id) continue;
+          const extraCallers = findCallers(db, rm.id);
+          callerRows.push(...extraCallers.map((c) => ({ ...c, viaHierarchy: rm.name })));
+        }
+      }
+      if (noTests) callerRows = callerRows.filter((c) => !isTestFile(c.file));
+
+      const callers = callerRows.map((c) => ({
+        name: c.name,
+        kind: c.kind,
+        file: c.file,
+        line: c.line,
+        viaHierarchy: c.viaHierarchy || undefined,
+      }));
+
+      // Related tests: callers that live in test files
+      const testCallerRows = findCallers(db, node.id);
+      const testCallers = testCallerRows.filter((c) => isTestFile(c.file));
+
+      const testsByFile = new Map();
+      for (const tc of testCallers) {
+        if (!testsByFile.has(tc.file)) testsByFile.set(tc.file, []);
+        testsByFile.get(tc.file).push(tc);
+      }
+
+      const relatedTests = [];
+      for (const [file] of testsByFile) {
+        const tLines = getFileLines(file);
+        const testNames = [];
+        if (tLines) {
+          for (const tl of tLines) {
+            const tm = tl.match(/(?:it|test|describe)\s*\(\s*['"`]([^'"`]+)['"`]/);
+            if (tm) testNames.push(tm[1]);
+          }
+        }
+        const testSource = includeTests && tLines ? tLines.join('\n') : undefined;
+        relatedTests.push({
+          file,
+          testCount: testNames.length,
+          testNames,
+          source: testSource,
+        });
+      }
+
+      // Complexity metrics
+      let complexityMetrics = null;
+      try {
+        const cRow = getComplexityForNode(db, node.id);
+        if (cRow) {
+          complexityMetrics = {
+            cognitive: cRow.cognitive,
+            cyclomatic: cRow.cyclomatic,
+            maxNesting: cRow.max_nesting,
+            maintainabilityIndex: cRow.maintainability_index || 0,
+            halsteadVolume: cRow.halstead_volume || 0,
+          };
+        }
+      } catch {
+        /* table may not exist */
+      }
+
+      // Children (parameters, properties, constants)
+      let nodeChildren = [];
+      try {
+        nodeChildren = findNodeChildren(db, node.id).map((c) => ({
+          name: c.name,
+          kind: c.kind,
+          line: c.line,
+          endLine: c.end_line || null,
+        }));
+      } catch {
+        /* parent_id column may not exist */
+      }
+
+      return {
+        name: node.name,
+        kind: node.kind,
+        file: node.file,
+        line: node.line,
+        role: node.role || null,
+        endLine: node.end_line || null,
+        source,
+        signature,
+        complexity: complexityMetrics,
+        children: nodeChildren.length > 0 ? nodeChildren : undefined,
+        callees,
+        callers,
+        relatedTests,
+      };
+    });
+
+    const base = { name, results };
+    return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
+  }
+}
+
+export function explainData(target, customDbPath, opts = {}) {
+  const db = openReadonlyOrFail(customDbPath);
+  try {
+    const noTests = opts.noTests || false;
+    const depth = opts.depth || 0;
+    const kind = isFileLikeTarget(target) ? 'file' : 'function';
+
+    const dbPath = findDbPath(customDbPath);
+    const repoRoot = path.resolve(path.dirname(dbPath), '..');
+
+    const getFileLines = createFileLinesReader(repoRoot);
+
+    const results =
+      kind === 'file'
+        ? explainFileImpl(db, target, getFileLines)
+        : explainFunctionImpl(db, target, noTests, getFileLines);
+
+    // Recursive dependency explanation for function targets
+    if (kind === 'function' && depth > 0 && results.length > 0) {
+      const visited = new Set(results.map((r) => `${r.name}:${r.file}:${r.line}`));
+
+      function explainCallees(parentResults, currentDepth) {
+        if (currentDepth <= 0) return;
+        for (const r of parentResults) {
+          const newCallees = [];
+          for (const callee of r.callees) {
+            const key = `${callee.name}:${callee.file}:${callee.line}`;
+            if (visited.has(key)) continue;
+            visited.add(key);
+            const calleeResults = explainFunctionImpl(db, callee.name, noTests, getFileLines);
+            const exact = calleeResults.find(
+              (cr) => cr.file === callee.file && cr.line === callee.line,
+            );
+            if (exact) {
+              exact._depth = (r._depth || 0) + 1;
+              newCallees.push(exact);
+            }
+          }
+          if (newCallees.length > 0) {
+            r.depDetails = newCallees;
+            explainCallees(newCallees, currentDepth - 1);
+          }
+        }
+      }
+
+      explainCallees(results, depth);
+    }
+
+    const base = { target, kind, results };
+    return paginateResult(base, 'results', { limit: opts.limit, offset: opts.offset });
+  } finally {
+    db.close();
+  }
+}