@kodus/kodus-graph 0.1.0

package/src/parser/extractors/ruby.ts

@@ -0,0 +1,142 @@
+import type { SgNode, SgRoot } from '@ast-grep/napi';
+import type { RawCallSite, RawGraph } from '../../graph/types';
+import { NOISE } from '../../shared/filters';
+import { log } from '../../shared/logger';
+import { LANG_KINDS } from '../languages';
+
+export function extractRuby(root: SgRoot, fp: string, seen: Set<string>, graph: RawGraph): void {
+  const kinds = LANG_KINDS.ruby;
+  const rootNode = root.root();
+
+  // ── Classes ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.class } })) {
+    const name = node.field('name')?.text();
+    if (!name || seen.has(`c:${fp}:${name}`)) continue;
+    seen.add(`c:${fp}:${name}`);
+
+    const superclass = node.field('superclass')?.text() || '';
+    graph.classes.push({
+      name,
+      file: fp,
+      line_start: node.range().start.line,
+      line_end: node.range().end.line,
+      extends: superclass,
+      implements: '',
+      qualified: `${fp}::${name}`,
+    });
+  }
+
+  // ── Modules ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.module } })) {
+    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}`,
+    });
+  }
+
+  // ── Methods ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.method } })) {
+    const name = node.field('name')?.text();
+    if (!name) continue;
+    const line = node.range().start.line;
+    if (seen.has(`m:${fp}:${name}:${line}`)) continue;
+    seen.add(`m:${fp}:${name}:${line}`);
+
+    const classAncestor = node.ancestors().find((a: SgNode) => a.kind() === kinds.class || a.kind() === kinds.module);
+    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: '',
+      kind: className ? 'Method' : 'Function',
+      className,
+      qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
+    });
+  }
+
+  // ── Tests (RSpec: describe/it/context) ──
+  for (const p of [
+    "describe '$NAME' do $$$BODY end",
+    'describe "$NAME" do $$$BODY end',
+    "it '$NAME' do $$$BODY end",
+    'it "$NAME" do $$$BODY end',
+    "context '$NAME' do $$$BODY end",
+    'context "$NAME" do $$$BODY end',
+  ]) {
+    try {
+      for (const m of rootNode.findAll(p)) {
+        const name = m.getMatch('NAME')?.text();
+        if (!name) continue;
+        const key = `t:${fp}:${name}:${m.range().start.line}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        graph.tests.push({
+          name,
+          file: fp,
+          line_start: m.range().start.line,
+          line_end: m.range().end.line,
+          qualified: `${fp}::test:${name}`,
+        });
+      }
+    } catch (err) {
+      log.debug('Ruby pattern mismatch', { file: fp, pattern: p, error: String(err) });
+    }
+  }
+
+  // ── Imports (require/require_relative) ──
+  for (const p of [
+    "require '$MODULE'",
+    'require "$MODULE"',
+    "require_relative '$MODULE'",
+    'require_relative "$MODULE"',
+  ]) {
+    try {
+      for (const m of rootNode.findAll(p)) {
+        const mod = m.getMatch('MODULE')?.text();
+        if (mod) {
+          graph.imports.push({
+            module: mod,
+            file: fp,
+            line: m.range().start.line,
+            names: [],
+            lang: 'ruby',
+          });
+        }
+      }
+    } catch (err) {
+      log.debug('Ruby pattern mismatch', { file: fp, pattern: p, error: String(err) });
+    }
+  }
+}
+
+/**
+ * Extract raw call sites from a Ruby AST.
+ * Direct calls only — Ruby has no DI pattern.
+ */
+export function extractCallsFromRuby(root: SgRoot, fp: string, calls: RawCallSite[]): void {
+  const rootNode = root.root();
+
+  for (const m of rootNode.findAll('$CALLEE($$$ARGS)')) {
+    const callee = m.getMatch('CALLEE')?.text();
+    if (!callee) continue;
+    const callName = callee.includes('.') ? callee.split('.').pop()! : callee;
+    if (NOISE.has(callName)) continue;
+    calls.push({
+      source: fp,
+      callName,
+      line: m.range().start.line,
+    });
+  }
+}

package/src/parser/extractors/typescript.ts

@@ -0,0 +1,329 @@
+import type { SgNode, SgRoot } from '@ast-grep/napi';
+import { Lang } from '@ast-grep/napi';
+import type { RawCallSite, RawGraph } from '../../graph/types';
+import { NOISE } from '../../shared/filters';
+import { LANG_KINDS } from '../languages';
+
+export function extractTypeScript(
+  root: SgRoot,
+  fp: string,
+  seen: Set<string>,
+  graph: RawGraph,
+  lang: Lang | string = Lang.TypeScript,
+): void {
+  const kinds = LANG_KINDS.typescript;
+  const rootNode = root.root();
+  const isTS = lang === Lang.TypeScript || lang === Lang.Tsx;
+
+  // ── Classes ──
+  const classKinds = isTS ? [kinds.class, kinds.abstractClass] : [kinds.class];
+  for (const kind of classKinds) {
+    for (const node of rootNode.findAll({ rule: { kind } })) {
+      const name = node.field('name')?.text();
+      if (!name || seen.has(`c:${fp}:${name}`)) continue;
+      seen.add(`c:${fp}:${name}`);
+
+      let extendsName = '';
+      let implementsName = '';
+      const heritage = node.children().find((c: SgNode) => c.kind() === 'class_heritage');
+      if (heritage) {
+        const ext = heritage.children().find((c: SgNode) => c.kind() === 'extends_clause');
+        extendsName =
+          ext
+            ?.children()
+            .find(
+              (c: SgNode) =>
+                c.kind() === 'identifier' || c.kind() === 'type_identifier' || c.kind() === 'member_expression',
+            )
+            ?.text() || '';
+        const impl = heritage.children().find((c: SgNode) => c.kind() === 'implements_clause');
+        implementsName =
+          impl
+            ?.children()
+            .find((c: SgNode) => c.kind() === 'type_identifier' || c.kind() === 'identifier')
+            ?.text() || '';
+      }
+
+      graph.classes.push({
+        name,
+        file: fp,
+        line_start: node.range().start.line,
+        line_end: node.range().end.line,
+        extends: extendsName,
+        implements: implementsName,
+        qualified: `${fp}::${name}`,
+      });
+    }
+  }
+
+  // ── Methods (kind-based: catches constructor, async, getters/setters) ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.method } })) {
+    const name = node.field('name')?.text();
+    if (!name) continue;
+    const line = node.range().start.line;
+    if (seen.has(`m:${fp}:${name}:${line}`)) continue;
+    seen.add(`m:${fp}:${name}:${line}`);
+
+    const classAncestor = node
+      .ancestors()
+      .find((a: SgNode) => a.kind() === kinds.class || (isTS && a.kind() === kinds.abstractClass));
+    const className = classAncestor?.field('name')?.text() || '';
+    const params = node.field('parameters');
+    const retType = node.field('return_type')?.text()?.replace(/^:\s*/, '') || '';
+
+    if (name === 'constructor' && className) {
+      // Constructor DI extraction
+      const fieldTypeMap = new Map<string, string>();
+      if (params) {
+        for (const p of params.children()) {
+          if (p.kind() !== 'required_parameter') continue;
+          if (!p.children().some((c: SgNode) => c.kind() === 'accessibility_modifier')) continue;
+          const ident = p.children().find((c: SgNode) => c.kind() === 'identifier');
+          const typeAnn = p.children().find((c: SgNode) => c.kind() === 'type_annotation');
+          if (ident && typeAnn) {
+            const typeNode = typeAnn
+              .children()
+              .find(
+                (c: SgNode) =>
+                  c.kind() === 'type_identifier' || c.kind() === 'identifier' || c.kind() === 'generic_type',
+              );
+            if (typeNode) {
+              const typeName =
+                typeNode.kind() === 'generic_type'
+                  ? typeNode
+                      .children()
+                      .find((c: SgNode) => c.kind() === 'type_identifier')
+                      ?.text() || typeNode.text()
+                  : typeNode.text();
+              fieldTypeMap.set(ident.text(), typeName);
+            }
+          }
+        }
+      }
+      if (fieldTypeMap.size > 0) graph.diMaps.set(fp, fieldTypeMap);
+
+      graph.functions.push({
+        name: `${className}.constructor`,
+        file: fp,
+        line_start: line,
+        line_end: node.range().end.line,
+        params: params?.text() || '()',
+        returnType: '',
+        kind: 'Constructor',
+        className,
+        qualified: `${fp}::${className}.constructor`,
+      });
+    } else {
+      graph.functions.push({
+        name,
+        file: fp,
+        line_start: line,
+        line_end: node.range().end.line,
+        params: params?.text() || '()',
+        returnType: retType,
+        kind: className ? 'Method' : 'Function',
+        className,
+        qualified: className ? `${fp}::${className}.${name}` : `${fp}::${name}`,
+      });
+    }
+  }
+
+  // ── Standalone functions ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.function } })) {
+    const name = node.field('name')?.text();
+    if (!name) continue;
+    const line = node.range().start.line;
+    if (seen.has(`f:${fp}:${name}:${line}`)) continue;
+    if (node.ancestors().some((a: SgNode) => a.kind() === kinds.class || (isTS && a.kind() === kinds.abstractClass)))
+      continue;
+    seen.add(`f:${fp}:${name}:${line}`);
+
+    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()?.replace(/^:\s*/, '') || '',
+      kind: 'Function',
+      className: '',
+      qualified: `${fp}::${name}`,
+    });
+  }
+
+  // ── Arrow functions ──
+  for (const node of rootNode.findAll({
+    rule: { kind: kinds.arrowContainer, has: { kind: kinds.arrowFunction } },
+  })) {
+    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 arrow = node.children().find((c: SgNode) => c.kind() === kinds.arrowFunction);
+    graph.functions.push({
+      name,
+      file: fp,
+      line_start: line,
+      line_end: node.range().end.line,
+      params: arrow?.field('parameters')?.text() || '()',
+      returnType: arrow?.field('return_type')?.text()?.replace(/^:\s*/, '') || '',
+      kind: 'Function',
+      className: '',
+      qualified: `${fp}::${name}`,
+    });
+  }
+
+  // ── Interfaces (TS only — JS grammar has no interface_declaration) ──
+  if (isTS)
+    for (const node of rootNode.findAll({ rule: { kind: kinds.interface } })) {
+      const name = node.field('name')?.text();
+      if (!name || seen.has(`i:${fp}:${name}`)) continue;
+      seen.add(`i:${fp}:${name}`);
+
+      const methods: string[] = [];
+      const body = node.field('body');
+      if (body) {
+        for (const child of body.findAll({ rule: { kind: kinds.methodSignature } })) {
+          const mn = child.field('name')?.text();
+          if (mn) methods.push(mn);
+        }
+      }
+
+      graph.interfaces.push({
+        name,
+        file: fp,
+        line_start: node.range().start.line,
+        line_end: node.range().end.line,
+        methods,
+        qualified: `${fp}::${name}`,
+      });
+    }
+
+  // ── Enums (TS only — JS grammar has no enum_declaration) ──
+  if (isTS)
+    for (const node of rootNode.findAll({ rule: { kind: kinds.enum } })) {
+      const name = node.field('name')?.text();
+      if (!name || seen.has(`e:${fp}:${name}`)) continue;
+      seen.add(`e:${fp}:${name}`);
+      graph.enums.push({
+        name,
+        file: fp,
+        line_start: node.range().start.line,
+        line_end: node.range().end.line,
+        qualified: `${fp}::${name}`,
+      });
+    }
+
+  // ── Imports ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.import } })) {
+    const sourceNode = node.children().find((c: SgNode) => c.kind() === 'string');
+    const frag = sourceNode?.children().find((c: SgNode) => c.kind() === 'string_fragment');
+    const modulePath = frag?.text() || sourceNode?.text()?.replace(/['"]/g, '') || '';
+    if (!modulePath) continue;
+
+    const names: string[] = [];
+    const importClause = node.children().find((c: SgNode) => c.kind() === 'import_clause');
+    if (importClause) {
+      for (const child of importClause.children()) {
+        if (child.kind() === 'identifier') {
+          names.push(child.text());
+        } else if (child.kind() === 'named_imports') {
+          for (const spec of child.findAll({ rule: { kind: 'import_specifier' } })) {
+            const n =
+              spec.field('name')?.text() ||
+              spec
+                .children()
+                .find((c: SgNode) => c.kind() === 'identifier')
+                ?.text();
+            if (n) names.push(n);
+          }
+        } else if (child.kind() === 'namespace_import') {
+          const alias = child.children().find((c: SgNode) => c.kind() === 'identifier');
+          if (alias) names.push(alias.text());
+        }
+      }
+    }
+    graph.imports.push({
+      module: modulePath,
+      file: fp,
+      line: node.range().start.line,
+      names,
+      lang: 'ts',
+    });
+  }
+
+  // ── Re-exports ──
+  for (const node of rootNode.findAll({ rule: { kind: kinds.export } })) {
+    const src = node.children().find((c: SgNode) => c.kind() === 'string');
+    if (src) {
+      const frag = src.children().find((c: SgNode) => c.kind() === 'string_fragment');
+      graph.reExports.push({
+        module: frag?.text() || src.text().replace(/['"]/g, ''),
+        file: fp,
+        line: node.range().start.line,
+      });
+    }
+  }
+
+  // ── Tests (pattern-based) ──
+  for (const p of [
+    'describe("$NAME", $$$BODY)',
+    "describe('$NAME', $$$BODY)",
+    'it("$NAME", $$$BODY)',
+    "it('$NAME', $$$BODY)",
+    'test("$NAME", $$$BODY)',
+    "test('$NAME', $$$BODY)",
+  ]) {
+    for (const m of rootNode.findAll(p)) {
+      const name = m.getMatch('NAME')?.text();
+      if (!name) continue;
+      const key = `t:${fp}:${name}:${m.range().start.line}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      graph.tests.push({
+        name,
+        file: fp,
+        line_start: m.range().start.line,
+        line_end: m.range().end.line,
+        qualified: `${fp}::test:${name}`,
+      });
+    }
+  }
+}
+
+/**
+ * Extract raw call sites from a TypeScript/JavaScript AST.
+ * Finds DI calls (this.field.method) and direct calls ($CALLEE($$$ARGS)).
+ * Filters NOISE. Does NOT resolve — just collects raw sites.
+ */
+export function extractCallsFromTypeScript(root: SgRoot, fp: string, calls: RawCallSite[]): void {
+  const rootNode = root.root();
+
+  // DI pattern: this.$FIELD.$METHOD($$$ARGS)
+  for (const m of rootNode.findAll('this.$FIELD.$METHOD($$$ARGS)')) {
+    const field = m.getMatch('FIELD')?.text();
+    const method = m.getMatch('METHOD')?.text();
+    if (!method || NOISE.has(method)) continue;
+    calls.push({
+      source: fp,
+      callName: method,
+      line: m.range().start.line,
+      diField: field,
+    });
+  }
+
+  // Direct calls: $CALLEE($$$ARGS)
+  for (const m of rootNode.findAll('$CALLEE($$$ARGS)')) {
+    const callee = m.getMatch('CALLEE')?.text();
+    if (!callee || callee.startsWith('this.')) continue;
+    const callName = callee.includes('.') ? callee.split('.').pop()! : callee;
+    if (NOISE.has(callName)) continue;
+    calls.push({
+      source: fp,
+      callName,
+      line: m.range().start.line,
+    });
+  }
+}

package/src/parser/languages.ts

@@ -0,0 +1,122 @@
+import csharp from '@ast-grep/lang-csharp';
+import go from '@ast-grep/lang-go';
+import java from '@ast-grep/lang-java';
+import php from '@ast-grep/lang-php';
+import python from '@ast-grep/lang-python';
+import ruby from '@ast-grep/lang-ruby';
+import rust from '@ast-grep/lang-rust';
+import { Lang, registerDynamicLanguage } from '@ast-grep/napi';
+
+// Register dynamic languages at import time (side effect).
+// This must happen before parseAsync can parse these languages.
+registerDynamicLanguage({ python, ruby, go, java, rust, php, csharp });
+
+// Extension -> language identifier
+// Built-in langs use Lang enum, dynamic langs use lowercase string
+const EXT_TO_LANG: Record<string, Lang | string> = {
+  '.ts': Lang.TypeScript,
+  '.tsx': Lang.Tsx,
+  '.js': Lang.JavaScript,
+  '.jsx': Lang.JavaScript,
+  '.mjs': Lang.JavaScript,
+  '.cjs': Lang.JavaScript,
+  '.py': 'python',
+  '.rb': 'ruby',
+  '.go': 'go',
+  '.java': 'java',
+  '.rs': 'rust',
+  '.cs': 'csharp',
+  '.php': 'php',
+};
+
+export function getLanguage(ext: string): Lang | string | null {
+  return EXT_TO_LANG[ext] ?? null;
+}
+
+export function getSupportedExtensions(): string[] {
+  return Object.keys(EXT_TO_LANG);
+}
+
+export function getLanguageName(lang: Lang | string): string {
+  if (typeof lang === 'string') return lang;
+  if (lang === Lang.TypeScript || lang === Lang.Tsx) return 'typescript';
+  if (lang === Lang.JavaScript) return 'javascript';
+  return 'unknown';
+}
+
+export function isTypeScriptLike(lang: Lang | string): boolean {
+  return lang === Lang.TypeScript || lang === Lang.Tsx || lang === Lang.JavaScript;
+}
+
+// AST node kinds per language for structural extraction
+export const LANG_KINDS: Record<string, Record<string, string>> = {
+  typescript: {
+    class: 'class_declaration',
+    abstractClass: 'abstract_class_declaration',
+    method: 'method_definition',
+    function: 'function_declaration',
+    arrowContainer: 'variable_declarator',
+    arrowFunction: 'arrow_function',
+    interface: 'interface_declaration',
+    enum: 'enum_declaration',
+    import: 'import_statement',
+    export: 'export_statement',
+    methodSignature: 'method_signature',
+  },
+  python: {
+    class: 'class_definition',
+    method: 'function_definition',
+    function: 'function_definition',
+    import: 'import_from_statement',
+    importRegular: 'import_statement',
+    decorator: 'decorator',
+  },
+  ruby: {
+    class: 'class',
+    method: 'method',
+    singletonMethod: 'singleton_method',
+    module: 'module',
+    call: 'call',
+  },
+  go: {
+    function: 'function_declaration',
+    method: 'method_declaration',
+    struct: 'type_declaration',
+    interface: 'type_declaration',
+    import: 'import_declaration',
+  },
+  java: {
+    class: 'class_declaration',
+    interface: 'interface_declaration',
+    method: 'method_declaration',
+    constructor: 'constructor_declaration',
+    import: 'import_declaration',
+    enum: 'enum_declaration',
+  },
+  rust: {
+    function: 'function_item',
+    struct: 'struct_item',
+    impl: 'impl_item',
+    trait: 'trait_item',
+    enum: 'enum_item',
+    use: 'use_declaration',
+  },
+  csharp: {
+    class: 'class_declaration',
+    interface: 'interface_declaration',
+    method: 'method_declaration',
+    constructor: 'constructor_declaration',
+    using: 'using_directive',
+    enum: 'enum_declaration',
+    namespace: 'namespace_declaration',
+  },
+  php: {
+    class: 'class_declaration',
+    method: 'method_declaration',
+    function: 'function_definition',
+    namespace: 'namespace_definition',
+    use: 'namespace_use_declaration',
+  },
+};
+
+export { Lang };