@vohongtho.infotech/code-intel 0.1.3 → 0.1.4

package/dist/index.d.ts

@@ -1,31 +1,386 @@
-export { createKnowledgeGraph } from './graph/index.js';
-export type { KnowledgeGraph } from './graph/index.js';
-export { generateNodeId, generateEdgeId } from './graph/index.js';
-export { initParser, getParser, getLanguage, parseSource, runQuery, AstCache } from './parsing/index.js';
-export type { QueryCapture } from './parsing/index.js';
-export { getLanguageModule, getAllLanguageModules } from './languages/index.js';
-export type { LanguageModule, FileSet } from './languages/index.js';
-export { resolveImports, BindingTracker } from './resolver/index.js';
-export type { ImportInfo, ImportResolutionResult, ImportBinding } from './resolver/index.js';
-export { buildCallEdges, classifyCall } from './call-graph/index.js';
-export type { CallSite, CallKind } from './call-graph/index.js';
-export { buildHeritageEdges, computeMRO, detectOverrides } from './inheritance/index.js';
-export type { HeritageInfo, MroStrategy } from './inheritance/index.js';
-export { runPipeline, validateDAG, topologicalSort } from './pipeline/index.js';
-export type { Phase, PhaseResult, PipelineContext, PipelineRunResult } from './pipeline/index.js';
-export { scanPhase, structurePhase, parsePhase, resolvePhase, clusterPhase, flowPhase, } from './pipeline/index.js';
-export { createScope, resolveBinding, addBinding } from './scope-analysis/index.js';
-export type { Scope, ScopeBinding } from './scope-analysis/index.js';
-export { detectCommunities, addClustersToGraph } from './clustering/index.js';
-export type { ClusterResult } from './clustering/index.js';
-export { findEntryPoints, traceFlow } from './flow-detection/index.js';
-export type { EntryPoint, FlowTrace } from './flow-detection/index.js';
-export { textSearch, reciprocalRankFusion } from './search/index.js';
-export type { SearchResult } from './search/index.js';
-export { createMcpServer, startMcpStdio } from './mcp-server/index.js';
-export { createApp, startHttpServer } from './http/index.js';
-export { DbManager, loadGraphToDB, upsertRepo, loadRegistry, removeRepo, saveMetadata, loadMetadata, getDbPath } from './storage/index.js';
-export type { RepoEntry, IndexMetadata } from './storage/index.js';
-export { listGroups, getGroup, createGroup, deleteGroup, mergeSearchResults } from './multi-repo/index.js';
-export type { RepoGroup } from './multi-repo/index.js';
-//# sourceMappingURL=index.d.ts.map
+import { Language as Language$1, Parser, Tree, Node } from 'web-tree-sitter';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import express from 'express';
+
+declare enum Language {
+    TypeScript = "typescript",
+    JavaScript = "javascript",
+    Python = "python",
+    Java = "java",
+    Go = "go",
+    C = "c",
+    Cpp = "cpp",
+    CSharp = "csharp",
+    Rust = "rust",
+    PHP = "php",
+    Kotlin = "kotlin",
+    Ruby = "ruby",
+    Swift = "swift",
+    Dart = "dart"
+}
+
+type NodeKind = 'file' | 'directory' | 'function' | 'class' | 'interface' | 'method' | 'constructor' | 'variable' | 'property' | 'struct' | 'enum' | 'trait' | 'namespace' | 'module' | 'type_alias' | 'constant' | 'route' | 'cluster' | 'flow';
+type EdgeKind = 'contains' | 'calls' | 'imports' | 'extends' | 'implements' | 'has_member' | 'accesses' | 'overrides' | 'belongs_to' | 'step_of' | 'handles';
+interface CodeNode {
+    id: string;
+    kind: NodeKind;
+    name: string;
+    filePath: string;
+    startLine?: number;
+    endLine?: number;
+    exported?: boolean;
+    content?: string;
+    metadata?: Record<string, unknown>;
+}
+interface CodeEdge {
+    id: string;
+    source: string;
+    target: string;
+    kind: EdgeKind;
+    weight?: number;
+    label?: string;
+}
+
+interface KnowledgeGraph {
+    addNode(node: CodeNode): void;
+    addEdge(edge: CodeEdge): void;
+    getNode(id: string): CodeNode | undefined;
+    getEdge(id: string): CodeEdge | undefined;
+    findEdgesByKind(kind: EdgeKind): Iterable<CodeEdge>;
+    findEdgesFrom(sourceId: string): Iterable<CodeEdge>;
+    findEdgesTo(targetId: string): Iterable<CodeEdge>;
+    removeNodeCascade(id: string): void;
+    removeEdge(id: string): void;
+    allNodes(): Iterable<CodeNode>;
+    allEdges(): Iterable<CodeEdge>;
+    readonly size: {
+        nodes: number;
+        edges: number;
+    };
+    clear(): void;
+}
+declare function createKnowledgeGraph(): KnowledgeGraph;
+
+declare function generateNodeId(kind: NodeKind, filePath: string, qualifiedName: string): string;
+declare function generateEdgeId(source: string, target: string, kind: string): string;
+
+declare function initParser(): Promise<void>;
+declare function getParser(lang: Language): Promise<Parser>;
+declare function getLanguage(lang: Language): Promise<Language$1 | null>;
+declare function parseSource(lang: Language, source: string): Promise<Tree | null>;
+
+interface QueryCapture {
+    name: string;
+    node: Node;
+    text: string;
+}
+declare function runQuery(tree: Tree, language: Language$1, querySource: string): QueryCapture[];
+
+declare class AstCache {
+    private cache;
+    private maxEntries;
+    constructor(maxEntries?: number);
+    get(filePath: string): Tree | undefined;
+    set(filePath: string, tree: Tree): void;
+    has(filePath: string): boolean;
+    clear(): void;
+    get size(): number;
+    private evictLRU;
+}
+
+interface FileSet {
+    has(filePath: string): boolean;
+    resolve(fromDir: string, relativePath: string): string | null;
+    findByPackage(packageName: string): string | null;
+}
+interface LanguageModule {
+    readonly lang: Language;
+    readonly fileExtensions: readonly string[];
+    readonly queries: string;
+    readonly importStyle: 'explicit' | 'wildcard' | 'namespace' | 'include';
+    readonly inheritanceStrategy: 'depth-first' | 'c3' | 'mixin-aware' | 'none';
+    resolveImport(rawPath: string, fromFile: string, workspace: FileSet): string | null;
+    isExported(node: Node): boolean;
+    extractType(node: Node): string | null;
+}
+
+declare function getLanguageModule(lang: Language): LanguageModule;
+declare function getAllLanguageModules(): LanguageModule[];
+
+interface ImportBinding {
+    localName: string;
+    sourcePath: string;
+    exportedName: string;
+    isDefault: boolean;
+    isNamespace: boolean;
+}
+declare class BindingTracker {
+    private bindings;
+    addBinding(filePath: string, binding: ImportBinding): void;
+    getBinding(filePath: string, localName: string): ImportBinding | undefined;
+    getFileBindings(filePath: string): ImportBinding[];
+    clear(): void;
+}
+
+interface ImportInfo {
+    rawPath: string;
+    localNames: string[];
+    isDefault: boolean;
+    isNamespace: boolean;
+    namespaceName?: string;
+}
+interface ImportResolutionResult {
+    edges: CodeEdge[];
+    bindings: BindingTracker;
+}
+declare function resolveImports(filePath: string, fileNodeId: string, imports: ImportInfo[], langModule: LanguageModule, workspace: FileSet): ImportResolutionResult;
+
+type CallKind = 'free' | 'member' | 'constructor';
+interface CallSite {
+    callerNodeId: string;
+    callerFilePath: string;
+    name: string;
+    receiverText?: string;
+    kind: CallKind;
+    line: number;
+    argCount: number;
+}
+declare function classifyCall(name: string, hasReceiver: boolean, isNew: boolean): CallKind;
+
+declare function buildCallEdges(callSites: CallSite[], graph: KnowledgeGraph, bindings: BindingTracker): CodeEdge[];
+
+interface HeritageInfo {
+    classNodeId: string;
+    extendsNames: string[];
+    implementsNames: string[];
+}
+declare function buildHeritageEdges(heritages: HeritageInfo[], graph: KnowledgeGraph): CodeEdge[];
+
+type MroStrategy = 'depth-first' | 'c3' | 'mixin-aware' | 'none';
+declare function computeMRO(classId: string, parentMap: Map<string, string[]>, strategy: MroStrategy): string[];
+
+declare function detectOverrides(graph: KnowledgeGraph): CodeEdge[];
+
+type PipelinePhaseStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+interface PhaseResult {
+    status: PipelinePhaseStatus;
+    duration: number;
+    message?: string;
+}
+interface PipelineContext {
+    workspaceRoot: string;
+    graph: KnowledgeGraph;
+    filePaths: string[];
+    onProgress?: (phase: string, message: string) => void;
+    verbose?: boolean;
+}
+interface Phase {
+    name: string;
+    dependencies: string[];
+    execute(context: PipelineContext, depResults: Map<string, PhaseResult>): Promise<PhaseResult>;
+}
+
+interface PipelineRunResult {
+    success: boolean;
+    results: Map<string, PhaseResult>;
+    totalDuration: number;
+}
+declare function runPipeline(phases: Phase[], context: PipelineContext): Promise<PipelineRunResult>;
+
+interface ValidationError {
+    type: 'duplicate' | 'missing-dep' | 'cycle';
+    message: string;
+}
+declare function validateDAG(phases: Phase[]): ValidationError[];
+declare function topologicalSort(phases: Phase[]): Phase[];
+
+declare const scanPhase: Phase;
+declare const structurePhase: Phase;
+
+declare const parsePhase: Phase;
+
+declare const resolvePhase: Phase;
+
+declare const clusterPhase: Phase;
+
+declare const flowPhase: Phase;
+
+interface Scope {
+    name: string;
+    kind: 'module' | 'function' | 'block' | 'class';
+    parent: Scope | null;
+    bindings: Map<string, ScopeBinding>;
+    children: Scope[];
+}
+interface ScopeBinding {
+    name: string;
+    nodeId: string;
+    kind: 'variable' | 'function' | 'class' | 'parameter' | 'import';
+}
+declare function createScope(name: string, kind: Scope['kind'], parent?: Scope | null): Scope;
+declare function resolveBinding(name: string, scope: Scope): ScopeBinding | null;
+declare function addBinding(scope: Scope, binding: ScopeBinding): void;
+
+interface ClusterResult {
+    clusterId: string;
+    label: string;
+    memberIds: string[];
+}
+declare function detectCommunities(graph: KnowledgeGraph): ClusterResult[];
+declare function addClustersToGraph(graph: KnowledgeGraph, clusters: ClusterResult[]): void;
+
+interface EntryPoint {
+    nodeId: string;
+    name: string;
+    score: number;
+    filePath: string;
+}
+declare function findEntryPoints(graph: KnowledgeGraph): EntryPoint[];
+interface FlowTrace {
+    entryPointId: string;
+    steps: string[];
+}
+declare function traceFlow(entryId: string, graph: KnowledgeGraph, maxDepth?: number, maxBranching?: number): FlowTrace[];
+
+interface SearchResult {
+    nodeId: string;
+    name: string;
+    kind: string;
+    filePath: string;
+    score: number;
+    snippet?: string;
+}
+declare function textSearch(graph: KnowledgeGraph, query: string, limit?: number): SearchResult[];
+declare function reciprocalRankFusion(...rankings: SearchResult[][]): SearchResult[];
+
+declare class DbManager {
+    private db;
+    private conn;
+    private dbPath;
+    constructor(dbPath: string);
+    init(): Promise<void>;
+    query(cypher: string): Promise<Record<string, unknown>[]>;
+    execute(cypher: string): Promise<void>;
+    close(): void;
+    get isOpen(): boolean;
+}
+
+declare function createMcpServer(graph: KnowledgeGraph, repoName: string): Server;
+declare function startMcpStdio(graph: KnowledgeGraph, repoName: string): Promise<void>;
+
+declare function createApp(graph: KnowledgeGraph, repoName: string, workspaceRoot?: string): express.Application;
+declare function startHttpServer(graph: KnowledgeGraph, repoName: string, port?: number, workspaceRoot?: string): void;
+
+declare function loadGraphToDB(graph: KnowledgeGraph, dbManager: DbManager): Promise<{
+    nodeCount: number;
+    edgeCount: number;
+}>;
+
+interface RepoEntry {
+    name: string;
+    path: string;
+    indexedAt: string;
+    stats: {
+        nodes: number;
+        edges: number;
+        files: number;
+    };
+}
+declare function loadRegistry(): RepoEntry[];
+declare function upsertRepo(entry: RepoEntry): void;
+declare function removeRepo(repoPath: string): void;
+
+interface IndexMetadata {
+    indexedAt: string;
+    commitHash?: string;
+    stats: {
+        nodes: number;
+        edges: number;
+        files: number;
+        duration: number;
+    };
+}
+declare function saveMetadata(repoDir: string, metadata: IndexMetadata): void;
+declare function loadMetadata(repoDir: string): IndexMetadata | null;
+declare function getDbPath(repoDir: string): string;
+
+/** A member of a repo group, located at a hierarchy path. */
+interface GroupMember {
+    /** Hierarchy path inside the group, e.g. "hr/hiring/backend" */
+    groupPath: string;
+    /** Name from the global registry (`code-intel list`) */
+    registryName: string;
+}
+/** A named collection of repos treated as a logical system. */
+interface RepoGroup {
+    name: string;
+    createdAt: string;
+    members: GroupMember[];
+    lastSync?: string;
+}
+type ContractKind = 'export' | 'route' | 'schema' | 'event';
+/**
+ * A contract is an observable boundary point of a repo:
+ * an exported symbol, HTTP route, event, or schema type.
+ */
+interface Contract {
+    repoName: string;
+    repoPath: string;
+    kind: ContractKind;
+    name: string;
+    nodeId: string;
+    nodeKind: string;
+    filePath: string;
+    signature?: string;
+}
+type LinkKind = 'name-match' | 'route-match' | 'import-match';
+/**
+ * A cross-repo link: a contract in one repo matched to a contract
+ * (or consumer node) in another repo.
+ */
+interface ContractLink {
+    providerRepo: string;
+    providerContract: string;
+    consumerRepo: string;
+    consumerContract: string;
+    matchKind: LinkKind;
+    confidence: number;
+}
+/** Persisted result of a `group sync` run. */
+interface GroupSyncResult {
+    groupName: string;
+    syncedAt: string;
+    memberCount: number;
+    contracts: Contract[];
+    links: ContractLink[];
+}
+
+declare function loadGroup(name: string): RepoGroup | null;
+declare function saveGroup(group: RepoGroup): void;
+declare function listGroups(): RepoGroup[];
+declare function deleteGroup(name: string): void;
+declare function groupExists(name: string): boolean;
+/** Add or update a member (by groupPath). Returns the updated group. */
+declare function addMember(groupName: string, member: GroupMember): RepoGroup;
+/** Remove a member by groupPath. Returns the updated group. */
+declare function removeMember(groupName: string, groupPath: string): RepoGroup;
+
+declare function saveSyncResult(result: GroupSyncResult): void;
+declare function loadSyncResult(groupName: string): GroupSyncResult | null;
+
+declare function syncGroup(group: RepoGroup): Promise<GroupSyncResult>;
+
+interface GroupQueryResult {
+    repoName: string;
+    repoPath: string;
+    groupPath: string;
+    results: SearchResult[];
+}
+declare function queryGroup(group: RepoGroup, query: string, limit?: number): Promise<{
+    perRepo: GroupQueryResult[];
+    merged: SearchResult[];
+}>;
+
+declare function mergeSearchResults(...perRepoResults: SearchResult[][]): SearchResult[];
+
+export { AstCache, BindingTracker, type CallKind, type CallSite, type ClusterResult, type Contract, type ContractLink, DbManager, type EntryPoint, type FileSet, type FlowTrace, type GroupMember, type GroupQueryResult, type GroupSyncResult, type HeritageInfo, type ImportBinding, type ImportInfo, type ImportResolutionResult, type IndexMetadata, type KnowledgeGraph, type LanguageModule, type MroStrategy, type Phase, type PhaseResult, type PipelineContext, type PipelineRunResult, type QueryCapture, type RepoEntry, type RepoGroup, type Scope, type ScopeBinding, type SearchResult, addBinding, addClustersToGraph, addMember, buildCallEdges, buildHeritageEdges, classifyCall, clusterPhase, computeMRO, createApp, createKnowledgeGraph, createMcpServer, createScope, deleteGroup, detectCommunities, detectOverrides, findEntryPoints, flowPhase, generateEdgeId, generateNodeId, getAllLanguageModules, getDbPath, getLanguage, getLanguageModule, getParser, groupExists, initParser, listGroups, loadGraphToDB, loadGroup, loadMetadata, loadRegistry, loadSyncResult, mergeSearchResults, parsePhase, parseSource, queryGroup, reciprocalRankFusion, removeMember, removeRepo, resolveBinding, resolveImports, resolvePhase, runPipeline, runQuery, saveGroup, saveMetadata, saveSyncResult, scanPhase, startHttpServer, startMcpStdio, structurePhase, syncGroup, textSearch, topologicalSort, traceFlow, upsertRepo, validateDAG };