claude-eidetic 0.1.0 → 0.1.2

package/dist/splitter/ast.js

@@ -1,4 +1,6 @@
 import { createRequire } from 'node:module';
+import { MAX_CHUNK_CHARS } from './types.js';
+import { extractSymbolInfo, isContainerType } from './symbol-extract.js';
 // tree-sitter and language parsers are native CommonJS modules
 const require = createRequire(import.meta.url);
 const Parser = require('tree-sitter');
@@ -23,29 +25,67 @@ const languageParsers = {
 };
 // AST node types that represent logical code units per language
 const SPLITTABLE_TYPES = {
-    javascript: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition', 'export_statement'],
-    typescript: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition', 'export_statement', 'interface_declaration', 'type_alias_declaration'],
-    tsx: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition', 'export_statement', 'interface_declaration', 'type_alias_declaration'],
-    python: ['function_definition', 'class_definition', 'decorated_definition', 'async_function_definition'],
-    java: ['method_declaration', 'class_declaration', 'interface_declaration', 'constructor_declaration'],
+    javascript: ['function_declaration', 'arrow_function', 'class_declaration', 'method_definition'],
+    typescript: [
+        'function_declaration',
+        'arrow_function',
+        'class_declaration',
+        'method_definition',
+        'interface_declaration',
+        'type_alias_declaration',
+    ],
+    tsx: [
+        'function_declaration',
+        'arrow_function',
+        'class_declaration',
+        'method_definition',
+        'interface_declaration',
+        'type_alias_declaration',
+    ],
+    python: [
+        'function_definition',
+        'class_definition',
+        'decorated_definition',
+        'async_function_definition',
+    ],
+    java: [
+        'method_declaration',
+        'class_declaration',
+        'interface_declaration',
+        'constructor_declaration',
+    ],
     cpp: ['function_definition', 'class_specifier', 'namespace_definition', 'declaration'],
-    go: ['function_declaration', 'method_declaration', 'type_declaration', 'var_declaration', 'const_declaration'],
+    go: [
+        'function_declaration',
+        'method_declaration',
+        'type_declaration',
+        'var_declaration',
+        'const_declaration',
+    ],
     rust: ['function_item', 'impl_item', 'struct_item', 'enum_item', 'trait_item', 'mod_item'],
-    csharp: ['method_declaration', 'class_declaration', 'interface_declaration', 'struct_declaration', 'enum_declaration'],
+    csharp: [
+        'method_declaration',
+        'class_declaration',
+        'interface_declaration',
+        'struct_declaration',
+        'enum_declaration',
+    ],
 };
-// Map aliases to canonical language names for node type lookup
 const LANG_CANONICAL = {
-    js: 'javascript', ts: 'typescript', py: 'python',
-    rs: 'rust', 'c++': 'cpp', c: 'cpp', cs: 'csharp',
+    js: 'javascript',
+    ts: 'typescript',
+    py: 'python',
+    rs: 'rust',
+    'c++': 'cpp',
+    c: 'cpp',
+    cs: 'csharp',
 };
-const MAX_CHUNK_CHARS = 2500;
 export class AstSplitter {
     parser = new Parser();
     currentLang = '';
     // Shared across all AstSplitter instances — one cache per process
     static langCache = new Map();
     static resolveLanguage(lang) {
-        // Resolve alias to canonical name first — prevents duplicate cache entries
         const canonical = LANG_CANONICAL[lang] ?? lang;
         const cached = AstSplitter.langCache.get(canonical);
         if (cached)
@@ -59,7 +99,7 @@ export class AstSplitter {
             return mod;
         }
         catch (err) {
-            console.warn(`Failed to load tree-sitter parser for "${lang}": ${err}`);
+            console.warn(`Failed to load tree-sitter parser for "${lang}":`, err);
             return null;
         }
     }
@@ -68,10 +108,9 @@ export class AstSplitter {
         const canonical = LANG_CANONICAL[lang] ?? lang;
         const langModule = AstSplitter.resolveLanguage(lang);
         if (!langModule) {
-            return []; // Caller should fall back to line splitter
+            return [];
         }
         try {
-            // Skip setLanguage() if parser is already configured for this language
             if (canonical !== this.currentLang) {
                 this.parser.setLanguage(langModule);
                 this.currentLang = canonical;
@@ -81,14 +120,13 @@ export class AstSplitter {
                 return [];
             const nodeTypes = SPLITTABLE_TYPES[canonical] ?? [];
             const rawChunks = this.extractChunks(tree.rootNode, code, nodeTypes, language, filePath);
-            // If no meaningful chunks found, return empty (caller will use line splitter)
             if (rawChunks.length === 0)
                 return [];
             return this.refineChunks(rawChunks);
         }
         catch (err) {
-            console.warn(`AST parse failed for "${filePath}" (${language}): ${err}`);
-            return []; // Caller should fall back to line splitter
+            console.warn(`AST parse failed for "${filePath}" (${language}):`, err);
+            return [];
         }
     }
     static isSupported(language) {
@@ -96,21 +134,37 @@ export class AstSplitter {
     }
     extractChunks(node, code, splittableTypes, language, filePath) {
         const chunks = [];
-        const traverse = (current) => {
+        const traverse = (current, parentName) => {
             if (splittableTypes.includes(current.type)) {
                 const text = code.slice(current.startIndex, current.endIndex);
                 if (text.trim().length > 0) {
-                    chunks.push({
+                    const symbolInfo = extractSymbolInfo(current, code, parentName);
+                    const chunk = {
                         content: text,
                         startLine: current.startPosition.row + 1,
                         endLine: current.endPosition.row + 1,
                         language,
                         filePath,
-                    });
+                    };
+                    if (symbolInfo) {
+                        chunk.symbolName = symbolInfo.name;
+                        chunk.symbolKind = symbolInfo.kind;
+                        chunk.symbolSignature = symbolInfo.signature;
+                        if (parentName)
+                            chunk.parentSymbol = parentName;
+                    }
+                    chunks.push(chunk);
+                    // If this is a container, pass its name as parentName to children
+                    if (isContainerType(current.type) && symbolInfo?.name) {
+                        for (const child of current.children) {
+                            traverse(child, symbolInfo.name);
+                        }
+                        return;
+                    }
                 }
             }
             for (const child of current.children) {
-                traverse(child);
+                traverse(child, parentName);
             }
         };
         traverse(node);
@@ -144,6 +198,10 @@ export class AstSplitter {
                     endLine: startLine + lineCount - 1,
                     language: chunk.language,
                     filePath: chunk.filePath,
+                    symbolName: chunk.symbolName,
+                    symbolKind: chunk.symbolKind,
+                    symbolSignature: chunk.symbolSignature,
+                    parentSymbol: chunk.parentSymbol,
                 });
                 current = addition;
                 startLine = chunk.startLine + i;
@@ -161,6 +219,10 @@ export class AstSplitter {
                 endLine: startLine + lineCount - 1,
                 language: chunk.language,
                 filePath: chunk.filePath,
+                symbolName: chunk.symbolName,
+                symbolKind: chunk.symbolKind,
+                symbolSignature: chunk.symbolSignature,
+                parentSymbol: chunk.parentSymbol,
             });
         }
         return subChunks;

package/dist/splitter/line.d.ts

@@ -1,8 +1,4 @@
 import type { Splitter, CodeChunk } from './types.js';
-/**
- * Simple line-based splitter. Used as fallback when tree-sitter
- * doesn't support the language or fails to parse.
- */
 export declare class LineSplitter implements Splitter {
     private chunkLines;
     private overlapLines;

package/dist/splitter/line.js

@@ -1,10 +1,6 @@
+import { MAX_CHUNK_CHARS } from './types.js';
 const DEFAULT_CHUNK_LINES = 60;
 const OVERLAP_LINES = 5;
-const MAX_CHUNK_CHARS = 2500;
-/**
- * Simple line-based splitter. Used as fallback when tree-sitter
- * doesn't support the language or fails to parse.
- */
 export class LineSplitter {
     chunkLines;
     overlapLines;
@@ -72,9 +68,7 @@ export class LineSplitter {
                 startLine = chunk.startLine + i;
                 lineCount = 0;
             }
-            // If a single line exceeds the limit, hard-split it by characters
             if (addition.length > MAX_CHUNK_CHARS) {
-                // Flush anything accumulated before this line
                 if (current.length > 0) {
                     flush();
                     current = '';

package/dist/splitter/symbol-extract.d.ts

@@ -0,0 +1,16 @@
+export interface SymbolInfo {
+    name: string;
+    kind: string;
+    signature: string;
+}
+interface AstNode {
+    type: string;
+    startIndex: number;
+    endIndex: number;
+    children: AstNode[];
+    text?: string;
+}
+export declare function extractSymbolInfo(node: AstNode, code: string, parentName?: string): SymbolInfo | undefined;
+export declare function isContainerType(nodeType: string): boolean;
+export {};
+//# sourceMappingURL=symbol-extract.d.ts.map

package/dist/splitter/symbol-extract.js

@@ -0,0 +1,61 @@
+const CONTAINER_TYPES = new Set(['class_declaration', 'class_definition', 'interface_declaration']);
+const KIND_MAP = {
+    function_declaration: 'function',
+    arrow_function: 'function',
+    async_function_definition: 'function',
+    function_definition: 'function',
+    class_declaration: 'class',
+    class_definition: 'class',
+    interface_declaration: 'interface',
+    method_definition: 'method',
+    method_declaration: 'method',
+    type_alias_declaration: 'type',
+    enum_declaration: 'enum',
+    // Java
+    constructor_declaration: 'constructor',
+    // Rust
+    function_item: 'function',
+    impl_item: 'impl',
+    struct_item: 'struct',
+    enum_item: 'enum',
+    trait_item: 'trait',
+    // C#
+    struct_declaration: 'struct',
+};
+function getIdentifier(node, code) {
+    const identChild = node.children.find((c) => c.type === 'identifier' || c.type === 'type_identifier' || c.type === 'name');
+    if (identChild)
+        return code.slice(identChild.startIndex, identChild.endIndex);
+    return undefined;
+}
+function extractSignature(node, code) {
+    const text = code.slice(node.startIndex, node.endIndex);
+    // Take first line up to opening brace or end of line
+    const firstLine = text.split('\n')[0];
+    const upToBrace = firstLine.split('{')[0].trimEnd();
+    const sig = upToBrace || firstLine;
+    return sig.length > 200 ? sig.slice(0, 200) + '…' : sig;
+}
+export function extractSymbolInfo(node, code, parentName) {
+    const nodeType = node.type;
+    // Handle export_statement: recurse into declaration child
+    if (nodeType === 'export_statement') {
+        const declChild = node.children.find((c) => c.type !== 'export' && c.type !== 'default' && c.type !== ';' && c.type !== 'identifier');
+        if (declChild)
+            return extractSymbolInfo(declChild, code, parentName);
+        return undefined;
+    }
+    const kind = KIND_MAP[nodeType];
+    if (!kind)
+        return undefined;
+    const name = getIdentifier(node, code);
+    if (!name)
+        return undefined;
+    const signature = extractSignature(node, code);
+    void parentName; // consumed by caller to set chunk.parentSymbol
+    return { name, kind, signature };
+}
+export function isContainerType(nodeType) {
+    return CONTAINER_TYPES.has(nodeType);
+}
+//# sourceMappingURL=symbol-extract.js.map

package/dist/splitter/types.d.ts

@@ -1,9 +1,14 @@
+export declare const MAX_CHUNK_CHARS = 2500;
 export interface CodeChunk {
     content: string;
     startLine: number;
     endLine: number;
     language: string;
     filePath: string;
+    symbolName?: string;
+    symbolKind?: string;
+    symbolSignature?: string;
+    parentSymbol?: string;
 }
 export interface Splitter {
     split(code: string, language: string, filePath: string): CodeChunk[];

package/dist/splitter/types.js

@@ -1,2 +1,2 @@
-export {};
+export const MAX_CHUNK_CHARS = 2500;
 //# sourceMappingURL=types.js.map

package/dist/state/doc-metadata.d.ts

@@ -0,0 +1,18 @@
+export interface DocEntry {
+    library: string;
+    topic: string;
+    source: string;
+    collectionName: string;
+    indexedAt: string;
+    ttlDays: number;
+    totalChunks: number;
+}
+export type DocMetadata = Record<string, DocEntry>;
+export declare function loadDocMetadata(): DocMetadata;
+export declare function saveDocMetadata(metadata: DocMetadata): void;
+export declare function upsertDocEntry(entry: DocEntry): void;
+export declare function removeDocEntry(library: string, topic: string): boolean;
+export declare function findDocEntries(library: string): DocEntry[];
+export declare function isStale(entry: DocEntry): boolean;
+export declare function listDocLibraries(): string[];
+//# sourceMappingURL=doc-metadata.d.ts.map

package/dist/state/doc-metadata.js

@@ -0,0 +1,59 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { getDocMetadataPath } from '../paths.js';
+function metadataKey(library, topic) {
+    return `${library.toLowerCase()}::${topic.toLowerCase()}`;
+}
+export function loadDocMetadata() {
+    const metadataPath = getDocMetadataPath();
+    try {
+        const data = fs.readFileSync(metadataPath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return {};
+    }
+}
+export function saveDocMetadata(metadata) {
+    const metadataPath = getDocMetadataPath();
+    const dir = path.dirname(metadataPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(metadataPath, JSON.stringify(metadata, null, 2) + '\n', 'utf-8');
+}
+export function upsertDocEntry(entry) {
+    const metadata = loadDocMetadata();
+    const key = metadataKey(entry.library, entry.topic);
+    metadata[key] = entry;
+    saveDocMetadata(metadata);
+}
+export function removeDocEntry(library, topic) {
+    const metadata = loadDocMetadata();
+    const key = metadataKey(library, topic);
+    if (!(key in metadata))
+        return false;
+    Reflect.deleteProperty(metadata, key);
+    saveDocMetadata(metadata);
+    return true;
+}
+export function findDocEntries(library) {
+    const metadata = loadDocMetadata();
+    const prefix = `${library.toLowerCase()}::`;
+    return Object.entries(metadata)
+        .filter(([key]) => key.startsWith(prefix))
+        .map(([, entry]) => entry);
+}
+export function isStale(entry) {
+    const indexedAt = new Date(entry.indexedAt).getTime();
+    const now = Date.now();
+    const ttlMs = entry.ttlDays * 24 * 60 * 60 * 1000;
+    return now - indexedAt > ttlMs;
+}
+export function listDocLibraries() {
+    const metadata = loadDocMetadata();
+    const libs = new Set();
+    for (const entry of Object.values(metadata)) {
+        libs.add(entry.library);
+    }
+    return [...libs].sort();
+}
+//# sourceMappingURL=doc-metadata.js.map

package/dist/state/registry.d.ts

@@ -1,6 +1,4 @@
-interface Registry {
-    [project: string]: string;
-}
+type Registry = Record<string, string>;
 export declare function registerProject(absolutePath: string): void;
 export declare function resolveProject(project: string): string | undefined;
 export declare function listProjects(): Registry;

package/dist/state/snapshot.d.ts

@@ -20,7 +20,6 @@ export declare class StateManager {
     setIndexed(normalizedPath: string, totalFiles: number, totalChunks: number): void;
     setError(normalizedPath: string, error: string): void;
     remove(normalizedPath: string): void;
-    markExisting(normalizedPath: string, collectionName: string): void;
 }
 export declare function cleanupOrphanedSnapshots(vectordb: VectorDB): Promise<number>;
 //# sourceMappingURL=snapshot.d.ts.map

package/dist/state/snapshot.js

@@ -46,14 +46,6 @@ export class StateManager {
     remove(normalizedPath) {
         this.states.delete(normalizedPath);
     }
-    markExisting(normalizedPath, collectionName) {
-        this.states.set(normalizedPath, {
-            path: normalizedPath,
-            collectionName,
-            status: 'indexed',
-            lastIndexed: 'unknown (pre-existing)',
-        });
-    }
 }
 export async function cleanupOrphanedSnapshots(vectordb) {
     const snapshotDir = getSnapshotDir();
@@ -61,16 +53,10 @@ export async function cleanupOrphanedSnapshots(vectordb) {
     try {
         if (!fs.existsSync(snapshotDir))
             return 0;
-        const files = fs.readdirSync(snapshotDir).filter(f => f.endsWith('.json'));
+        const files = fs.readdirSync(snapshotDir).filter((f) => f.endsWith('.json'));
         if (files.length === 0)
             return 0;
-        // Connectivity probe: use a name unlikely to exist. If hasCollection throws
-        // or the vector DB is unreachable (Qdrant's hasCollection returns false on
-        // network error), we must not proceed -- deleting snapshots when we cannot
-        // confirm collection absence would destroy valid state.
         const probeResult = await vectordb.hasCollection('__eidetic_connectivity_probe__');
-        // If the probe returns true for a name that should never exist, something is
-        // wrong -- skip cleanup to be safe.
         if (probeResult) {
             console.warn('Orphan cleanup skipped: connectivity probe returned unexpected result.');
             return 0;
@@ -87,14 +73,12 @@ export async function cleanupOrphanedSnapshots(vectordb) {
                 }
             }
             catch (err) {
-                // Network error for this specific check -- skip rather than risk deletion
-                console.warn(`Skipping orphan check for ${collectionName}: ${err}`);
+                console.warn(`Skipping orphan check for ${collectionName}:`, err);
             }
         }
     }
     catch (err) {
-        // Connectivity probe failure or filesystem error -- skip cleanup entirely
-        console.warn(`Orphan cleanup skipped: ${err}`);
+        console.warn('Orphan cleanup skipped:', err);
     }
     return cleaned;
 }