@colbymchenry/codegraph 0.9.7 → 0.9.9

package/dist/extraction/grammars.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Grammar Loading and Caching
+ *
+ * Uses web-tree-sitter (WASM) for universal cross-platform support.
+ * Grammars are loaded lazily — only languages actually present in the project
+ * are compiled, keeping V8 WASM memory pressure low on large codebases.
+ */
+import { Parser } from 'web-tree-sitter';
+import { Language } from '../types';
+export type GrammarLanguage = Exclude<Language, 'svelte' | 'vue' | 'liquid' | 'yaml' | 'twig' | 'xml' | 'properties' | 'unknown'>;
+/**
+ * File extension to Language mapping
+ */
+export declare const EXTENSION_MAP: Record<string, Language>;
+/**
+ * Whether a file is one CodeGraph can parse, based purely on its extension.
+ * This is the single source of truth for "should we index this file" — derived
+ * from EXTENSION_MAP so parser support and indexing selection never drift.
+ */
+export declare function isSourceFile(filePath: string): boolean;
+/**
+ * Play Framework routes file: the extensionless `conf/routes` (and included
+ * `conf/*.routes`). No grammar — route extraction is done by the Play framework
+ * resolver, so it's processed through the no-grammar (`yaml`-style) path.
+ */
+export declare function isPlayRoutesFile(filePath: string): boolean;
+/**
+ * Initialize the tree-sitter WASM runtime. Must be called before loading grammars.
+ * Does NOT load any grammar WASM files — use loadGrammarsForLanguages() for that.
+ * Idempotent — safe to call multiple times.
+ */
+export declare function initGrammars(): Promise<void>;
+/**
+ * Load grammar WASM files for specific languages only.
+ * Skips languages that are already loaded or have no WASM grammar.
+ * Must be called after initGrammars().
+ */
+export declare function loadGrammarsForLanguages(languages: Language[]): Promise<void>;
+/**
+ * Load ALL grammar WASM files. Convenience function for tests and
+ * backward compatibility. Prefer loadGrammarsForLanguages() in production.
+ */
+export declare function loadAllGrammars(): Promise<void>;
+/**
+ * Check if grammars have been initialized
+ */
+export declare function isGrammarsInitialized(): boolean;
+/**
+ * Get a parser for the specified language.
+ * Returns synchronously from pre-loaded cache.
+ */
+export declare function getParser(language: Language): Parser | null;
+/**
+ * Detect language from file extension
+ */
+export declare function detectLanguage(filePath: string, source?: string): Language;
+/**
+ * Check if a language is supported (has a grammar defined).
+ * Returns true if the grammar exists, even if not yet loaded.
+ */
+export declare function isLanguageSupported(language: Language): boolean;
+/**
+ * Check if a grammar has been loaded and is ready for parsing.
+ */
+export declare function isGrammarLoaded(language: Language): boolean;
+/**
+ * Languages tracked at the file-record level only: parsing emits zero symbol
+ * nodes, but the file is still stored (and framework resolvers may add per-file
+ * references later, e.g. Drupal routing yml, Spring `@Value` against
+ * application.properties). This is the canonical set behind the no-symbol
+ * branch in `tree-sitter.ts`; `xml` is intentionally excluded because its
+ * MyBatis extractor emits a file node. Callers use this to count such files as
+ * indexed rather than skipped, so it must stay in sync with that branch.
+ */
+export declare function isFileLevelOnlyLanguage(language: Language): boolean;
+/**
+ * Get all supported languages (those with grammar definitions).
+ */
+export declare function getSupportedLanguages(): Language[];
+/**
+ * Reset the cached parser for a language to reclaim WASM heap memory.
+ * The tree-sitter WASM runtime accumulates fragmented memory over thousands
+ * of parses. Deleting and recreating the Parser instance forces the WASM
+ * heap to reset, preventing "memory access out of bounds" crashes in
+ * large repos.
+ */
+export declare function resetParser(language: Language): void;
+/**
+ * Clear parser/grammar caches (useful for testing)
+ */
+export declare function clearParserCache(): void;
+/**
+ * Report grammars that failed to load.
+ */
+export declare function getUnavailableGrammarErrors(): Partial<Record<Language, string>>;
+/**
+ * Get language display name
+ */
+export declare function getLanguageDisplayName(language: Language): string;
+//# sourceMappingURL=grammars.d.ts.map

package/dist/extraction/index.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Extraction Orchestrator
+ *
+ * Coordinates file scanning, parsing, and database storage.
+ */
+import * as fs from 'fs';
+import { ExtractionResult, ExtractionError } from '../types';
+import { QueryBuilder } from '../db/queries';
+import { Ignore } from 'ignore';
+/**
+ * Progress callback for indexing operations
+ */
+export interface IndexProgress {
+    phase: 'scanning' | 'parsing' | 'storing' | 'resolving';
+    current: number;
+    total: number;
+    currentFile?: string;
+}
+/**
+ * Result of an indexing operation
+ */
+export interface IndexResult {
+    success: boolean;
+    filesIndexed: number;
+    filesSkipped: number;
+    filesErrored: number;
+    nodesCreated: number;
+    edgesCreated: number;
+    errors: ExtractionError[];
+    durationMs: number;
+}
+/**
+ * Result of a sync operation
+ */
+export interface SyncResult {
+    filesChecked: number;
+    filesAdded: number;
+    filesModified: number;
+    filesRemoved: number;
+    nodesUpdated: number;
+    durationMs: number;
+    changedFilePaths?: string[];
+}
+/**
+ * Calculate SHA256 hash of file contents
+ */
+export declare function hashContent(content: string): string;
+/**
+ * An `ignore` matcher seeded with the built-in defaults, merged with the project's
+ * root .gitignore so a negation there (e.g. `!vendor/`) overrides a default. Shared
+ * by both enumeration paths so behavior is identical with or without git — and so
+ * the defaults apply to tracked files too (committing a dependency dir doesn't make
+ * it project code; the explicit `.gitignore` negation is the only opt-in).
+ */
+export declare function buildDefaultIgnore(rootDir: string): Ignore;
+/**
+ * Recursively scan a directory for source files.
+ *
+ * In git repos, uses `git ls-files` (inherently respects .gitignore at all
+ * levels), then keeps files with a supported source extension. For non-git
+ * projects, falls back to a filesystem walk that parses .gitignore itself.
+ */
+export declare function scanDirectory(rootDir: string, onProgress?: (current: number, file: string) => void): string[];
+/**
+ * Async variant of scanDirectory that yields to the event loop periodically,
+ * allowing worker threads to receive and render progress messages.
+ */
+export declare function scanDirectoryAsync(rootDir: string, onProgress?: (current: number, file: string) => void): Promise<string[]>;
+/**
+ * Extraction orchestrator
+ */
+export declare class ExtractionOrchestrator {
+    private rootDir;
+    private queries;
+    /**
+     * Names of frameworks detected for this project, populated by indexAll().
+     * Passed to extractFromSource so framework-specific extractors (route nodes,
+     * middleware, etc.) run after the tree-sitter pass. Cleared if detection
+     * hasn't run yet so single-file re-index paths can detect on the spot.
+     */
+    private detectedFrameworkNames;
+    constructor(rootDir: string, queries: QueryBuilder);
+    /**
+     * Build a filesystem-backed ResolutionContext sufficient for framework
+     * detection. Graph-query methods (getNodesByName etc.) return empty because
+     * the DB hasn't been populated yet, but detect() only uses readFile,
+     * fileExists, and getAllFiles, so that's fine.
+     */
+    private buildDetectionContext;
+    /**
+     * Detect frameworks on demand using the current scanned files (or a fresh
+     * scan if none are provided). Cached on the orchestrator so repeat calls
+     * inside a single run don't re-scan.
+     */
+    private ensureDetectedFrameworks;
+    /**
+     * Index all files in the project
+     */
+    indexAll(onProgress?: (progress: IndexProgress) => void, signal?: AbortSignal, verbose?: boolean): Promise<IndexResult>;
+    /**
+     * Index specific files
+     */
+    indexFiles(filePaths: string[]): Promise<IndexResult>;
+    /**
+     * Index a single file
+     */
+    indexFile(relativePath: string): Promise<ExtractionResult>;
+    /**
+     * Index a single file with pre-read content and stats.
+     * Used by the parallel batch reader to avoid redundant file I/O.
+     */
+    indexFileWithContent(relativePath: string, content: string, stats: fs.Stats): Promise<ExtractionResult>;
+    /**
+     * Store extraction result in database
+     */
+    private storeExtractionResult;
+    /**
+     * Sync the index with the current file state.
+     *
+     * Change detection is filesystem-based, never git: a (size, mtime) stat
+     * pre-filter skips unchanged files, then a content-hash compare confirms real
+     * changes. This works in non-git projects and catches committed changes from
+     * `git pull`/`checkout`/`merge`/`rebase` that `git status` cannot see.
+     */
+    sync(onProgress?: (progress: IndexProgress) => void): Promise<SyncResult>;
+    /**
+     * Get files that have changed since last index.
+     * Uses git status as a fast path when available, falling back to full scan.
+     */
+    getChangedFiles(): {
+        added: string[];
+        modified: string[];
+        removed: string[];
+    };
+}
+export { extractFromSource } from './tree-sitter';
+export { detectLanguage, isSourceFile, isLanguageSupported, isGrammarLoaded, getSupportedLanguages, initGrammars, loadGrammarsForLanguages, loadAllGrammars } from './grammars';
+//# sourceMappingURL=index.d.ts.map

package/dist/extraction/languages/c-cpp.d.ts

@@ -0,0 +1,4 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const cExtractor: LanguageExtractor;
+export declare const cppExtractor: LanguageExtractor;
+//# sourceMappingURL=c-cpp.d.ts.map

package/dist/extraction/languages/csharp.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const csharpExtractor: LanguageExtractor;
+//# sourceMappingURL=csharp.d.ts.map

package/dist/extraction/languages/dart.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const dartExtractor: LanguageExtractor;
+//# sourceMappingURL=dart.d.ts.map

package/dist/extraction/languages/go.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const goExtractor: LanguageExtractor;
+//# sourceMappingURL=go.d.ts.map

package/dist/extraction/languages/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Per-language extraction configurations.
+ *
+ * Each file exports a LanguageExtractor config object.
+ * This barrel builds the EXTRACTORS map consumed by TreeSitterExtractor.
+ */
+import { Language } from '../../types';
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const EXTRACTORS: Partial<Record<Language, LanguageExtractor>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/extraction/languages/java.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const javaExtractor: LanguageExtractor;
+//# sourceMappingURL=java.d.ts.map

package/dist/extraction/languages/javascript.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const javascriptExtractor: LanguageExtractor;
+//# sourceMappingURL=javascript.d.ts.map

package/dist/extraction/languages/kotlin.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const kotlinExtractor: LanguageExtractor;
+//# sourceMappingURL=kotlin.d.ts.map

package/dist/extraction/languages/lua.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const luaExtractor: LanguageExtractor;
+//# sourceMappingURL=lua.d.ts.map

package/dist/extraction/languages/luau.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const luauExtractor: LanguageExtractor;
+//# sourceMappingURL=luau.d.ts.map

package/dist/extraction/languages/objc.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const objcExtractor: LanguageExtractor;
+//# sourceMappingURL=objc.d.ts.map

package/dist/extraction/languages/pascal.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const pascalExtractor: LanguageExtractor;
+//# sourceMappingURL=pascal.d.ts.map

package/dist/extraction/languages/php.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const phpExtractor: LanguageExtractor;
+//# sourceMappingURL=php.d.ts.map

package/dist/extraction/languages/python.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const pythonExtractor: LanguageExtractor;
+//# sourceMappingURL=python.d.ts.map

package/dist/extraction/languages/ruby.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const rubyExtractor: LanguageExtractor;
+//# sourceMappingURL=ruby.d.ts.map

package/dist/extraction/languages/rust.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const rustExtractor: LanguageExtractor;
+//# sourceMappingURL=rust.d.ts.map

package/dist/extraction/languages/scala.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const scalaExtractor: LanguageExtractor;
+//# sourceMappingURL=scala.d.ts.map

package/dist/extraction/languages/swift.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const swiftExtractor: LanguageExtractor;
+//# sourceMappingURL=swift.d.ts.map

package/dist/extraction/languages/typescript.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageExtractor } from '../tree-sitter-types';
+export declare const typescriptExtractor: LanguageExtractor;
+//# sourceMappingURL=typescript.d.ts.map

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

@@ -0,0 +1,52 @@
+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/mybatis-extractor.d.ts

@@ -0,0 +1,48 @@
+import { ExtractionResult } from '../types';
+/**
+ * MyBatisExtractor — parses MyBatis mapper XML files.
+ *
+ * MyBatis splits a DAO interface across two files: a Java interface (parsed by
+ * tree-sitter) declares the method, and an XML mapper file holds the SQL keyed
+ * by `<namespace>` (the fully-qualified Java type name) and `id` (the method
+ * name). Without the XML side in the graph, `trace(Controller, ...DAO.method)`
+ * dead-ends at the interface method — the SQL it actually runs is invisible,
+ * and "what does this query touch" / "where is this column written" can't be
+ * answered.
+ *
+ * This extractor emits one method-shaped node per `<select|insert|update|
+ * delete>` and per `<sql>` fragment, qualified as `<namespace>::<id>` so the
+ * MyBatis framework synthesizer (`src/resolution/frameworks/mybatis.ts`) can
+ * link the matching Java method → XML statement by suffix-matching qualified
+ * names. `<include refid="...">` inside a statement yields an unresolved
+ * reference to the SQL fragment, also keyed by `<namespace>::<refid>`.
+ *
+ * Non-mapper XML (Maven `pom.xml`, Spring beans XML, `web.xml`, log4j config,
+ * etc.) is detected by the absence of a `<mapper namespace="...">` root and
+ * returns just a file node — we still need the file row so the watcher can
+ * track it, but we emit no symbols.
+ */
+export declare class MyBatisExtractor {
+    private filePath;
+    private source;
+    private nodes;
+    private edges;
+    private unresolvedReferences;
+    private errors;
+    private lineStarts;
+    constructor(filePath: string, source: string);
+    extract(): ExtractionResult;
+    private createFileNode;
+    /**
+     * Find the `<mapper namespace="X">` opening tag. Returns the namespace and
+     * the byte offsets of the body (between the opening and closing tag) so
+     * statement extraction can be scoped to mapper contents.
+     */
+    private findMapperRoot;
+    private extractMapper;
+    private buildSignature;
+    private previewSql;
+    private computeLineStarts;
+    private getLineNumber;
+}
+//# sourceMappingURL=mybatis-extractor.d.ts.map

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

@@ -0,0 +1,8 @@
+/**
+ * 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/svelte-extractor.d.ts

@@ -0,0 +1,56 @@
+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

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

@@ -0,0 +1,28 @@
+/**
+ * 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