@saluzi/codegraph 0.1.0 → 0.2.0

package/dist/extraction/languages/typescript.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.typescriptExtractor = void 0;
-const tree_sitter_helpers_1 = require("../tree-sitter-helpers");
-exports.typescriptExtractor = {
-    functionTypes: ['function_declaration', 'arrow_function', 'function_expression'],
-    classTypes: ['class_declaration', 'abstract_class_declaration'],
-    methodTypes: ['method_definition', 'public_field_definition'],
-    interfaceTypes: ['interface_declaration'],
-    structTypes: [],
-    enumTypes: ['enum_declaration'],
-    enumMemberTypes: ['property_identifier', 'enum_assignment'],
-    typeAliasTypes: ['type_alias_declaration'],
-    importTypes: ['import_statement'],
-    callTypes: ['call_expression'],
-    variableTypes: ['lexical_declaration', 'variable_declaration'],
-    nameField: 'name',
-    bodyField: 'body',
-    resolveBody: (node, bodyField) => {
-        // public_field_definition (arrow function class fields) nest the body inside
-        // an arrow_function or function_expression child:
-        //   public_field_definition → arrow_function → body (statement_block)
-        // Also handles wrapper patterns like: field = withBatchedUpdates((e) => { ... })
-        //   public_field_definition → call_expression → arguments → arrow_function → body
-        if (node.type === 'public_field_definition') {
-            for (let i = 0; i < node.namedChildCount; i++) {
-                const child = node.namedChild(i);
-                if (!child)
-                    continue;
-                if (child.type === 'arrow_function' || child.type === 'function_expression') {
-                    return (0, tree_sitter_helpers_1.getChildByField)(child, bodyField);
-                }
-                // Check inside call_expression arguments (HOF wrappers like throttle, debounce)
-                if (child.type === 'call_expression') {
-                    const args = (0, tree_sitter_helpers_1.getChildByField)(child, 'arguments');
-                    if (args) {
-                        for (let j = 0; j < args.namedChildCount; j++) {
-                            const arg = args.namedChild(j);
-                            if (arg && (arg.type === 'arrow_function' || arg.type === 'function_expression')) {
-                                return (0, tree_sitter_helpers_1.getChildByField)(arg, bodyField);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return null;
-    },
-    paramsField: 'parameters',
-    returnField: 'return_type',
-    getSignature: (node, source) => {
-        const params = (0, tree_sitter_helpers_1.getChildByField)(node, 'parameters');
-        const returnType = (0, tree_sitter_helpers_1.getChildByField)(node, 'return_type');
-        if (!params)
-            return undefined;
-        let sig = (0, tree_sitter_helpers_1.getNodeText)(params, source);
-        if (returnType) {
-            sig += ': ' + (0, tree_sitter_helpers_1.getNodeText)(returnType, source).replace(/^:\s*/, '');
-        }
-        return sig;
-    },
-    getVisibility: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'accessibility_modifier') {
-                const text = child.text;
-                if (text === 'public')
-                    return 'public';
-                if (text === 'private')
-                    return 'private';
-                if (text === 'protected')
-                    return 'protected';
-            }
-        }
-        return undefined;
-    },
-    isExported: (node, _source) => {
-        // Walk the parent chain to find an export_statement ancestor.
-        // This correctly handles deeply nested nodes like arrow functions
-        // inside variable declarations: `export const X = () => { ... }`
-        // where the arrow_function is 3 levels deep under export_statement.
-        let current = node.parent;
-        while (current) {
-            if (current.type === 'export_statement')
-                return true;
-            current = current.parent;
-        }
-        return false;
-    },
-    isAsync: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'async')
-                return true;
-        }
-        return false;
-    },
-    isStatic: (node) => {
-        for (let i = 0; i < node.childCount; i++) {
-            const child = node.child(i);
-            if (child?.type === 'static')
-                return true;
-        }
-        return false;
-    },
-    isConst: (node) => {
-        // For lexical_declaration, check if it's 'const' or 'let'
-        // For variable_declaration, it's always 'var'
-        if (node.type === 'lexical_declaration') {
-            for (let i = 0; i < node.childCount; i++) {
-                const child = node.child(i);
-                if (child?.type === 'const')
-                    return true;
-            }
-        }
-        return false;
-    },
-    extractImport: (node, source) => {
-        const sourceField = node.childForFieldName('source');
-        if (sourceField) {
-            const moduleName = source.substring(sourceField.startIndex, sourceField.endIndex).replace(/['"]/g, '');
-            if (moduleName) {
-                return { moduleName, signature: source.substring(node.startIndex, node.endIndex).trim() };
-            }
-        }
-        return null;
-    },
-};
-//# sourceMappingURL=typescript.js.map

package/dist/extraction/liquid-extractor.d.ts

@@ -1,52 +0,0 @@
-import { ExtractionResult } from '../types'
-/**
- * LiquidExtractor - Extracts relationships from Liquid template files
- *
- * Liquid is a templating language (used by Shopify, Jekyll, etc.) that doesn't
- * have traditional functions or classes. Instead, we extract:
- * - Section references ({% section 'name' %})
- * - Snippet references ({% render 'name' %} and {% include 'name' %})
- * - Schema blocks ({% schema %}...{% endschema %})
- */
-export declare class LiquidExtractor {
-  private filePath
-  private source
-  private nodes
-  private edges
-  private unresolvedReferences
-  private errors
-  constructor(filePath: string, source: string)
-  /**
-   * Extract from Liquid source
-   */
-  extract(): ExtractionResult
-  /**
-   * Create a file node for the Liquid template
-   */
-  private createFileNode
-  /**
-   * Extract {% render 'snippet' %} and {% include 'snippet' %} references
-   */
-  private extractSnippetReferences
-  /**
-   * Extract {% section 'name' %} references
-   */
-  private extractSectionReferences
-  /**
-   * Extract {% schema %}...{% endschema %} blocks
-   */
-  private extractSchema
-  /**
-   * Extract {% assign var = value %} statements
-   */
-  private extractAssignments
-  /**
-   * Get the line number for a character index
-   */
-  private getLineNumber
-  /**
-   * Get the character index of the start of a line
-   */
-  private getLineStart
-}
-//# sourceMappingURL=liquid-extractor.d.ts.map

package/dist/extraction/liquid-extractor.js

@@ -1,313 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiquidExtractor = void 0;
-const tree_sitter_helpers_1 = require("./tree-sitter-helpers");
-/**
- * LiquidExtractor - Extracts relationships from Liquid template files
- *
- * Liquid is a templating language (used by Shopify, Jekyll, etc.) that doesn't
- * have traditional functions or classes. Instead, we extract:
- * - Section references ({% section 'name' %})
- * - Snippet references ({% render 'name' %} and {% include 'name' %})
- * - Schema blocks ({% schema %}...{% endschema %})
- */
-class LiquidExtractor {
-    filePath;
-    source;
-    nodes = [];
-    edges = [];
-    unresolvedReferences = [];
-    errors = [];
-    constructor(filePath, source) {
-        this.filePath = filePath;
-        this.source = source;
-    }
-    /**
-     * Extract from Liquid source
-     */
-    extract() {
-        const startTime = Date.now();
-        try {
-            // Create file node
-            const fileNode = this.createFileNode();
-            // Extract render/include statements (snippet references)
-            this.extractSnippetReferences(fileNode.id);
-            // Extract section references
-            this.extractSectionReferences(fileNode.id);
-            // Extract schema block
-            this.extractSchema(fileNode.id);
-            // Extract assign statements as variables
-            this.extractAssignments(fileNode.id);
-        }
-        catch (error) {
-            this.errors.push({
-                message: `Liquid 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 file node for the Liquid template
-     */
-    createFileNode() {
-        const lines = this.source.split('\n');
-        const id = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'file', this.filePath, 1);
-        const fileNode = {
-            id,
-            kind: 'file',
-            name: this.filePath.split('/').pop() || this.filePath,
-            qualifiedName: this.filePath,
-            filePath: this.filePath,
-            language: 'liquid',
-            startLine: 1,
-            endLine: lines.length,
-            startColumn: 0,
-            endColumn: lines[lines.length - 1]?.length || 0,
-            updatedAt: Date.now(),
-        };
-        this.nodes.push(fileNode);
-        return fileNode;
-    }
-    /**
-     * Extract {% render 'snippet' %} and {% include 'snippet' %} references
-     */
-    extractSnippetReferences(fileNodeId) {
-        // Match {% render 'name' %} or {% include 'name' %} with optional parameters
-        const renderRegex = /\{%[-]?\s*(render|include)\s+['"]([^'"]+)['"]/g;
-        let match;
-        while ((match = renderRegex.exec(this.source)) !== null) {
-            const [fullMatch, tagType, snippetName] = match;
-            const line = this.getLineNumber(match.index);
-            // Create an import node for searchability
-            const importNodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'import', snippetName, line);
-            const importNode = {
-                id: importNodeId,
-                kind: 'import',
-                name: snippetName,
-                qualifiedName: `${this.filePath}::import:${snippetName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                signature: fullMatch,
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(importNode);
-            // Add containment edge from file to import
-            this.edges.push({
-                source: fileNodeId,
-                target: importNodeId,
-                kind: 'contains',
-            });
-            // Create a component node for the snippet reference
-            const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'component', `${tagType}:${snippetName}`, line);
-            const node = {
-                id: nodeId,
-                kind: 'component',
-                name: snippetName,
-                qualifiedName: `${this.filePath}::${tagType}:${snippetName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-            // Add unresolved reference to the snippet file
-            this.unresolvedReferences.push({
-                fromNodeId: fileNodeId,
-                referenceName: `snippets/${snippetName}.liquid`,
-                referenceKind: 'references',
-                line,
-                column: match.index - this.getLineStart(line),
-            });
-        }
-    }
-    /**
-     * Extract {% section 'name' %} references
-     */
-    extractSectionReferences(fileNodeId) {
-        // Match {% section 'name' %}
-        const sectionRegex = /\{%[-]?\s*section\s+['"]([^'"]+)['"]/g;
-        let match;
-        while ((match = sectionRegex.exec(this.source)) !== null) {
-            const [fullMatch, sectionName] = match;
-            const line = this.getLineNumber(match.index);
-            // Create an import node for searchability
-            const importNodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'import', sectionName, line);
-            const importNode = {
-                id: importNodeId,
-                kind: 'import',
-                name: sectionName,
-                qualifiedName: `${this.filePath}::import:${sectionName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                signature: fullMatch,
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(importNode);
-            // Add containment edge from file to import
-            this.edges.push({
-                source: fileNodeId,
-                target: importNodeId,
-                kind: 'contains',
-            });
-            // Create a component node for the section reference
-            const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'component', `section:${sectionName}`, line);
-            const node = {
-                id: nodeId,
-                kind: 'component',
-                name: sectionName,
-                qualifiedName: `${this.filePath}::section:${sectionName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + fullMatch.length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-            // Add unresolved reference to the section file
-            this.unresolvedReferences.push({
-                fromNodeId: fileNodeId,
-                referenceName: `sections/${sectionName}.liquid`,
-                referenceKind: 'references',
-                line,
-                column: match.index - this.getLineStart(line),
-            });
-        }
-    }
-    /**
-     * Extract {% schema %}...{% endschema %} blocks
-     */
-    extractSchema(fileNodeId) {
-        // Match {% schema %}...{% endschema %}
-        const schemaRegex = /\{%[-]?\s*schema\s*[-]?%\}([\s\S]*?)\{%[-]?\s*endschema\s*[-]?%\}/g;
-        let match;
-        while ((match = schemaRegex.exec(this.source)) !== null) {
-            const [fullMatch, schemaContent] = match;
-            const startLine = this.getLineNumber(match.index);
-            const endLine = this.getLineNumber(match.index + fullMatch.length);
-            // Try to parse the schema JSON to get the name
-            let schemaName = 'schema';
-            try {
-                const schemaJson = JSON.parse(schemaContent);
-                if (schemaJson.name) {
-                    // Shopify schema names can be translation objects like {"en": "...", "fr": "..."}
-                    schemaName = typeof schemaJson.name === 'string'
-                        ? schemaJson.name
-                        : schemaJson.name.en || Object.values(schemaJson.name)[0] || 'schema';
-                }
-            }
-            catch {
-                // Schema isn't valid JSON, use default name
-            }
-            // Create a node for the schema
-            const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'constant', `schema:${schemaName}`, startLine);
-            const node = {
-                id: nodeId,
-                kind: 'constant',
-                name: schemaName,
-                qualifiedName: `${this.filePath}::schema:${schemaName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine,
-                endLine,
-                startColumn: match.index - this.getLineStart(startLine),
-                endColumn: 0,
-                docstring: schemaContent?.trim().substring(0, 200), // Store first 200 chars as docstring
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-        }
-    }
-    /**
-     * Extract {% assign var = value %} statements
-     */
-    extractAssignments(fileNodeId) {
-        // Match {% assign variable_name = ... %}
-        const assignRegex = /\{%[-]?\s*assign\s+(\w+)\s*=/g;
-        let match;
-        while ((match = assignRegex.exec(this.source)) !== null) {
-            const [, variableName] = match;
-            const line = this.getLineNumber(match.index);
-            // Create a variable node
-            const nodeId = (0, tree_sitter_helpers_1.generateNodeId)(this.filePath, 'variable', variableName, line);
-            const node = {
-                id: nodeId,
-                kind: 'variable',
-                name: variableName,
-                qualifiedName: `${this.filePath}::${variableName}`,
-                filePath: this.filePath,
-                language: 'liquid',
-                startLine: line,
-                endLine: line,
-                startColumn: match.index - this.getLineStart(line),
-                endColumn: match.index - this.getLineStart(line) + match[0].length,
-                updatedAt: Date.now(),
-            };
-            this.nodes.push(node);
-            // Add containment edge from file
-            this.edges.push({
-                source: fileNodeId,
-                target: nodeId,
-                kind: 'contains',
-            });
-        }
-    }
-    /**
-     * Get the line number for a character index
-     */
-    getLineNumber(index) {
-        const substring = this.source.substring(0, index);
-        return (substring.match(/\n/g) || []).length + 1;
-    }
-    /**
-     * Get the character index of the start of a line
-     */
-    getLineStart(lineNumber) {
-        const lines = this.source.split('\n');
-        let index = 0;
-        for (let i = 0; i < lineNumber - 1 && i < lines.length; i++) {
-            index += lines[i].length + 1; // +1 for newline
-        }
-        return index;
-    }
-}
-exports.LiquidExtractor = LiquidExtractor;
-//# sourceMappingURL=liquid-extractor.js.map

package/dist/extraction/parse-worker.d.ts

@@ -1,8 +0,0 @@
-/**
- * Parse Worker
- *
- * Runs tree-sitter parsing in a separate thread so the main thread
- * stays unblocked and the UI animation renders smoothly.
- */
-export {}
-//# sourceMappingURL=parse-worker.d.ts.map

package/dist/extraction/parse-worker.js

@@ -1,94 +0,0 @@
-"use strict";
-/**
- * Parse Worker
- *
- * Runs tree-sitter parsing in a separate thread so the main thread
- * stays unblocked and the UI animation renders smoothly.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const worker_threads_1 = require("worker_threads");
-const tree_sitter_1 = require("./tree-sitter");
-const grammars_1 = require("./grammars");
-// Emscripten prints `Aborted()` (and a follow-up RuntimeError diag
-// line) directly to stderr when WASM aborts — before the JS catch
-// runs. Worker stderr is inherited by the parent, so each crash leaks
-// a noise line to the user's terminal even though the JS layer
-// already handles the failure cleanly. Filter these specific lines
-// out at the source. Real diagnostic output (anything we log
-// ourselves) goes through console.* / parentPort and is unaffected.
-//
-// Caveats deliberately accepted:
-//   - Per-call match: each `write()` call is matched in isolation.
-//     If Emscripten ever splits `Aborted(` across two write()s (it
-//     doesn't today — synchronous abort prints the whole line at
-//     once via libc puts) the first fragment would leak. Buffering
-//     across calls would add complexity for a hypothetical case.
-//   - Substring exactness: the prefix `Aborted(` is the literal
-//     Emscripten signature. Any user code that legitimately writes
-//     a stderr line starting with that prefix would also be filtered;
-//     in practice no real diagnostic does.
-{
-    const realWrite = process.stderr.write.bind(process.stderr);
-    process.stderr.write = ((chunk, encoding, cb) => {
-        const s = typeof chunk === 'string' ? chunk : Buffer.from(chunk).toString('utf-8');
-        if (s.startsWith('Aborted(') ||
-            s.includes('Build with -sASSERTIONS for more info')) {
-            // Honour the Writable stream contract: callbacks must always
-            // fire even when the write is suppressed, or upstream code
-            // waiting on the drain signal would hang. Both overload forms
-            // are handled (`(chunk, cb)` and `(chunk, encoding, cb)`).
-            if (typeof encoding === 'function')
-                encoding();
-            else if (cb)
-                cb();
-            return true;
-        }
-        return realWrite(chunk, encoding, cb);
-    });
-}
-const PARSER_RESET_INTERVAL = 5000;
-const parseCounts = new Map();
-worker_threads_1.parentPort.on('message', async (msg) => {
-    if (msg.type === 'load-grammars') {
-        await (0, grammars_1.loadGrammarsForLanguages)(msg.languages);
-        worker_threads_1.parentPort.postMessage({ type: 'grammars-loaded' });
-    }
-    else if (msg.type === 'parse') {
-        const { id, filePath, content, frameworkNames } = msg;
-        try {
-            const language = (0, grammars_1.detectLanguage)(filePath, content);
-            const result = (0, tree_sitter_1.extractFromSource)(filePath, content, language, frameworkNames);
-            // Periodic parser reset to reclaim WASM heap memory
-            const count = (parseCounts.get(language) ?? 0) + 1;
-            parseCounts.set(language, count);
-            if (count % PARSER_RESET_INTERVAL === 0) {
-                (0, grammars_1.resetParser)(language);
-            }
-            worker_threads_1.parentPort.postMessage({ type: 'parse-result', id, result });
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            // WASM memory errors leave the module in a corrupted state — all
-            // subsequent parses would also fail (cascading failures). Crash the
-            // worker so the main thread spawns a fresh one with a clean heap.
-            if (message.includes('memory access out of bounds') || message.includes('out of memory')) {
-                process.exit(1);
-            }
-            worker_threads_1.parentPort.postMessage({
-                type: 'parse-result',
-                id,
-                result: {
-                    nodes: [],
-                    edges: [],
-                    unresolvedReferences: [],
-                    errors: [{ message: `Parse worker error: ${message}`, filePath: filePath, severity: 'error', code: 'parse_error' }],
-                    durationMs: 0,
-                },
-            });
-        }
-    }
-    else if (msg.type === 'shutdown') {
-        worker_threads_1.parentPort.postMessage({ type: 'shutdown-ack' });
-    }
-});
-//# sourceMappingURL=parse-worker.js.map

package/dist/extraction/svelte-extractor.d.ts

@@ -1,56 +0,0 @@
-import { ExtractionResult } from '../types'
-/**
- * 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).
- */
-export declare class SvelteExtractor {
-  private filePath
-  private source
-  private nodes
-  private edges
-  private unresolvedReferences
-  private errors
-  constructor(filePath: string, source: string)
-  /**
-   * Extract from Svelte source
-   */
-  extract(): ExtractionResult
-  /**
-   * Create a component node for the .svelte file
-   */
-  private createComponentNode
-  /**
-   * Extract <script> blocks from the Svelte source
-   */
-  private extractScriptBlocks
-  /**
-   * Process a script block by delegating to TreeSitterExtractor
-   */
-  private processScriptBlock
-  /**
-   * 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.
-   */
-  private extractTemplateCalls
-  /**
-   * 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.
-   */
-  private extractTemplateComponents
-}
-//# sourceMappingURL=svelte-extractor.d.ts.map