@easbot/codebase 0.1.11

package/dist/index.d.cts

@@ -0,0 +1,542 @@
+import { KnowledgeSearchOptions, BaseSearchResult, CodebaseKnowledgeConfigWithModels, CodebaseKnowledgeConfig } from '@easbot/types';
+export { CodebaseKnowledgeConfig, CodebaseKnowledgeConfigWithModels } from '@easbot/types';
+import { EmbeddingModelV3 } from '@ai-sdk/provider';
+export { EmbeddingModelV3 as EmbeddingModel } from '@ai-sdk/provider';
+
+interface FtsSearchResult {
+    id: string;
+    file_path: string;
+    name: string;
+    ast_type: string;
+    language: Language;
+    score: number;
+    text: string;
+    start_line: number;
+    start_col: number;
+    end_line: number;
+    end_col: number;
+}
+declare class DatabaseManager {
+    private db;
+    private dbPath;
+    private closed;
+    private ftsAvailable;
+    constructor(dbPath: string);
+    private openDatabase;
+    private ensureSchema;
+    private checkFtsAvailability;
+    isFtsAvailable(): boolean;
+    insertNode(node: Node): void;
+    insertNodes(nodes: Node[]): void;
+    private updateFtsNode;
+    private updateFtsNodes;
+    insertEdge(edge: Edge): void;
+    insertEdges(edges: Edge[]): void;
+    queryNodes(filter: NodeQueryFilter): Node[];
+    queryEdges(filter: EdgeQueryFilter): Edge[];
+    queryAll<T = any>(sql: string, params?: (string | number)[]): T[];
+    searchNodesFts(query: string, limit?: number): FtsSearchResult[];
+    deleteNodesByFile(filePath: string): number;
+    deleteEdgesByFile(filePath: string): number;
+    getFileHash(filePath: string): string | null;
+    setFileHash(filePath: string, hash: string): void;
+    deleteFileHash(filePath: string): void;
+    getAllFileHashes(): FileHashRecord[];
+    getStatus(): GraphStatus;
+    setLastSync(): void;
+    getNodeCount(): number;
+    getEdgeCount(): number;
+    getFileCount(): number;
+    getNodeById(id: string): Node | null;
+    getEdgeById(id: string): Edge | null;
+    clearAll(): void;
+    getCachedEmbedding(contentHash: string): Float32Array | null;
+    cacheEmbedding(contentHash: string, embedding: Float32Array): void;
+    getAllNodeEmbeddings(): Array<{
+        node_id: string;
+        embedding: Buffer;
+    }>;
+    storeNodeEmbeddings(embeddings: Array<{
+        nodeId: string;
+        embeddingText: string;
+        embedding: Float32Array;
+    }>): void;
+    initialize(): void;
+    close(): void;
+    isClosed(): boolean;
+    getDbPath(): string;
+    transaction<T>(fn: () => T): T;
+}
+
+type CodeSearchSource = 'fts' | 'structural' | 'vector' | 'basic';
+interface SearchResult extends BaseSearchResult {
+    id: string;
+    name: string;
+    astType: string;
+    language: Language;
+    filePath: string;
+    text: string;
+    startLine: number;
+    startCol: number;
+    endLine: number;
+    endCol: number;
+    source: CodeSearchSource;
+}
+interface HybridSearchResult extends SearchResult {
+    vectorScore?: number;
+    ftsScore?: number;
+    hybridScore: number;
+}
+interface SearchOptions extends KnowledgeSearchOptions {
+    language?: Language;
+    filePath?: string;
+    astType?: string;
+    enableFts?: boolean;
+    includeEdges?: boolean;
+    edgesLimit?: number;
+    embedding?: EmbeddingModelV3;
+}
+interface RelationQueryOptions {
+    maxDepth?: number;
+    relationTypes?: RelationType[];
+    direction?: 'incoming' | 'outgoing' | 'both';
+    limit?: number;
+}
+declare class QueryInterface {
+    private db;
+    private embedding?;
+    constructor(db: DatabaseManager, embedding?: EmbeddingModelV3);
+    search(query: string, options?: SearchOptions): Promise<NodeWithEdges[]>;
+    private vectorSearchNodes;
+    private getEdgesForNode;
+    private embedText;
+    private cosineSimilarity;
+    private structuralSearch;
+    private calculateNameSimilarity;
+    private normalizeScore;
+    queryNodes(filter: NodeQueryFilter): Node[];
+    queryEdges(filter: EdgeQueryFilter): Edge[];
+    queryEdgesWithNodes(filter: EdgeQueryFilter): EdgeWithNodes[];
+    queryNeighbors(nodeId: string, options?: RelationQueryOptions): {
+        nodes: Node[];
+        edges: Edge[];
+    };
+    queryCallGraph(nodeId: string, depth?: number): Map<string, {
+        callers: string[];
+        callees: string[];
+    }>;
+    queryInheritance(nodeId: string): {
+        ancestors: Node[];
+        descendants: Node[];
+    };
+    getNode(nodeId: string): Node | null;
+    getEdge(edgeId: string): Edge | null;
+}
+declare function createQueryInterface(db: DatabaseManager): QueryInterface;
+
+type CodebaseConfig = CodebaseKnowledgeConfigWithModels;
+type Language = 'ts' | 'tsx' | 'js' | 'py' | 'rs' | 'go' | 'c' | 'cpp' | 'csharp' | 'java' | 'scala' | 'ruby' | 'php' | 'zig';
+declare const FILE_EXTENSION_MAP: Record<string, Language>;
+type RelationType = 'CONTAINS' | 'CALLS' | 'INHERITS_FROM' | 'IMPLEMENTS' | 'REFERENCES' | 'IMPORTS';
+type ASTNodeType = 'class_declaration' | 'function_declaration' | 'method_declaration' | 'method_definition' | 'variable_declaration' | 'import_declaration' | 'import_statement' | 'interface_declaration' | 'type_alias_declaration' | 'enum_declaration' | 'struct_item' | 'impl_item' | 'trait_item' | 'function_definition' | 'function_item' | 'class_definition' | 'module' | 'identifier' | 'type_identifier' | 'property_identifier' | 'field_identifier' | 'call_expression' | 'new_expression' | 'member_expression' | 'assignment_expression' | 'binary_expression' | 'unary_expression' | 'arrow_function' | 'function_expression' | 'lexical_declaration' | 'variable_declarator' | 'formal_parameters' | 'parameter' | 'required_parameter' | 'optional_parameter' | 'rest_parameter' | 'object_type' | 'array_type' | 'union_type' | 'intersection_type' | 'literal_type' | 'generic_type' | 'named_imports' | 'import_clause' | 'export_statement' | 'export_clause' | 'decorator' | 'attribute_item' | 'macro_definition' | 'macro_invocation' | 'namespace_definition' | 'using_directive' | 'class_heredoc' | 'trait_adaptations' | 'namespace_declaration' | 'define_directive' | 'preproc_if' | 'preproc_function_def';
+interface Node {
+    id: string;
+    name: string;
+    ast_type: string;
+    language: Language;
+    file_path: string;
+    start_line: number;
+    start_col: number;
+    end_line: number;
+    end_col: number;
+    text: string;
+    created_at: string;
+}
+interface Edge {
+    id: string;
+    source: string;
+    target: string;
+    relation: RelationType;
+    created_at: string;
+}
+interface NodeWithEdges extends Node {
+    edges: Edge[];
+}
+interface ExtractedNode {
+    name: string;
+    ast_type: string;
+    language: Language;
+    file_path: string;
+    start_line: number;
+    start_col: number;
+    end_line: number;
+    end_col: number;
+    text: string;
+    parent_id?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ExtractedEdge {
+    source: string;
+    target: string;
+    relation: RelationType;
+}
+type CodeKnowledgeGraphConfig = CodebaseKnowledgeConfig;
+interface NodeQueryFilter {
+    filePath?: string;
+    astType?: string;
+    name?: string;
+    language?: Language;
+    ids?: string[];
+    limit?: number;
+    offset?: number;
+}
+interface EdgeQueryFilter {
+    source?: string;
+    target?: string;
+    sourceOrTarget?: string[];
+    relation?: RelationType;
+    limit?: number;
+    offset?: number;
+}
+interface EdgeWithNodes {
+    edge: Edge;
+    sourceNode: Node | null;
+    targetNode: Node | null;
+}
+interface IndexResult {
+    success: boolean;
+    filesProcessed: number;
+    nodesCreated: number;
+    edgesCreated: number;
+    errors: Array<{
+        filePath: string;
+        error: string;
+    }>;
+    duration: number;
+}
+interface SyncResult {
+    success: boolean;
+    filesAdded: number;
+    filesUpdated: number;
+    filesDeleted: number;
+    filesSkipped: number;
+    nodesCreated: number;
+    edgesCreated: number;
+    errors: Array<{
+        filePath: string;
+        error: string;
+    }>;
+    duration: number;
+}
+interface GraphStatus {
+    nodeCount: number;
+    edgeCount: number;
+    indexedFiles: number;
+    dbPath: string;
+    workspaceDir: string;
+    lastSync: string | null;
+}
+interface HealthCheckResult {
+    healthy: boolean;
+    issues: string[];
+    nodeCount: number;
+    edgeCount: number;
+    fileCount: number;
+    ftsAvailable: boolean;
+    parserStatus: Record<Language, boolean>;
+    database?: boolean;
+    parsers?: Record<Language, boolean>;
+    errors?: string[];
+}
+interface FileHashRecord {
+    file_path: string;
+    content_hash: string;
+    last_modified: string;
+}
+type ProgressCallback = (progress: {
+    currentFile: string;
+    processed: number;
+    total: number;
+    stage: 'parsing' | 'extracting' | 'storing' | 'embedding';
+}) => void;
+interface IParser {
+    parse(sourceCode: string): unknown;
+    getLanguage(): Language;
+}
+interface INodeExtractor {
+    extractNodes(tree: unknown, source: string, language: Language, filePath: string): ExtractedNode[];
+}
+interface IEdgeExtractor {
+    extractEdges(tree: unknown, nodes: ExtractedNode[], language: Language, filePath: string): ExtractedEdge[];
+}
+
+interface ICodebase {
+    initialize(): Promise<void>;
+    indexFile(filePath: string, progress?: ProgressCallback): Promise<IndexResult>;
+    indexDirectory(dir?: string, progress?: ProgressCallback): Promise<IndexResult>;
+    sync(progress?: ProgressCallback): Promise<SyncResult>;
+    search(query: string, options?: SearchOptions): Promise<NodeWithEdges[]>;
+    queryNodes(filter: NodeQueryFilter): Promise<Node[]>;
+    queryEdges(filter: EdgeQueryFilter): Promise<Edge[]>;
+    queryNeighbors(nodeId: string, options?: RelationQueryOptions): Promise<{
+        nodes: Node[];
+        edges: Edge[];
+    }>;
+    queryCallGraph(nodeId: string, depth?: number): Promise<Map<string, {
+        callers: string[];
+        callees: string[];
+    }>>;
+    queryInheritance(nodeId: string): Promise<{
+        ancestors: Node[];
+        descendants: Node[];
+    }>;
+    getNode(nodeId: string): Promise<Node | null>;
+    getEdge(edgeId: string): Promise<Edge | null>;
+    getStatus(): Promise<GraphStatus>;
+    healthCheck(): Promise<HealthCheckResult>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+}
+
+type ParserInstance = any;
+type LanguageInstance = any;
+interface ParseTree {
+    rootNode: SyntaxNode;
+    walk(): TreeCursor;
+    delete(): void;
+}
+interface SyntaxNode {
+    type: string;
+    text: string;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    childCount: number;
+    children: SyntaxNode[];
+    namedChildCount: number;
+    namedChildren: SyntaxNode[];
+    parent: SyntaxNode | null;
+    childForFieldName(name: string): SyntaxNode | null;
+    childForFieldId(id: number): SyntaxNode | null;
+    firstChild: SyntaxNode | null;
+    lastChild: SyntaxNode | null;
+    nextSibling: SyntaxNode | null;
+    prevSibling: SyntaxNode | null;
+    nextNamedSibling: SyntaxNode | null;
+    prevNamedSibling: SyntaxNode | null;
+    descendantForPosition(position: {
+        row: number;
+        column: number;
+    }): SyntaxNode;
+    descendantsOfType(type: string | string[]): SyntaxNode[];
+}
+interface TreeCursor {
+    nodeType: string;
+    nodeText: string;
+    startPosition: {
+        row: number;
+        column: number;
+    };
+    endPosition: {
+        row: number;
+        column: number;
+    };
+    gotoFirstChild(): boolean;
+    gotoNextSibling(): boolean;
+    gotoParent(): boolean;
+    currentNode: SyntaxNode;
+}
+declare class ParserManager {
+    private parsers;
+    private initialized;
+    private initPromise;
+    initialize(): Promise<void>;
+    private doInitialize;
+    getParser(language: Language): ParserInstance | null;
+    getLanguage(language: Language): LanguageInstance | null;
+    detectLanguage(filePath: string): Language | null;
+    parse(sourceCode: string, language: Language): ParseTree;
+    parseFile(filePath: string, sourceCode: string): ParseTree;
+    isLanguageSupported(language: Language): boolean;
+    getSupportedLanguages(): Language[];
+    isInitialized(): boolean;
+    getStatus(): Record<Language, boolean>;
+    dispose(): void;
+}
+declare function getParserManager(): Promise<ParserManager>;
+declare function resetParserManager(): void;
+
+declare class ParserError extends Error {
+    readonly name = "ParserError";
+    readonly filePath: string;
+    readonly cause?: Error;
+    constructor(message: string, filePath: string, cause?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class DatabaseError extends Error {
+    readonly name = "DatabaseError";
+    readonly operation: string;
+    readonly cause?: Error;
+    constructor(message: string, operation: string, cause?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class FileSystemError extends Error {
+    readonly name = "FileSystemError";
+    readonly filePath: string;
+    readonly cause?: Error;
+    constructor(message: string, filePath: string, cause?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class SchemaError extends Error {
+    readonly name = "SchemaError";
+    readonly missing?: string[];
+    constructor(message: string, missing?: string[]);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class ConfigError extends Error {
+    readonly name = "ConfigError";
+    readonly field?: string;
+    constructor(message: string, field?: string);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class IndexError extends Error {
+    readonly name = "IndexError";
+    readonly filePath?: string;
+    readonly cause?: Error;
+    constructor(message: string, filePath?: string, cause?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class QueryError extends Error {
+    readonly name = "QueryError";
+    readonly params?: Record<string, unknown>;
+    readonly cause?: Error;
+    constructor(message: string, params?: Record<string, unknown>, cause?: Error);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+declare class UnsupportedLanguageError extends Error {
+    readonly name = "UnsupportedLanguageError";
+    readonly extension: string;
+    readonly filePath: string;
+    constructor(extension: string, filePath: string);
+    toString(): string;
+    toJSON(): Record<string, unknown>;
+}
+
+declare class NodeExtractor {
+    extractNodes(tree: ParseTree, source: string, language: Language, filePath: string): ExtractedNode[];
+    private walkTree;
+    private extractNode;
+    private getNodeName;
+    private findNameInChildren;
+    private findNameInGrandchildren;
+    private extractImportName;
+    private normalizeAstType;
+    private getNodeText;
+    generateNodeId(node: ExtractedNode): string;
+}
+declare function createNodeExtractor(): NodeExtractor;
+
+declare class EdgeExtractor {
+    extractEdges(tree: ParseTree, nodes: ExtractedNode[], language: Language, filePath: string): ExtractedEdge[];
+    private extractContainsEdges;
+    private extractCallEdges;
+    private extractInheritanceEdges;
+    private extractImportEdges;
+    private walkTree;
+    private findEnclosingFunction;
+    private extractCalleeName;
+    private findNameInChildren;
+    private findChildByType;
+    private findDescendantByType;
+    private extractIdentifier;
+    private extractIdentifiers;
+    private extractImportPath;
+    generateNodeId(node: ExtractedNode): string;
+}
+declare function createEdgeExtractor(): EdgeExtractor;
+
+interface IndexerConfig {
+    workspaceDir: string;
+    batchSize: number;
+    ignorePatterns: string[];
+    incremental: boolean;
+    embedding: EmbeddingModelV3;
+}
+declare class Indexer {
+    private db;
+    private parserManager;
+    private nodeExtractor;
+    private edgeExtractor;
+    private config;
+    constructor(db: DatabaseManager, parserManager: ParserManager, config: IndexerConfig);
+    private generateNodeEmbeddingText;
+    private embedText;
+    indexFile(filePath: string, progress?: ProgressCallback): Promise<IndexResult>;
+    indexDirectory(dir?: string, progress?: ProgressCallback): Promise<IndexResult>;
+    sync(progress?: ProgressCallback): Promise<SyncResult>;
+    private scanFiles;
+    private readFile;
+    private computeHash;
+    private storeNodes;
+    private storeEdges;
+    private getValidEdgeCount;
+    private embedNodes;
+    private chunkArray;
+}
+declare function createIndexer(db: DatabaseManager, parserManager: ParserManager, config: IndexerConfig): Indexer;
+
+declare class CodeBase implements ICodebase {
+    private config;
+    private db;
+    private parserManager;
+    private indexer;
+    private queryInterface;
+    private initialized;
+    constructor(config?: Partial<CodebaseConfig>);
+    initialize(): Promise<void>;
+    private validateConfig;
+    private resolveDbPath;
+    indexFile(filePath: string, progress?: ProgressCallback): Promise<IndexResult>;
+    indexDirectory(dir?: string, progress?: ProgressCallback): Promise<IndexResult>;
+    sync(progress?: ProgressCallback): Promise<SyncResult>;
+    search(query: string, options?: SearchOptions): Promise<NodeWithEdges[]>;
+    queryNodes(filter: NodeQueryFilter): Promise<Node[]>;
+    queryEdges(filter: EdgeQueryFilter): Promise<Edge[]>;
+    queryNeighbors(nodeId: string, options?: RelationQueryOptions): Promise<{
+        nodes: Node[];
+        edges: Edge[];
+    }>;
+    queryCallGraph(nodeId: string, depth?: number): Promise<Map<string, {
+        callers: string[];
+        callees: string[];
+    }>>;
+    queryInheritance(nodeId: string): Promise<{
+        ancestors: Node[];
+        descendants: Node[];
+    }>;
+    getNode(nodeId: string): Promise<Node | null>;
+    getEdge(edgeId: string): Promise<Edge | null>;
+    getStatus(): Promise<GraphStatus>;
+    healthCheck(): Promise<HealthCheckResult>;
+    clear(): Promise<void>;
+    close(): Promise<void>;
+    private ensureInitialized;
+    getDatabase(): DatabaseManager;
+    getParser(): ParserManager;
+    getQuery(): QueryInterface;
+}
+declare function createCodebase(config?: Partial<CodebaseConfig>): Promise<ICodebase>;
+
+export { type ASTNodeType, CodeBase, type CodeKnowledgeGraphConfig, type CodebaseConfig, ConfigError, DatabaseError, DatabaseManager, type Edge, EdgeExtractor, type EdgeQueryFilter, type EdgeWithNodes, type ExtractedEdge, type ExtractedNode, FILE_EXTENSION_MAP, type FileHashRecord, FileSystemError, type GraphStatus, type HealthCheckResult, type HybridSearchResult, type ICodebase, type IEdgeExtractor, type INodeExtractor, type IParser, IndexError, type IndexResult, Indexer, type IndexerConfig, type Language, type Node, NodeExtractor, type NodeQueryFilter, type NodeWithEdges, ParserError, ParserManager, type ProgressCallback, QueryError, QueryInterface, type RelationQueryOptions, type RelationType, SchemaError, type SearchOptions, type SearchResult, type SyncResult, UnsupportedLanguageError, createCodebase, createEdgeExtractor, createIndexer, createNodeExtractor, createQueryInterface, getParserManager, resetParserManager };