@colbymchenry/codegraph 0.7.10 → 0.9.0

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

@@ -1,179 +0,0 @@
-/**
- * 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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tree-sitter-types.d.ts","sourceRoot":"","sources":["../../src/extraction/tree-sitter-types.ts"],"names":[],"mappings":"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"}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"tree-sitter-types.js","sourceRoot":"","sources":["../../src/extraction/tree-sitter-types.ts"],"names":[],"mappings":";AAAA;;;;;;GAMG"}

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

@@ -1,233 +0,0 @@
-/**
- * Tree-sitter Parser Wrapper
- *
- * Handles parsing source code and extracting structural information.
- */
-import { Language, ExtractionResult } from '../types';
-export { generateNodeId } from './tree-sitter-helpers';
-/**
- * TreeSitterExtractor - Main extraction class
- */
-export declare class TreeSitterExtractor {
-    private filePath;
-    private language;
-    private source;
-    private tree;
-    private nodes;
-    private edges;
-    private unresolvedReferences;
-    private errors;
-    private extractor;
-    private nodeStack;
-    private methodIndex;
-    constructor(filePath: string, source: string, language?: Language);
-    /**
-     * Parse and extract from the source code
-     */
-    extract(): ExtractionResult;
-    /**
-     * Visit a node and extract information
-     */
-    private visitNode;
-    /**
-     * Create a Node object
-     */
-    private createNode;
-    /**
-     * Find first named child whose type is in the given list.
-     * Used to locate inner type nodes (e.g. enum_specifier inside a typedef).
-     */
-    private findChildByTypes;
-    /**
-     * Build qualified name from node stack
-     */
-    private buildQualifiedName;
-    /**
-     * Build an ExtractorContext for passing to language-specific visitNode hooks.
-     */
-    private makeExtractorContext;
-    /**
-     * Check if the current node stack indicates we are inside a class-like node
-     * (class, struct, interface, trait). File nodes do not count as class-like.
-     */
-    private isInsideClassLikeNode;
-    /**
-     * Extract a function
-     */
-    private extractFunction;
-    /**
-     * Extract a class
-     */
-    private extractClass;
-    /**
-     * Extract a method
-     */
-    private extractMethod;
-    /**
-     * Extract an interface/protocol/trait
-     */
-    private extractInterface;
-    /**
-     * Extract a struct
-     */
-    private extractStruct;
-    /**
-     * Extract an enum
-     */
-    private extractEnum;
-    /**
-     * Extract enum member names from an enum member node.
-     * Handles multi-case declarations (Swift: `case put, delete`) and single-case patterns.
-     */
-    private extractEnumMembers;
-    /**
-     * Extract a class property declaration (e.g. C# `public string Name { get; set; }`).
-     * Extracts as 'property' kind node inside the owning class.
-     */
-    private extractProperty;
-    /**
-     * Extract a class field declaration (e.g. Java field_declaration, C# field_declaration).
-     * Extracts each declarator as a 'field' kind node inside the owning class.
-     */
-    private extractField;
-    /**
-     * Extract a variable declaration (const, let, var, etc.)
-     *
-     * Extracts top-level and module-level variable declarations.
-     * Captures the variable name and first 100 chars of initializer in signature for searchability.
-     */
-    private extractVariable;
-    /**
-     * Extract a type alias (e.g. `export type X = ...` in TypeScript).
-     * For languages like Go, resolveTypeAliasKind detects when the type_spec
-     * wraps a struct or interface definition and creates the correct node kind.
-     * Returns true if children should be skipped (struct/interface handled body visiting).
-     */
-    private extractTypeAlias;
-    /**
-     * Extract an import
-     *
-     * Creates an import node with the full import statement stored in signature for searchability.
-     * Also creates unresolved references for resolution purposes.
-     */
-    private extractImport;
-    /**
-     * Extract a function call
-     */
-    private extractCall;
-    /**
-     * `new Foo(...)` / `Foo::new(...)` / object_creation_expression —
-     * emit an `instantiates` reference to the class name. The resolver
-     * then links it to the class node, producing the `instantiates`
-     * edge that powers "what creates instances of X" queries.
-     *
-     * Children are still walked so nested calls inside the constructor
-     * arguments (`new Foo(bar())`) get their own `calls` references.
-     */
-    private extractInstantiation;
-    /**
-     * Scan `declNode` and its preceding siblings (within the parent's
-     * named children) for decorator nodes, emitting a `decorates`
-     * reference from `decoratedId` to each decorator's function name.
-     *
-     * Why preceding siblings: in TypeScript, `@Foo class Bar {}` parses
-     * as an `export_statement` (or top-level wrapper) with the
-     * `decorator` as a child *before* the `class_declaration` — so the
-     * decorator isn't a child of the class itself. For methods/
-     * properties, the decorator IS a direct child of the declaration,
-     * so we also scan declNode.namedChildren.
-     *
-     * Idempotent across grammars: if neither location yields decorators
-     * (most non-decorator-using languages), the function is a no-op.
-     */
-    private extractDecoratorsFor;
-    /**
-     * Visit function body and extract calls (and structural nodes).
-     *
-     * In addition to call expressions, this also detects class/struct/enum
-     * definitions inside function bodies. This handles two cases:
-     *   1. Local class/struct/enum definitions (valid in C++, Java, etc.)
-     *   2. C++ macro misparsing — macros like NLOHMANN_JSON_NAMESPACE_BEGIN cause
-     *      tree-sitter to interpret the namespace block as a function_definition,
-     *      hiding real class/struct/enum nodes inside the "function body".
-     */
-    private visitFunctionBody;
-    /**
-     * Extract inheritance relationships
-     */
-    private extractInheritance;
-    /**
-     * Rust `impl Trait for Type` — creates an implements edge from Type to Trait.
-     * For plain `impl Type { ... }` (no trait), no inheritance edge is needed.
-     */
-    private extractRustImplItem;
-    /**
-     * Find a previously-extracted node by name (used for back-references like impl blocks)
-     */
-    private findNodeByName;
-    /**
-     * Languages that support type annotations (TypeScript, etc.)
-     */
-    private readonly TYPE_ANNOTATION_LANGUAGES;
-    /**
-     * Built-in/primitive type names that shouldn't create references
-     */
-    private readonly BUILTIN_TYPES;
-    /**
-     * Extract type references from type annotations on a function/method/field node.
-     * Creates 'references' edges for parameter types, return types, and field types.
-     */
-    private extractTypeAnnotations;
-    /**
-     * Extract type references from a variable's type annotation.
-     */
-    private extractVariableTypeAnnotation;
-    /**
-     * Recursively walk a subtree and extract all type_identifier references.
-     * Handles unions, intersections, generics, arrays, etc.
-     */
-    private extractTypeRefsFromSubtree;
-    /**
-     * Handle Pascal-specific AST structures.
-     * Returns true if the node was fully handled and children should be skipped.
-     */
-    private visitPascalNode;
-    /**
-     * Extract a Pascal declType node (class, interface, enum, or type alias)
-     */
-    private extractPascalDeclType;
-    /**
-     * Extract Pascal uses clause into individual import nodes
-     */
-    private extractPascalUses;
-    /**
-     * Extract a Pascal constant declaration
-     */
-    private extractPascalConst;
-    /**
-     * Extract Pascal inheritance (extends/implements) from declClass typeref children
-     */
-    private extractPascalInheritance;
-    /**
-     * Extract calls and resolve method context from a Pascal defProc (implementation body).
-     * Does not create a new node — the declaration was already captured from the interface section.
-     */
-    private extractPascalDefProc;
-    /**
-     * Extract function calls from a Pascal expression
-     */
-    private extractPascalCall;
-    /**
-     * Recursively visit a Pascal block/statement tree for call expressions
-     */
-    private visitPascalBlock;
-}
-/**
- * Extract nodes and edges from source code.
- *
- * If `frameworkNames` is provided, framework-specific extractors matching
- * those names and the file's language are run after the tree-sitter pass.
- * Their nodes/references/errors are merged into the returned result.
- */
-export declare function extractFromSource(filePath: string, source: string, language?: Language, frameworkNames?: string[]): ExtractionResult;
-//# sourceMappingURL=tree-sitter.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"tree-sitter.d.ts","sourceRoot":"","sources":["../../src/extraction/tree-sitter.ts"],"names":[],"mappings":"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"}