@saluzi/codegraph 0.1.0

package/dist/extraction/svelte-extractor.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SvelteExtractor = void 0;
+const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
+const tree_sitter_1 = require("./tree-sitter");
+const grammars_1 = require("./grammars");
+/** Svelte 5 rune names — compiler builtins, not real functions */
+const SVELTE_RUNES = new Set([
+    '$props', '$state', '$derived', '$effect', '$bindable',
+    '$inspect', '$host', '$snippet',
+]);
+/**
+ * SvelteExtractor - Extracts code relationships from Svelte component files
+ *
+ * Svelte files are multi-language (script + template + style). Rather than
+ * parsing the full Svelte grammar, we extract the <script> block content
+ * and delegate it to the TypeScript/JavaScript TreeSitterExtractor.
+ *
+ * Also extracts function calls from template expressions (`{fn(...)}`) so
+ * cross-file call edges are captured even when calls live in markup.
+ *
+ * Every .svelte file produces a component node (Svelte components are always importable).
+ */
+class SvelteExtractor {
+    filePath;
+    source;
+    nodes = [];
+    edges = [];
+    unresolvedReferences = [];
+    errors = [];
+    constructor(filePath, source) {
+        this.filePath = filePath;
+        this.source = source;
+    }
+    /**
+     * Extract from Svelte source
+     */
+    extract() {
+        const startTime = Date.now();
+        try {
+            // Create component node for the .svelte file itself
+            const componentNode = this.createComponentNode();
+            // Extract and process script blocks
+            const scriptBlocks = this.extractScriptBlocks();
+            for (const block of scriptBlocks) {
+                this.processScriptBlock(block, componentNode.id);
+            }
+            // Extract function calls from template expressions ({fn(...)})
+            this.extractTemplateCalls(componentNode.id, scriptBlocks);
+            // Extract component usages from template (<ComponentName>)
+            this.extractTemplateComponents(componentNode.id);
+            // Filter out Svelte rune calls ($state, $props, $derived, etc.)
+            this.unresolvedReferences = this.unresolvedReferences.filter(ref => !SVELTE_RUNES.has(ref.referenceName));
+        }
+        catch (error) {
+            this.errors.push({
+                message: `Svelte extraction error: ${error instanceof Error ? error.message : String(error)}`,
+                severity: 'error',
+                code: 'parse_error',
+            });
+        }
+        return {
+            nodes: this.nodes,
+            edges: this.edges,
+            unresolvedReferences: this.unresolvedReferences,
+            errors: this.errors,
+            durationMs: Date.now() - startTime,
+        };
+    }
+    /**
+     * Create a component node for the .svelte file
+     */
+    createComponentNode() {
+        const lines = this.source.split('\n');
+        const fileName = this.filePath.split(/[/\\]/).pop() || this.filePath;
+        const componentName = fileName.replace(/\.svelte$/, '');
+        const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'component', componentName, 1);
+        const node = {
+            id,
+            kind: 'component',
+            name: componentName,
+            qualifiedName: `${this.filePath}::${componentName}`,
+            filePath: this.filePath,
+            language: 'svelte',
+            startLine: 1,
+            endLine: lines.length,
+            startColumn: 0,
+            endColumn: lines[lines.length - 1]?.length || 0,
+            isExported: true, // Svelte components are always importable
+            updatedAt: Date.now(),
+        };
+        this.nodes.push(node);
+        return node;
+    }
+    /**
+     * Extract <script> blocks from the Svelte source
+     */
+    extractScriptBlocks() {
+        const blocks = [];
+        const scriptRegex = /<script(\s[^>]*)?>(?<content>[\s\S]*?)<\/script>/g;
+        let match;
+        while ((match = scriptRegex.exec(this.source)) !== null) {
+            const attrs = match[1] || '';
+            const content = match.groups?.content || match[2] || '';
+            // Detect TypeScript from lang attribute
+            const isTypeScript = /lang\s*=\s*["'](ts|typescript)["']/.test(attrs);
+            // Detect module script
+            const isModule = /context\s*=\s*["']module["']/.test(attrs);
+            // Calculate start line of the script content (line after <script>)
+            const beforeScript = this.source.substring(0, match.index);
+            const scriptTagLine = (beforeScript.match(/\n/g) || []).length;
+            // The content starts on the line after the opening <script> tag
+            const openingTag = match[0].substring(0, match[0].indexOf('>') + 1);
+            const openingTagLines = (openingTag.match(/\n/g) || []).length;
+            const contentStartLine = scriptTagLine + openingTagLines + 1; // 0-indexed line
+            blocks.push({
+                content,
+                startLine: contentStartLine,
+                isModule,
+                isTypeScript,
+            });
+        }
+        return blocks;
+    }
+    /**
+     * Process a script block by delegating to TreeSitterExtractor
+     */
+    processScriptBlock(block, componentNodeId) {
+        const scriptLanguage = block.isTypeScript ? 'typescript' : 'javascript';
+        // Check if the script language parser is available
+        if (!(0, grammars_1.isLanguageSupported)(scriptLanguage)) {
+            this.errors.push({
+                message: `Parser for ${scriptLanguage} not available, cannot parse Svelte script block`,
+                severity: 'warning',
+            });
+            return;
+        }
+        // Delegate to TreeSitterExtractor
+        const extractor = new tree_sitter_1.TreeSitterExtractor(this.filePath, block.content, scriptLanguage);
+        const result = extractor.extract();
+        // Offset line numbers from script block back to .svelte file positions
+        for (const node of result.nodes) {
+            node.startLine += block.startLine;
+            node.endLine += block.startLine;
+            node.language = 'svelte'; // Mark as svelte, not TS/JS
+            this.nodes.push(node);
+            // Add containment edge from component to this node
+            this.edges.push({
+                source: componentNodeId,
+                target: node.id,
+                kind: 'contains',
+            });
+        }
+        // Offset edges (they reference line numbers)
+        for (const edge of result.edges) {
+            if (edge.line) {
+                edge.line += block.startLine;
+            }
+            this.edges.push(edge);
+        }
+        // Offset unresolved references
+        for (const ref of result.unresolvedReferences) {
+            ref.line += block.startLine;
+            ref.filePath = this.filePath;
+            ref.language = 'svelte';
+            this.unresolvedReferences.push(ref);
+        }
+        // Carry over errors
+        for (const error of result.errors) {
+            if (error.line) {
+                error.line += block.startLine;
+            }
+            this.errors.push(error);
+        }
+    }
+    /**
+     * Extract function calls from Svelte template expressions.
+     *
+     * In Svelte, many function calls happen in markup (e.g., `class={cn(...)}`),
+     * not inside `<script>` blocks. We scan the template portion for `{expression}`
+     * blocks and extract call patterns from them.
+     */
+    extractTemplateCalls(componentNodeId, _scriptBlocks) {
+        // Build a set of line ranges covered by <script> and <style> blocks so we skip them
+        const coveredRanges = [];
+        // Find all <script>...</script> and <style>...</style> ranges
+        const tagRegex = /<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1>/g;
+        let tagMatch;
+        while ((tagMatch = tagRegex.exec(this.source)) !== null) {
+            const startLine = (this.source.substring(0, tagMatch.index).match(/\n/g) || []).length;
+            const endLine = startLine + (tagMatch[0].match(/\n/g) || []).length;
+            coveredRanges.push([startLine, endLine]);
+        }
+        // Find template expressions: {...} outside of script/style blocks
+        // Matches curly-brace expressions, excluding Svelte block syntax ({#if}, {:else}, {/if}, {@html}, {@render})
+        const lines = this.source.split('\n');
+        const exprRegex = /\{([^}#/:@][^}]*)\}/g;
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            // Skip lines inside script/style blocks
+            if (coveredRanges.some(([start, end]) => lineIdx >= start && lineIdx <= end))
+                continue;
+            const line = lines[lineIdx];
+            let exprMatch;
+            while ((exprMatch = exprRegex.exec(line)) !== null) {
+                const expr = exprMatch[1];
+                // Extract function calls: identifiers followed by (
+                // Matches: cn(...), buttonVariants(...), obj.method(...)
+                const callRegex = /\b([a-zA-Z_$][\w$.]*)\s*\(/g;
+                let callMatch;
+                while ((callMatch = callRegex.exec(expr)) !== null) {
+                    const calleeName = callMatch[1];
+                    // Skip Svelte runes, control flow keywords, and common non-function patterns
+                    if (SVELTE_RUNES.has(calleeName))
+                        continue;
+                    if (calleeName === 'if' || calleeName === 'else' || calleeName === 'each' || calleeName === 'await')
+                        continue;
+                    this.unresolvedReferences.push({
+                        fromNodeId: componentNodeId,
+                        referenceName: calleeName,
+                        referenceKind: 'calls',
+                        line: lineIdx + 1, // 1-indexed
+                        column: exprMatch.index + callMatch.index,
+                        filePath: this.filePath,
+                        language: 'svelte',
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Extract component usages from the Svelte template.
+     *
+     * PascalCase tags like <Modal>, <Button />, <DevServerPreview> represent
+     * component instantiations — analogous to function calls in imperative code.
+     * Capturing these creates graph edges from parent to child components and
+     * gives codegraph_explore anchor points in the template markup.
+     */
+    extractTemplateComponents(componentNodeId) {
+        // Build ranges covered by <script> and <style> blocks to skip them
+        const coveredRanges = [];
+        const tagRegex = /<(script|style)(\s[^>]*)?>[\s\S]*?<\/\1>/g;
+        let tagMatch;
+        while ((tagMatch = tagRegex.exec(this.source)) !== null) {
+            const startLine = (this.source.substring(0, tagMatch.index).match(/\n/g) || []).length;
+            const endLine = startLine + (tagMatch[0].match(/\n/g) || []).length;
+            coveredRanges.push([startLine, endLine]);
+        }
+        const lines = this.source.split('\n');
+        // Match PascalCase opening/self-closing tags (closing tags </Foo> start with </ so won't match)
+        const componentTagRegex = /<([A-Z][a-zA-Z0-9_$]*)\b/g;
+        for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            if (coveredRanges.some(([start, end]) => lineIdx >= start && lineIdx <= end))
+                continue;
+            const line = lines[lineIdx];
+            let match;
+            while ((match = componentTagRegex.exec(line)) !== null) {
+                const componentName = match[1];
+                this.unresolvedReferences.push({
+                    fromNodeId: componentNodeId,
+                    referenceName: componentName,
+                    referenceKind: 'references',
+                    line: lineIdx + 1, // 1-indexed
+                    column: match.index + 1,
+                    filePath: this.filePath,
+                    language: 'svelte',
+                });
+            }
+        }
+    }
+}
+exports.SvelteExtractor = SvelteExtractor;
+//# sourceMappingURL=svelte-extractor.js.map

package/dist/extraction/tree-sitter-helpers.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Tree-sitter Shared Helpers
+ *
+ * Utility functions used by the core TreeSitterExtractor and per-language extractors.
+ * Extracted to a leaf module to avoid circular imports between tree-sitter.ts and languages/.
+ */
+import { Node as SyntaxNode } from 'web-tree-sitter'
+import { NodeKind } from '../types'
+/**
+ * Generate a unique node ID
+ *
+ * Uses a 32-character (128-bit) hash to avoid collisions when indexing
+ * large codebases with many files containing similar symbols.
+ */
+export declare function generateNodeId(
+  filePath: string,
+  kind: NodeKind,
+  name: string,
+  line: number,
+): string
+/**
+ * Extract text from a syntax node
+ */
+export declare function getNodeText(node: SyntaxNode, source: string): string
+/**
+ * Find a child node by field name
+ */
+export declare function getChildByField(
+  node: SyntaxNode,
+  fieldName: string,
+): SyntaxNode | null
+/**
+ * Get the docstring/comment preceding a node
+ */
+export declare function getPrecedingDocstring(
+  node: SyntaxNode,
+  source: string,
+): string | undefined
+//# sourceMappingURL=tree-sitter-helpers.d.ts.map

package/dist/extraction/tree-sitter-helpers.js

@@ -0,0 +1,103 @@
+"use strict";
+/**
+ * Tree-sitter Shared Helpers
+ *
+ * Utility functions used by the core TreeSitterExtractor and per-language extractors.
+ * Extracted to a leaf module to avoid circular imports between tree-sitter.ts and languages/.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNodeId = generateNodeId;
+exports.getNodeText = getNodeText;
+exports.getChildByField = getChildByField;
+exports.getPrecedingDocstring = getPrecedingDocstring;
+const crypto = __importStar(require("crypto"));
+/**
+ * Generate a unique node ID
+ *
+ * Uses a 32-character (128-bit) hash to avoid collisions when indexing
+ * large codebases with many files containing similar symbols.
+ */
+function generateNodeId(filePath, kind, name, line) {
+    const hash = crypto
+        .createHash('sha256')
+        .update(`${filePath}:${kind}:${name}:${line}`)
+        .digest('hex')
+        .substring(0, 32);
+    return `${kind}:${hash}`;
+}
+/**
+ * Extract text from a syntax node
+ */
+function getNodeText(node, source) {
+    return source.substring(node.startIndex, node.endIndex);
+}
+/**
+ * Find a child node by field name
+ */
+function getChildByField(node, fieldName) {
+    return node.childForFieldName(fieldName);
+}
+/**
+ * Get the docstring/comment preceding a node
+ */
+function getPrecedingDocstring(node, source) {
+    let sibling = node.previousNamedSibling;
+    const comments = [];
+    while (sibling) {
+        if (sibling.type === 'comment' ||
+            sibling.type === 'line_comment' ||
+            sibling.type === 'block_comment' ||
+            sibling.type === 'documentation_comment') {
+            comments.unshift(getNodeText(sibling, source));
+            sibling = sibling.previousNamedSibling;
+        }
+        else {
+            break;
+        }
+    }
+    if (comments.length === 0)
+        return undefined;
+    // Clean up comment markers
+    return comments
+        .map((c) => c
+        .replace(/^\/\*\*?|\*\/$/g, '')
+        .replace(/^\/\/\s?/gm, '')
+        .replace(/^\s*\*\s?/gm, '')
+        .trim())
+        .join('\n')
+        .trim();
+}
+//# sourceMappingURL=tree-sitter-helpers.js.map

package/dist/extraction/tree-sitter-types.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Tree-sitter Extraction Types
+ *
+ * Defines the LanguageExtractor interface and related types used by
+ * the core TreeSitterExtractor and per-language extraction configs.
+ * Extracted to a leaf module to avoid circular imports.
+ */
+import { Node as SyntaxNode } from 'web-tree-sitter'
+import { Node, NodeKind, UnresolvedReference } from '../types'
+/**
+ * Information returned by a language's extractImport hook.
+ */
+export interface ImportInfo {
+  /** The module/package name being imported */
+  moduleName: string
+  /** Full import statement text for display */
+  signature: string
+  /** If true, the hook already created unresolved references itself */
+  handledRefs?: boolean
+}
+/**
+ * Information about a single variable within a declaration.
+ * Returned by a language's extractVariables hook.
+ */
+export interface VariableInfo {
+  /** Variable name */
+  name: string
+  /** Node kind: 'variable' or 'constant' */
+  kind: NodeKind
+  /** Optional signature string */
+  signature?: string
+  /** If set, this declarator is actually a function and should be extracted as such */
+  delegateToFunction?: SyntaxNode
+  /** The AST node to use for positioning (may differ from the declaration node) */
+  positionNode?: SyntaxNode
+}
+/**
+ * Context object passed to language hooks that need to call back into the core extractor.
+ * Provides a controlled API surface — hooks can create nodes, visit children, and add
+ * references without accessing the full TreeSitterExtractor internals.
+ */
+export interface ExtractorContext {
+  /** Create a node and add it to the extraction result */
+  createNode(
+    kind: NodeKind,
+    name: string,
+    node: SyntaxNode,
+    extra?: Partial<Node>,
+  ): Node | null
+  /** Visit a child node (dispatches through the standard visitNode logic) */
+  visitNode(node: SyntaxNode): void
+  /** Visit a function body to extract calls */
+  visitFunctionBody(body: SyntaxNode, functionId: string): void
+  /** Add an unresolved reference */
+  addUnresolvedReference(ref: UnresolvedReference): void
+  /** Push a node ID onto the scope stack (for containment/qualified name building) */
+  pushScope(nodeId: string): void
+  /** Pop the last node ID from the scope stack */
+  popScope(): void
+  /** Current file path */
+  readonly filePath: string
+  /** Current source text */
+  readonly source: string
+  /** Stack of parent node IDs (current scope) */
+  readonly nodeStack: readonly string[]
+  /** All nodes extracted so far */
+  readonly nodes: readonly Node[]
+}
+/**
+ * Language-specific extraction configuration.
+ *
+ * Each supported language provides an implementation of this interface
+ * that configures which AST node types to look for and how to extract
+ * language-specific details like signatures, visibility, and imports.
+ */
+export interface LanguageExtractor {
+  /** Node types that represent functions */
+  functionTypes: string[]
+  /** Node types that represent classes */
+  classTypes: string[]
+  /** Node types that represent methods */
+  methodTypes: string[]
+  /** Node types that represent interfaces/protocols/traits */
+  interfaceTypes: string[]
+  /** Node types that represent structs */
+  structTypes: string[]
+  /** Node types that represent enums */
+  enumTypes: string[]
+  /** Node types that represent enum members/cases (e.g. Swift: 'enum_entry', Rust: 'enum_variant') */
+  enumMemberTypes?: string[]
+  /** Node types that represent type aliases (e.g. `type X = ...`) */
+  typeAliasTypes: string[]
+  /** Node types that represent imports */
+  importTypes: string[]
+  /** Node types that represent function calls */
+  callTypes: string[]
+  /** Node types that represent variable declarations (const, let, var, etc.) */
+  variableTypes: string[]
+  /** Node types that represent class fields (extracted as 'field' kind inside class bodies) */
+  fieldTypes?: string[]
+  /** Node types that represent class properties (extracted as 'property' kind inside class bodies) */
+  propertyTypes?: string[]
+  /** Field name for identifier/name */
+  nameField: string
+  /** Field name for body */
+  bodyField: string
+  /** Field name for parameters */
+  paramsField: string
+  /** Field name for return type */
+  returnField?: string
+  /** Extract signature from node */
+  getSignature?: (node: SyntaxNode, source: string) => string | undefined
+  /** Extract visibility from node */
+  getVisibility?: (
+    node: SyntaxNode,
+  ) => 'public' | 'private' | 'protected' | 'internal' | undefined
+  /** Check if node is exported */
+  isExported?: (node: SyntaxNode, source: string) => boolean
+  /** Check if node is async */
+  isAsync?: (node: SyntaxNode) => boolean
+  /** Check if node is static */
+  isStatic?: (node: SyntaxNode) => boolean
+  /** Check if variable declaration is a constant (const vs let/var) */
+  isConst?: (node: SyntaxNode) => boolean
+  /** Additional node types to treat as class declarations (e.g. Dart: 'mixin_declaration') */
+  extraClassNodeTypes?: string[]
+  /** Whether methods can be top-level without enclosing class (Go: true) */
+  methodsAreTopLevel?: boolean
+  /** NodeKind to use for interface-like declarations (Rust: 'trait'). Default: 'interface' */
+  interfaceKind?: NodeKind
+  /**
+   * Custom node visitor. Return true if the node was fully handled (skip default dispatch).
+   * Used by languages with fundamentally different AST structures (e.g. Pascal).
+   */
+  visitNode?: (node: SyntaxNode, ctx: ExtractorContext) => boolean
+  /**
+   * Classify a class_declaration node when the grammar reuses one node type
+   * for multiple concepts (e.g. Swift uses class_declaration for classes, structs, and enums).
+   */
+  classifyClassNode?: (
+    node: SyntaxNode,
+  ) => 'class' | 'struct' | 'enum' | 'interface' | 'trait'
+  /**
+   * Resolve the body node for a function/method/class when it's not a child field.
+   * (e.g. Dart puts function_body as a sibling, not a child.)
+   */
+  resolveBody?: (node: SyntaxNode, bodyField: string) => SyntaxNode | null
+  /**
+   * Extract import information from an import node.
+   * Return null if the node isn't a recognized import form.
+   */
+  extractImport?: (node: SyntaxNode, source: string) => ImportInfo | null
+  /**
+   * Extract variable declarations from a variable declaration node.
+   * Returns info about each declared variable, allowing the core to create nodes.
+   */
+  extractVariables?: (node: SyntaxNode, source: string) => VariableInfo[]
+  /**
+   * Extract receiver/owner type name from a method declaration.
+   * Used by Go to get the struct receiver (e.g., "scrapeLoop" from "func (sl *scrapeLoop) run()").
+   * When present, the receiver type is included in the qualified name for better searchability.
+   */
+  getReceiverType?: (node: SyntaxNode, source: string) => string | undefined
+  /**
+   * Resolve the actual node kind for a type alias declaration.
+   * Used by Go where `type_spec` is the named declaration wrapper for structs/interfaces:
+   *   `type Foo struct { ... }` → type_spec (name: "Foo") → struct_type
+   * Returns 'struct', 'interface', etc. to override the default 'type_alias' kind,
+   * or undefined to keep it as a type alias.
+   */
+  resolveTypeAliasKind?: (
+    node: SyntaxNode,
+    source: string,
+  ) => NodeKind | undefined
+  /**
+   * Check if a function/method name is a misparse artifact that should be skipped.
+   * Used by C/C++ where macros (e.g. NLOHMANN_JSON_NAMESPACE_BEGIN) cause tree-sitter
+   * to misparse namespace blocks as function_definitions. When this returns true,
+   * the function node is NOT created, but the body is still visited for calls and
+   * structural nodes (classes, structs, enums).
+   */
+  isMisparsedFunction?: (name: string, node: SyntaxNode) => boolean
+  /**
+   * Detect bare method calls that don't use call expression syntax.
+   * Used by Ruby where `reset` (no parens, no receiver) is a method call but
+   * tree-sitter parses it as a plain `identifier` node instead of `call`/`method_call`.
+   * Returns the callee name if this node is a bare call, or undefined if not.
+   */
+  extractBareCall?: (node: SyntaxNode, source: string) => string | undefined
+}
+//# sourceMappingURL=tree-sitter-types.d.ts.map

package/dist/extraction/tree-sitter-types.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Tree-sitter Extraction Types
+ *
+ * Defines the LanguageExtractor interface and related types used by
+ * the core TreeSitterExtractor and per-language extraction configs.
+ * Extracted to a leaf module to avoid circular imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tree-sitter-types.js.map