@kodus/kodus-graph 0.2.8 → 0.2.10

package/src/graph/types.ts

@@ -1,283 +0,0 @@
-// ── Node kinds (aligned with Postgres ast_nodes.kind) ──
-export type NodeKind = 'Function' | 'Method' | 'Constructor' | 'Class' | 'Interface' | 'Enum' | 'Test';
-
-// ── Edge kinds (aligned with Postgres ast_edges.kind) ──
-export type EdgeKind = 'CALLS' | 'IMPORTS' | 'INHERITS' | 'IMPLEMENTS' | 'TESTED_BY' | 'CONTAINS';
-
-// ── Graph node (matches ast_nodes table) ──
-export interface GraphNode {
-  kind: NodeKind;
-  name: string;
-  qualified_name: string;
-  file_path: string;
-  line_start: number;
-  line_end: number;
-  language: string;
-  parent_name?: string;
-  params?: string;
-  return_type?: string;
-  modifiers?: string;
-  is_test: boolean;
-  file_hash: string;
-  content_hash?: string;
-}
-
-// ── Graph edge (matches ast_edges table) ──
-export interface GraphEdge {
-  kind: EdgeKind;
-  source_qualified: string;
-  target_qualified: string;
-  file_path: string;
-  line: number;
-  confidence?: number; // 0.0-1.0, only for CALLS
-}
-
-// ── Full graph data ──
-export interface GraphData {
-  nodes: GraphNode[];
-  edges: GraphEdge[];
-}
-
-// ── Parse command output ──
-export interface ParseMetadata {
-  repo_dir: string;
-  files_parsed: number;
-  total_nodes: number;
-  total_edges: number;
-  duration_ms: number;
-  parse_errors: number;
-  extract_errors: number;
-  files_unchanged?: number;
-  incremental?: boolean;
-}
-
-export interface ParseOutput {
-  metadata: ParseMetadata;
-  nodes: GraphNode[];
-  edges: GraphEdge[];
-}
-
-// ── Analyze command output ──
-export interface BlastRadiusResult {
-  total_functions: number;
-  total_files: number;
-  by_depth: Record<string, string[]>;
-}
-
-export interface RiskFactor {
-  weight: number;
-  value: number;
-  detail: string;
-}
-
-export interface RiskScoreResult {
-  level: 'LOW' | 'MEDIUM' | 'HIGH';
-  score: number;
-  factors: {
-    blast_radius: RiskFactor;
-    test_gaps: RiskFactor;
-    complexity: RiskFactor;
-    inheritance: RiskFactor;
-  };
-}
-
-export interface TestGap {
-  function: string;
-  file_path: string;
-  line_start: number;
-}
-
-export interface AnalysisOutput {
-  blast_radius: BlastRadiusResult;
-  risk_score: RiskScoreResult;
-  test_gaps: TestGap[];
-}
-
-// ── Context command output ──
-export interface ContextMetadata {
-  changed_functions: number;
-  caller_count: number;
-  callee_count: number;
-  untested_count: number;
-  blast_radius: { functions: number; files: number };
-  risk_level: 'LOW' | 'MEDIUM' | 'HIGH';
-  risk_score: number;
-}
-
-export interface ContextOutput {
-  text: string;
-  metadata: ContextMetadata;
-}
-
-// ── Main graph JSON (input --graph, from Postgres) ──
-export interface MainGraphInput {
-  repo_id: string;
-  sha: string;
-  nodes: GraphNode[];
-  edges: GraphEdge[];
-}
-
-// ── Context V2 types ──
-export interface CallerRef {
-  qualified_name: string;
-  name: string;
-  file_path: string;
-  line: number;
-  confidence: number;
-}
-
-export interface CalleeRef {
-  qualified_name: string;
-  name: string;
-  file_path: string;
-  signature: string;
-}
-
-export interface EnrichedFunction {
-  qualified_name: string;
-  name: string;
-  kind: NodeKind;
-  signature: string;
-  file_path: string;
-  line_start: number;
-  line_end: number;
-  callers: CallerRef[];
-  callees: CalleeRef[];
-  has_test_coverage: boolean;
-  diff_changes: string[];
-  is_new: boolean;
-  in_flows: string[];
-}
-
-export interface AffectedFlow {
-  entry_point: string;
-  type: 'test' | 'http';
-  touches_changed: string[];
-  depth: number;
-  path: string[];
-}
-
-export interface InheritanceEntry {
-  qualified_name: string;
-  file_path: string;
-  extends?: string;
-  implements: string[];
-  children: string[];
-}
-
-export interface ContextAnalysisMetadata {
-  changed_functions_count: number;
-  total_callers: number;
-  total_callees: number;
-  untested_count: number;
-  affected_flows_count: number;
-  duration_ms: number;
-  min_confidence: number;
-}
-
-// ── Internal types used during parsing pipeline ──
-export interface RawFunction {
-  name: string;
-  file: string;
-  line_start: number;
-  line_end: number;
-  params: string;
-  returnType: string;
-  kind: 'Function' | 'Method' | 'Constructor';
-  className: string;
-  qualified: string;
-  content_hash?: string;
-}
-
-export interface RawClass {
-  name: string;
-  file: string;
-  line_start: number;
-  line_end: number;
-  extends: string;
-  implements: string;
-  qualified: string;
-  content_hash?: string;
-}
-
-export interface RawInterface {
-  name: string;
-  file: string;
-  line_start: number;
-  line_end: number;
-  methods: string[];
-  qualified: string;
-  content_hash?: string;
-}
-
-export interface RawEnum {
-  name: string;
-  file: string;
-  line_start: number;
-  line_end: number;
-  qualified: string;
-  content_hash?: string;
-}
-
-export interface RawTest {
-  name: string;
-  file: string;
-  line_start: number;
-  line_end: number;
-  qualified: string;
-  content_hash?: string;
-}
-
-export interface RawImport {
-  module: string;
-  file: string;
-  line: number;
-  names: string[];
-  lang: string;
-}
-
-export interface RawReExport {
-  module: string;
-  file: string;
-  line: number;
-}
-
-export interface RawCallSite {
-  source: string; // relative file path
-  callName: string; // function or method name being called
-  line: number; // line number of the call
-  diField?: string; // if DI pattern (this.field.method), the field name
-  resolveInClass?: string; // class to resolve in: current class for self.X(), parent for super().X()
-}
-
-export interface RawCallEdge {
-  source: string; // file path of the caller
-  target: string; // qualified name of the callee
-  callName: string;
-  line: number;
-  confidence: number;
-}
-
-export interface ImportEdge {
-  source: string; // source file
-  target: string; // resolved target file or unresolved module
-  resolved: boolean;
-  line: number;
-}
-
-export interface RawGraph {
-  functions: RawFunction[];
-  classes: RawClass[];
-  interfaces: RawInterface[];
-  enums: RawEnum[];
-  tests: RawTest[];
-  imports: RawImport[];
-  reExports: RawReExport[];
-  rawCalls: RawCallSite[];
-  diMaps: Map<string, Map<string, string>>; // file -> Map<fieldName, typeName>
-}
-
-export interface ParseBatchResult extends RawGraph {
-  parseErrors: number;
-  extractErrors: number;
-}

package/src/parser/batch.ts

@@ -1,82 +0,0 @@
-import type { SgRoot } from '@ast-grep/napi';
-import { parseAsync } from '@ast-grep/napi';
-import { readFileSync } from 'fs';
-import { extname, relative } from 'path';
-import type { ParseBatchResult, RawCallSite, RawGraph } from '../graph/types';
-import { NOISE } from '../shared/filters';
-import { log } from '../shared/logger';
-import { extractCallsFromFile, extractFromFile } from './extractor';
-import { getLanguage } from './languages';
-
-const BATCH_SIZE = 50;
-
-export async function parseBatch(files: string[], repoRoot: string): Promise<ParseBatchResult> {
-  const graph: RawGraph = {
-    functions: [],
-    classes: [],
-    interfaces: [],
-    enums: [],
-    tests: [],
-    imports: [],
-    reExports: [],
-    rawCalls: [],
-    diMaps: new Map(),
-  };
-  const seen = new Set<string>();
-  let parseErrors = 0;
-  let extractErrors = 0;
-
-  for (let i = 0; i < files.length; i += BATCH_SIZE) {
-    const batch = files.slice(i, i + BATCH_SIZE);
-
-    const promises = batch.map(async (filePath) => {
-      const lang = getLanguage(extname(filePath));
-      if (!lang) return;
-
-      let source: string;
-      try {
-        source = readFileSync(filePath, 'utf-8');
-      } catch (err) {
-        log.warn('Failed to read file', { file: filePath, error: String(err) });
-        parseErrors++;
-        return;
-      }
-
-      let root: SgRoot;
-      try {
-        root = await parseAsync(lang, source);
-      } catch (err) {
-        log.warn('Failed to parse file', { file: filePath, error: String(err) });
-        parseErrors++;
-        return;
-      }
-
-      const fp = relative(repoRoot, filePath);
-
-      try {
-        extractFromFile(root, fp, lang, seen, graph);
-      } catch (err) {
-        log.error('Extraction crashed', { file: fp, error: String(err) });
-        extractErrors++;
-      }
-
-      try {
-        // Extract calls into a temporary buffer, then filter noise before pushing
-        const rawCalls: RawCallSite[] = [];
-        extractCallsFromFile(root, fp, lang, rawCalls);
-        for (const call of rawCalls) {
-          if (!NOISE.has(call.callName)) {
-            graph.rawCalls.push(call);
-          }
-        }
-      } catch (err) {
-        log.error('Call extraction crashed', { file: fp, error: String(err) });
-        extractErrors++;
-      }
-    });
-
-    await Promise.all(promises);
-  }
-
-  return { ...graph, parseErrors, extractErrors };
-}

package/src/parser/discovery.ts

@@ -1,75 +0,0 @@
-import { readdirSync } from 'fs';
-import { extname, join, relative, resolve } from 'path';
-import { isSkippableFile, SKIP_DIRS } from '../shared/filters';
-import { log } from '../shared/logger';
-import { ensureWithinRoot } from '../shared/safe-path';
-import { getLanguage } from './languages';
-
-/**
- * Walk the filesystem and find all supported source files.
- * If `filterFiles` is provided, only return those specific files (resolved to absolute paths).
- * If `include` patterns are provided, keep only files matching at least one pattern.
- * If `exclude` patterns are provided, remove files matching any pattern.
- */
-export function discoverFiles(
-  repoDir: string,
-  filterFiles?: string[],
-  include?: string[],
-  exclude?: string[],
-): string[] {
-  const absRepoDir = resolve(repoDir);
-
-  if (filterFiles) {
-    return filterFiles
-      .map((f) => (f.startsWith('/') ? f : join(absRepoDir, f)))
-      .filter((f) => {
-        try {
-          ensureWithinRoot(f, absRepoDir);
-          return getLanguage(extname(f)) !== null;
-        } catch (err) {
-          log.warn('Skipping file outside repository root', { file: f, error: String(err) });
-          return false;
-        }
-      });
-  }
-
-  let files: string[] = [];
-  walkFiles(absRepoDir, files);
-
-  // Apply include/exclude filters using Bun.Glob
-  const hasInclude = include && include.length > 0;
-  const hasExclude = exclude && exclude.length > 0;
-
-  if (hasInclude || hasExclude) {
-    const includeGlobs = hasInclude ? include.map((p) => new Bun.Glob(p)) : null;
-    const excludeGlobs = hasExclude ? exclude.map((p) => new Bun.Glob(p)) : null;
-
-    files = files.filter((absPath) => {
-      const rel = relative(absRepoDir, absPath);
-
-      // If include patterns exist, file must match at least one
-      if (includeGlobs && !includeGlobs.some((g) => g.match(rel))) {
-        return false;
-      }
-
-      // If exclude patterns exist, file must not match any
-      if (excludeGlobs && excludeGlobs.some((g) => g.match(rel))) {
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-  return files;
-}
-
-function walkFiles(dir: string, files: string[]): void {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
-      walkFiles(join(dir, entry.name), files);
-    } else if (entry.isFile() && getLanguage(extname(entry.name)) !== null && !isSkippableFile(entry.name)) {
-      files.push(join(dir, entry.name));
-    }
-  }
-}

package/src/parser/extractor.ts

@@ -1,37 +0,0 @@
-import type { Lang, SgRoot } from '@ast-grep/napi';
-import type { RawCallSite, RawGraph } from '../graph/types';
-import { extractCallsFromGeneric, extractGeneric } from './extractors/generic';
-import { extractCallsFromPython, extractPython } from './extractors/python';
-import { extractCallsFromRuby, extractRuby } from './extractors/ruby';
-import { extractCallsFromTypeScript, extractTypeScript } from './extractors/typescript';
-import { isTypeScriptLike } from './languages';
-
-export function extractFromFile(
-  root: SgRoot,
-  filePath: string,
-  lang: Lang | string,
-  seen: Set<string>,
-  graph: RawGraph,
-): void {
-  if (isTypeScriptLike(lang)) {
-    extractTypeScript(root, filePath, seen, graph, lang);
-  } else if (lang === 'python') {
-    extractPython(root, filePath, seen, graph);
-  } else if (lang === 'ruby') {
-    extractRuby(root, filePath, seen, graph);
-  } else {
-    extractGeneric(root, filePath, lang as string, seen, graph);
-  }
-}
-
-export function extractCallsFromFile(root: SgRoot, filePath: string, lang: Lang | string, calls: RawCallSite[]): void {
-  if (isTypeScriptLike(lang)) {
-    extractCallsFromTypeScript(root, filePath, calls);
-  } else if (lang === 'python') {
-    extractCallsFromPython(root, filePath, calls);
-  } else if (lang === 'ruby') {
-    extractCallsFromRuby(root, filePath, calls);
-  } else {
-    extractCallsFromGeneric(root, filePath, lang as string, calls);
-  }
-}

package/src/parser/extractors/generic.ts

@@ -1,132 +0,0 @@
-import type { SgNode, SgRoot } from '@ast-grep/napi';
-import type { RawCallSite, RawGraph } from '../../graph/types';
-import { type CallExtractionConfig, extractCalls } from '../../shared/extract-calls';
-import { computeContentHash } from '../../shared/file-hash';
-import { log } from '../../shared/logger';
-import { LANG_KINDS } from '../languages';
-
-export function extractGeneric(root: SgRoot, fp: string, lang: string, seen: Set<string>, graph: RawGraph): void {
-  const kinds = LANG_KINDS[lang];
-  if (!kinds) return;
-  const rootNode = root.root();
-
-  // Try to extract classes
-  for (const classKind of [kinds.class, kinds.struct, kinds.interface].filter(Boolean)) {
-    try {
-      for (const node of rootNode.findAll({ rule: { kind: classKind } })) {
-        const name = node.field('name')?.text();
-        if (!name || seen.has(`c:${fp}:${name}`)) continue;
-        seen.add(`c:${fp}:${name}`);
-        graph.classes.push({
-          name,
-          file: fp,
-          line_start: node.range().start.line,
-          line_end: node.range().end.line,
-          extends: '',
-          implements: '',
-          qualified: `${fp}::${name}`,
-          content_hash: computeContentHash(node.text()),
-        });
-      }
-    } catch (err) {
-      log.debug('Generic extraction failed', { file: fp, error: String(err) });
-    }
-  }
-
-  // Try to extract functions/methods
-  // biome-ignore lint/complexity/useLiteralKeys: 'constructor' must use bracket notation to avoid Object.prototype.constructor
-  for (const funcKind of [kinds.function, kinds.method, kinds['constructor'] as string | undefined].filter(Boolean)) {
-    try {
-      for (const node of rootNode.findAll({ rule: { kind: funcKind } })) {
-        const name = node.field('name')?.text();
-        if (!name) continue;
-        const line = node.range().start.line;
-        if (seen.has(`f:${fp}:${name}:${line}`)) continue;
-        seen.add(`f:${fp}:${name}:${line}`);
-
-        const classAncestor = node.ancestors().find((a: SgNode) => {
-          const k = String(a.kind());
-          return k.includes('class') || k.includes('struct') || k.includes('impl');
-        });
-        const className = classAncestor?.field('name')?.text() || '';
-
-        graph.functions.push({
-          name,
-          file: fp,
-          line_start: line,
-          line_end: node.range().end.line,
-          params: node.field('parameters')?.text() || '()',
-          returnType: node.field('return_type')?.text() || '',
-          kind: className ? 'Method' : 'Function',
-          className,
-          qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
-          content_hash: computeContentHash(node.text()),
-        });
-      }
-    } catch (err) {
-      log.debug('Generic extraction failed', { file: fp, error: String(err) });
-    }
-  }
-}
-
-/** Shared class-finder for languages using class/struct/impl AST kinds. */
-function findEnclosingClassGeneric(node: import('@ast-grep/napi').SgNode): import('@ast-grep/napi').SgNode | null {
-  return node.ancestors().find((a) => {
-    const k = String(a.kind());
-    return k.includes('class') || k.includes('struct') || k.includes('impl');
-  }) ?? null;
-}
-
-/** Per-language call extraction configs for self/super detection. */
-const GENERIC_CONFIGS: Record<string, CallExtractionConfig> = {
-  java: {
-    selfPrefixes: ['this.'],
-    superPrefixes: ['super.'],
-    findEnclosingClass: findEnclosingClassGeneric,
-    getParentClass: (classNode) => {
-      const sc = classNode.children().find((c) => c.kind() === 'superclass');
-      return sc?.children().find((c) => c.kind() === 'type_identifier')?.text();
-    },
-  },
-  csharp: {
-    selfPrefixes: ['this.'],
-    superPrefixes: ['base.'],
-    findEnclosingClass: findEnclosingClassGeneric,
-    getParentClass: (classNode) => {
-      const bl = classNode.children().find((c) => c.kind() === 'base_list');
-      return bl?.children().find((c) => c.kind() === 'identifier' || c.kind() === 'type_identifier')?.text();
-    },
-  },
-  rust: {
-    selfPrefixes: ['self.'],
-    superPrefixes: [],
-    findEnclosingClass: (node) =>
-      node.ancestors().find((a) => a.kind() === 'impl_item') ?? null,
-  },
-  go: {
-    selfPrefixes: [],
-    superPrefixes: [],
-    findEnclosingClass: findEnclosingClassGeneric,
-  },
-  php: {
-    selfPrefixes: [],
-    superPrefixes: [],
-    findEnclosingClass: findEnclosingClassGeneric,
-  },
-};
-
-/** Fallback config for unknown languages — no self/super detection. */
-const FALLBACK_CONFIG: CallExtractionConfig = {
-  selfPrefixes: [],
-  superPrefixes: [],
-  findEnclosingClass: findEnclosingClassGeneric,
-};
-
-/**
- * Extract raw call sites from a generic language AST.
- * Uses per-language config for self/super detection.
- */
-export function extractCallsFromGeneric(root: SgRoot, fp: string, lang: string, calls: RawCallSite[]): void {
-  const config = GENERIC_CONFIGS[lang] ?? FALLBACK_CONFIG;
-  extractCalls(root.root(), fp, config, calls);
-}