@monoes/graph 1.0.0

package/src/extract/languages/rust.ts

@@ -0,0 +1,230 @@
+import { basename } from 'path';
+import type { GraphNode, GraphEdge, ExtractionResult } from '../../types.js';
+import type { LanguageExtractor } from '../types.js';
+import {
+  tryLoadParser,
+  walk,
+  type SyntaxNodeLike,
+} from '../tree-sitter-runner.js';
+
+// ---- helpers ----
+
+function nodeName(node: SyntaxNodeLike): string {
+  const nameNode = node.childForFieldName('name');
+  return nameNode?.text ?? '';
+}
+
+function loc(node: SyntaxNodeLike): string {
+  return `L${node.startPosition.row + 1}`;
+}
+
+// ---- tree-sitter extraction ----
+
+function extractWithTreeSitter(filePath: string, content: string): ExtractionResult {
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+  const errors: string[] = [];
+
+  const parser = tryLoadParser('rust');
+  if (!parser) {
+    return { nodes, edges, filesProcessed: 1, fromCache: 0, errors };
+  }
+
+  let tree: { rootNode: SyntaxNodeLike };
+  try {
+    tree = parser.parse(content);
+  } catch (err) {
+    errors.push(`tree-sitter parse error in ${filePath}: ${String(err)}`);
+    return { nodes, edges, filesProcessed: 1, fromCache: 0, errors };
+  }
+
+  walk(tree.rootNode, (n) => {
+    // ---- functions ----
+    if (n.type === 'function_item') {
+      const name = nodeName(n);
+      if (name) {
+        nodes.push({
+          id: name,
+          label: name,
+          fileType: 'code',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+          nodeKind: 'function',
+        });
+      }
+      return;
+    }
+
+    // ---- structs ----
+    if (n.type === 'struct_item') {
+      const name = nodeName(n);
+      if (name) {
+        nodes.push({
+          id: name,
+          label: name,
+          fileType: 'code',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+          nodeKind: 'struct',
+        });
+      }
+      return;
+    }
+
+    // ---- traits ----
+    if (n.type === 'trait_item') {
+      const name = nodeName(n);
+      if (name) {
+        nodes.push({
+          id: name,
+          label: name,
+          fileType: 'code',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+          nodeKind: 'trait',
+        });
+      }
+      return;
+    }
+
+    // ---- impl blocks ----
+    if (n.type === 'impl_item') {
+      const typeNode = n.childForFieldName('type');
+      const traitNode = n.childForFieldName('trait');
+      const typeName = typeNode?.text ?? '';
+
+      if (typeName) {
+        nodes.push({
+          id: typeName,
+          label: typeName,
+          fileType: 'code',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+          nodeKind: 'impl',
+        });
+
+        // impl Trait for Type
+        if (traitNode) {
+          edges.push({
+            source: typeName,
+            target: traitNode.text,
+            relation: 'implements',
+            confidence: 'EXTRACTED',
+            sourceFile: filePath,
+            sourceLocation: loc(n),
+          });
+        }
+      }
+      return;
+    }
+
+    // ---- modules ----
+    if (n.type === 'mod_item') {
+      const name = nodeName(n);
+      if (name) {
+        nodes.push({
+          id: name,
+          label: name,
+          fileType: 'code',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+          nodeKind: 'module',
+        });
+      }
+      return;
+    }
+
+    // ---- use declarations ----
+    if (n.type === 'use_declaration') {
+      const argNode = n.childForFieldName('argument');
+      if (argNode) {
+        // Flatten the use path to a string (handles use a::b::c and use a::b::{c, d})
+        const usePath = argNode.text.replace(/\s+/g, '');
+        edges.push({
+          source: basename(filePath),
+          target: usePath,
+          relation: 'imports',
+          confidence: 'EXTRACTED',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+        });
+      }
+    }
+  });
+
+  return { nodes, edges, filesProcessed: 1, fromCache: 0, errors };
+}
+
+// ---- regex fallback ----
+
+function extractWithRegex(filePath: string, content: string): ExtractionResult {
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+
+  const lines = content.split('\n');
+
+  lines.forEach((line, idx) => {
+    const location = `L${idx + 1}`;
+    const trimmed = line.trim();
+
+    // pub fn / fn
+    const fnMatch = trimmed.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+    if (fnMatch) {
+      nodes.push({ id: fnMatch[1], label: fnMatch[1], fileType: 'code', sourceFile: filePath, sourceLocation: location, nodeKind: 'function' });
+    }
+
+    // pub struct / struct
+    const structMatch = trimmed.match(/^(?:pub\s+)?struct\s+(\w+)/);
+    if (structMatch) {
+      nodes.push({ id: structMatch[1], label: structMatch[1], fileType: 'code', sourceFile: filePath, sourceLocation: location, nodeKind: 'struct' });
+    }
+
+    // pub trait / trait
+    const traitMatch = trimmed.match(/^(?:pub\s+)?trait\s+(\w+)/);
+    if (traitMatch) {
+      nodes.push({ id: traitMatch[1], label: traitMatch[1], fileType: 'code', sourceFile: filePath, sourceLocation: location, nodeKind: 'trait' });
+    }
+
+    // impl Trait for Type
+    const implForMatch = trimmed.match(/^impl(?:<[^>]+>)?\s+(\w+)\s+for\s+(\w+)/);
+    if (implForMatch) {
+      edges.push({ source: implForMatch[2], target: implForMatch[1], relation: 'implements', confidence: 'EXTRACTED', sourceFile: filePath, sourceLocation: location });
+      nodes.push({ id: implForMatch[2], label: implForMatch[2], fileType: 'code', sourceFile: filePath, sourceLocation: location, nodeKind: 'impl' });
+    }
+
+    // plain impl Type
+    const implMatch = trimmed.match(/^impl(?:<[^>]+>)?\s+(\w+)\s*\{/);
+    if (implMatch && !implForMatch) {
+      nodes.push({ id: implMatch[1], label: implMatch[1], fileType: 'code', sourceFile: filePath, sourceLocation: location, nodeKind: 'impl' });
+    }
+
+    // use statements
+    const useMatch = trimmed.match(/^use\s+([^;]+)/);
+    if (useMatch) {
+      edges.push({ source: basename(filePath), target: useMatch[1].trim(), relation: 'imports', confidence: 'EXTRACTED', sourceFile: filePath, sourceLocation: location });
+    }
+
+    // mod declarations
+    const modMatch = trimmed.match(/^(?:pub\s+)?mod\s+(\w+)/);
+    if (modMatch) {
+      nodes.push({ id: modMatch[1], label: modMatch[1], fileType: 'code', sourceFile: filePath, sourceLocation: location, nodeKind: 'module' });
+    }
+  });
+
+  return { nodes, edges, filesProcessed: 1, fromCache: 0, errors: [] };
+}
+
+// ---- extractor implementation ----
+
+export const rustExtractor: LanguageExtractor = {
+  language: 'rust',
+  extensions: ['.rs'],
+
+  extract(filePath: string, content: string): ExtractionResult {
+    const tsResult = extractWithTreeSitter(filePath, content);
+    if (tsResult.nodes.length > 0 || tsResult.edges.length > 0 || tsResult.errors.length > 0) {
+      return tsResult;
+    }
+    return extractWithRegex(filePath, content);
+  },
+};

package/src/extract/languages/typescript.ts

@@ -0,0 +1,344 @@
+import { basename } from 'path';
+import type { GraphNode, GraphEdge, ExtractionResult } from '../../types.js';
+import type { LanguageExtractor } from '../types.js';
+import {
+  tryLoadParser,
+  walk,
+  type SyntaxNodeLike,
+} from '../tree-sitter-runner.js';
+
+// ---- helpers ----
+
+function nodeName(node: SyntaxNodeLike): string {
+  // Most declaration nodes expose "name" as a named field
+  const nameNode = node.childForFieldName('name');
+  return nameNode?.text ?? '';
+}
+
+function loc(node: SyntaxNodeLike): string {
+  return `L${node.startPosition.row + 1}`;
+}
+
+// ---- tree-sitter extraction ----
+
+const CLASS_TYPES = new Set([
+  'class_declaration',
+  'abstract_class_declaration',
+]);
+
+const FUNCTION_TYPES = new Set([
+  'function_declaration',
+  'generator_function_declaration',
+]);
+
+function extractWithTreeSitter(
+  filePath: string,
+  content: string,
+  language: string,
+): ExtractionResult {
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+  const errors: string[] = [];
+
+  const parser = tryLoadParser(language);
+  if (!parser) {
+    return { nodes, edges, filesProcessed: 1, fromCache: 0, errors };
+  }
+
+  let tree: { rootNode: SyntaxNodeLike };
+  try {
+    tree = parser.parse(content);
+  } catch (err) {
+    errors.push(`tree-sitter parse error in ${filePath}: ${String(err)}`);
+    return { nodes, edges, filesProcessed: 1, fromCache: 0, errors };
+  }
+
+  // Track current class/method context for call-edge attribution
+  const classStack: string[] = [];
+  const methodStack: string[] = [];
+
+  const addNode = (name: string, n: SyntaxNodeLike): void => {
+    if (!name) return;
+    nodes.push({
+      id: name,
+      label: name,
+      fileType: 'code',
+      sourceFile: filePath,
+      sourceLocation: loc(n),
+    });
+  };
+
+  walk(tree.rootNode, (n) => {
+    // ---- classes ----
+    if (CLASS_TYPES.has(n.type)) {
+      const name = nodeName(n);
+      addNode(name, n);
+      if (name) classStack.push(name);
+
+      // heritage: extends / implements
+      for (const child of n.children) {
+        if (child.type === 'class_heritage') {
+          for (const clause of child.children) {
+            if (clause.type !== 'extends_clause' && clause.type !== 'implements_clause') continue;
+            const relation = clause.type === 'extends_clause' ? 'extends' : 'implements';
+            // Each type_identifier inside the clause is a target
+            for (const target of clause.children) {
+              if (
+                target.type === 'type_identifier' ||
+                target.type === 'identifier'
+              ) {
+                edges.push({
+                  source: name,
+                  target: target.text,
+                  relation,
+                  confidence: 'EXTRACTED',
+                  sourceFile: filePath,
+                  sourceLocation: loc(clause),
+                });
+              }
+            }
+          }
+        }
+      }
+      return;
+    }
+
+    // ---- functions (top-level) ----
+    if (FUNCTION_TYPES.has(n.type)) {
+      const name = nodeName(n);
+      addNode(name, n);
+      if (name) methodStack.push(name);
+      return;
+    }
+
+    // ---- method definitions (inside class body) ----
+    if (n.type === 'method_definition' || n.type === 'public_field_definition') {
+      const name = nodeName(n);
+      // Qualify name with class if available
+      const qualifiedName = classStack.length > 0 ? `${classStack[classStack.length - 1]}.${name}` : name;
+      addNode(qualifiedName, n);
+      if (qualifiedName) methodStack.push(qualifiedName);
+      return;
+    }
+
+    // ---- interfaces ----
+    if (n.type === 'interface_declaration') {
+      const name = nodeName(n);
+      addNode(name, n);
+
+      // interface X extends Y
+      for (const child of n.children) {
+        if (child.type === 'extends_type_clause' || child.type === 'extends_clause') {
+          for (const target of child.children) {
+            if (target.type === 'type_identifier' || target.type === 'identifier') {
+              edges.push({
+                source: name,
+                target: target.text,
+                relation: 'extends',
+                confidence: 'EXTRACTED',
+                sourceFile: filePath,
+                sourceLocation: loc(child),
+              });
+            }
+          }
+        }
+      }
+      return;
+    }
+
+    // ---- type aliases ----
+    if (n.type === 'type_alias_declaration') {
+      const name = nodeName(n);
+      addNode(name, n);
+      return;
+    }
+
+    // ---- import statements ----
+    if (n.type === 'import_statement') {
+      // Extract the module specifier
+      const moduleSpecifier = n.childForFieldName('source');
+      const moduleText = moduleSpecifier
+        ? moduleSpecifier.text.replace(/^['"]|['"]$/g, '')
+        : '';
+
+      // Extract named specifiers: import { A, B } from '...'
+      for (const child of n.children) {
+        if (child.type === 'named_imports' || child.type === 'import_clause') {
+          for (const spec of child.children) {
+            if (spec.type === 'import_specifier') {
+              const importedName = spec.childForFieldName('name')?.text ?? spec.text;
+              if (importedName) {
+                edges.push({
+                  source: filePath,
+                  target: importedName,
+                  relation: 'imports',
+                  confidence: 'EXTRACTED',
+                  sourceFile: filePath,
+                  sourceLocation: loc(n),
+                });
+              }
+            }
+          }
+        }
+        // Default import: import X from '...'
+        if (child.type === 'import_clause') {
+          const defaultId = child.childForFieldName('name') ?? (
+            child.children.find(c => c.type === 'identifier') ?? null
+          );
+          if (defaultId) {
+            edges.push({
+              source: filePath,
+              target: defaultId.text,
+              relation: 'imports',
+              confidence: 'EXTRACTED',
+              sourceFile: filePath,
+              sourceLocation: loc(n),
+            });
+          }
+        }
+      }
+
+      // Always emit a file-level import edge to the module path
+      if (moduleText) {
+        edges.push({
+          source: basename(filePath),
+          target: moduleText,
+          relation: 'imports',
+          confidence: 'EXTRACTED',
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+        });
+      }
+      return;
+    }
+
+    // ---- call expressions ----
+    if (n.type === 'call_expression') {
+      const fnNode = n.childForFieldName('function');
+      if (!fnNode) return;
+
+      // Resolve callee name (may be `a.b()` or plain `foo()`)
+      let calleeName: string;
+      if (fnNode.type === 'member_expression') {
+        calleeName = fnNode.text;
+      } else {
+        calleeName = fnNode.text;
+      }
+
+      // Attribute to deepest known method context
+      const caller =
+        methodStack[methodStack.length - 1] ??
+        classStack[classStack.length - 1] ??
+        basename(filePath);
+
+      if (calleeName && caller && calleeName !== caller) {
+        edges.push({
+          source: caller,
+          target: calleeName,
+          relation: 'calls',
+          confidence: 'INFERRED',
+          confidenceScore: 0.8,
+          sourceFile: filePath,
+          sourceLocation: loc(n),
+        });
+      }
+    }
+  });
+
+  return { nodes, edges, filesProcessed: 1, fromCache: 0, errors };
+}
+
+// ---- regex fallback ----
+
+function extractWithRegex(filePath: string, content: string): ExtractionResult {
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+
+  const lines = content.split('\n');
+
+  lines.forEach((line, idx) => {
+    const location = `L${idx + 1}`;
+
+    // class
+    const classMatch = line.match(/^(export\s+)?(abstract\s+)?class\s+(\w+)/);
+    if (classMatch) {
+      const name = classMatch[3];
+      nodes.push({ id: name, label: name, fileType: 'code', sourceFile: filePath, sourceLocation: location });
+
+      // extends
+      const extendsMatch = line.match(/\bextends\s+(\w+)/);
+      if (extendsMatch) {
+        edges.push({ source: name, target: extendsMatch[1], relation: 'extends', confidence: 'EXTRACTED', sourceFile: filePath, sourceLocation: location });
+      }
+      // implements
+      const implementsMatch = line.match(/\bimplements\s+([\w,\s]+)/);
+      if (implementsMatch) {
+        for (const impl of implementsMatch[1].split(',')) {
+          const implName = impl.trim().split(/\s/)[0];
+          if (implName) {
+            edges.push({ source: name, target: implName, relation: 'implements', confidence: 'EXTRACTED', sourceFile: filePath, sourceLocation: location });
+          }
+        }
+      }
+    }
+
+    // interface
+    const ifaceMatch = line.match(/^(export\s+)?interface\s+(\w+)/);
+    if (ifaceMatch) {
+      const name = ifaceMatch[2];
+      nodes.push({ id: name, label: name, fileType: 'code', sourceFile: filePath, sourceLocation: location });
+    }
+
+    // type alias
+    const typeMatch = line.match(/^(export\s+)?type\s+(\w+)\s*=/);
+    if (typeMatch) {
+      const name = typeMatch[2];
+      nodes.push({ id: name, label: name, fileType: 'code', sourceFile: filePath, sourceLocation: location });
+    }
+
+    // function
+    const funcMatch = line.match(/^(export\s+)?(default\s+)?(async\s+)?function\s+(\w+)/);
+    if (funcMatch) {
+      const name = funcMatch[4];
+      nodes.push({ id: name, label: name, fileType: 'code', sourceFile: filePath, sourceLocation: location });
+    }
+
+    // import
+    const importMatch = line.match(/^import\s+.*from\s+['"]([^'"]+)['"]/);
+    if (importMatch) {
+      edges.push({ source: basename(filePath), target: importMatch[1], relation: 'imports', confidence: 'EXTRACTED', sourceFile: filePath, sourceLocation: location });
+
+      // Named specifiers
+      const namedMatch = line.match(/\{([^}]+)\}/);
+      if (namedMatch) {
+        for (const spec of namedMatch[1].split(',')) {
+          const specName = spec.trim().split(/\s+as\s+/)[0].trim();
+          if (specName) {
+            edges.push({ source: filePath, target: specName, relation: 'imports', confidence: 'EXTRACTED', sourceFile: filePath, sourceLocation: location });
+          }
+        }
+      }
+    }
+  });
+
+  return { nodes, edges, filesProcessed: 1, fromCache: 0, errors: [] };
+}
+
+// ---- extractor implementation ----
+
+export const typescriptExtractor: LanguageExtractor = {
+  language: 'typescript',
+  extensions: ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'],
+
+  extract(filePath: string, content: string): ExtractionResult {
+    const lang = filePath.endsWith('.tsx') || filePath.endsWith('.jsx') ? 'tsx' : 'typescript';
+
+    const tsResult = extractWithTreeSitter(filePath, content, lang);
+    if (tsResult.nodes.length > 0 || tsResult.edges.length > 0 || tsResult.errors.length > 0) {
+      return tsResult;
+    }
+
+    // tree-sitter not available or produced nothing — fall back to regex
+    return extractWithRegex(filePath, content);
+  },
+};