@tai-io/codesearch 2026.313.1614

package/dist/paths.js

@@ -0,0 +1,54 @@
+import path from 'node:path';
+import os from 'node:os';
+import { getConfig } from './config.js';
+export function normalizePath(inputPath) {
+    let resolved = inputPath;
+    if (resolved.startsWith('~')) {
+        resolved = path.join(os.homedir(), resolved.slice(1));
+    }
+    resolved = path.resolve(resolved);
+    resolved = resolved.replace(/\\/g, '/');
+    if (resolved.length > 1 && resolved.endsWith('/')) {
+        resolved = resolved.slice(0, -1);
+    }
+    return resolved;
+}
+export function getDataDir() {
+    return normalizePath(getConfig().eideticDataDir);
+}
+export function getSnapshotDir() {
+    return `${getDataDir()}/snapshots`;
+}
+export function getCacheDir() {
+    return `${getDataDir()}/cache`;
+}
+export function getRegistryPath() {
+    return `${getDataDir()}/registry.json`;
+}
+export function pathToCollectionName(absolutePath) {
+    const normalized = normalizePath(absolutePath);
+    const safe = normalized
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+    return `eidetic_${safe}`;
+}
+export function getCodesearchDbPath() {
+    return `${getDataDir()}/codesearch.db`;
+}
+export function getSnapshotDbPath() {
+    return `${getDataDir()}/snapshots.db`;
+}
+export function getDocMetadataPath() {
+    return `${getDataDir()}/doc-metadata.json`;
+}
+export function docCollectionName(library) {
+    const safe = library
+        .toLowerCase()
+        .replace(/[^a-z0-9]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '');
+    return `doc_${safe}`;
+}
+//# sourceMappingURL=paths.js.map

package/dist/setup-message.d.ts

@@ -0,0 +1,4 @@
+export type SetupContext = 'missing' | 'invalid' | 'unknown';
+export declare function getSetupErrorMessage(errorDetail: string, context?: SetupContext): string;
+export declare function getWelcomeMessage(): string;
+//# sourceMappingURL=setup-message.d.ts.map

package/dist/setup-message.js

@@ -0,0 +1,48 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const yamlPath = join(__dirname, '..', 'messages.yaml');
+let _cached = null;
+function loadMessages() {
+    if (_cached)
+        return _cached;
+    _cached = parseYaml(readFileSync(yamlPath, 'utf-8'));
+    return _cached;
+}
+function detectContext() {
+    const hasKey = !!process.env.OPENAI_API_KEY;
+    const isOllama = process.env.EMBEDDING_PROVIDER === 'ollama';
+    if (!hasKey && !isOllama)
+        return 'missing';
+    return 'invalid';
+}
+function getConfigInstructions() {
+    const msgs = loadMessages();
+    const isWindows = process.platform === 'win32';
+    const primary = isWindows
+        ? msgs.setup.config_instructions_windows
+        : msgs.setup.config_instructions_unix;
+    return primary + '\n' + msgs.setup.config_alternatives;
+}
+export function getSetupErrorMessage(errorDetail, context) {
+    const ctx = context ?? detectContext();
+    const msgs = loadMessages();
+    const block = msgs.setup[ctx];
+    const header = block.header.replace('{error}', errorDetail);
+    const diagnosis = block.diagnosis.trim() ? `**Diagnosis:** ${block.diagnosis.trim()}\n\n` : '';
+    return (`${header}\n\n` +
+        diagnosis +
+        '## How to fix\n\n' +
+        `1. ${block.step1}\n` +
+        '2. **Set or update your config:**\n\n' +
+        getConfigInstructions() +
+        `3. ${msgs.setup.footer}`);
+}
+export function getWelcomeMessage() {
+    const msgs = loadMessages();
+    return msgs.welcome.ascii_art.trimEnd() + '\n\n' + msgs.welcome.first_run.trimEnd();
+}
+//# sourceMappingURL=setup-message.js.map

package/dist/splitter/ast.d.ts

@@ -0,0 +1,13 @@
+import type { Splitter, CodeChunk } from './types.js';
+export declare class AstSplitter implements Splitter {
+    private parser;
+    private currentLang;
+    private static langCache;
+    private static resolveLanguage;
+    split(code: string, language: string, filePath: string): CodeChunk[];
+    static isSupported(language: string): boolean;
+    private extractChunks;
+    private refineChunks;
+    private splitLargeChunk;
+}
+//# sourceMappingURL=ast.d.ts.map

package/dist/splitter/ast.js

@@ -0,0 +1,231 @@
+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');
+// Lazy-load language parsers to avoid startup cost for unused languages
+const languageParsers = {
+    javascript: () => require('tree-sitter-javascript'),
+    js: () => require('tree-sitter-javascript'),
+    typescript: () => require('tree-sitter-typescript').typescript,
+    ts: () => require('tree-sitter-typescript').typescript,
+    tsx: () => require('tree-sitter-typescript').tsx,
+    python: () => require('tree-sitter-python'),
+    py: () => require('tree-sitter-python'),
+    go: () => require('tree-sitter-go'),
+    java: () => require('tree-sitter-java'),
+    rust: () => require('tree-sitter-rust'),
+    rs: () => require('tree-sitter-rust'),
+    cpp: () => require('tree-sitter-cpp'),
+    'c++': () => require('tree-sitter-cpp'),
+    c: () => require('tree-sitter-cpp'),
+    csharp: () => require('tree-sitter-c-sharp'),
+    cs: () => require('tree-sitter-c-sharp'),
+};
+// AST node types that represent logical code units per language
+const SPLITTABLE_TYPES = {
+    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',
+    ],
+    rust: ['function_item', 'impl_item', 'struct_item', 'enum_item', 'trait_item', 'mod_item'],
+    csharp: [
+        'method_declaration',
+        'class_declaration',
+        'interface_declaration',
+        'struct_declaration',
+        'enum_declaration',
+    ],
+};
+const LANG_CANONICAL = {
+    js: 'javascript',
+    ts: 'typescript',
+    py: 'python',
+    rs: 'rust',
+    'c++': 'cpp',
+    c: 'cpp',
+    cs: 'csharp',
+};
+export class AstSplitter {
+    parser = new Parser();
+    currentLang = '';
+    // Shared across all AstSplitter instances — one cache per process
+    static langCache = new Map();
+    static resolveLanguage(lang) {
+        const canonical = LANG_CANONICAL[lang] ?? lang;
+        const cached = AstSplitter.langCache.get(canonical);
+        if (cached)
+            return cached;
+        const factory = languageParsers[canonical] ?? languageParsers[lang];
+        if (!factory)
+            return null;
+        try {
+            const mod = factory();
+            AstSplitter.langCache.set(canonical, mod);
+            return mod;
+        }
+        catch (err) {
+            console.warn(`Failed to load tree-sitter parser for "${lang}":`, err);
+            return null;
+        }
+    }
+    split(code, language, filePath) {
+        const lang = language.toLowerCase();
+        const canonical = LANG_CANONICAL[lang] ?? lang;
+        const langModule = AstSplitter.resolveLanguage(lang);
+        if (!langModule) {
+            return [];
+        }
+        try {
+            if (canonical !== this.currentLang) {
+                this.parser.setLanguage(langModule);
+                this.currentLang = canonical;
+            }
+            const tree = this.parser.parse(code);
+            if (!tree.rootNode)
+                return [];
+            const nodeTypes = SPLITTABLE_TYPES[canonical] ?? [];
+            const rawChunks = this.extractChunks(tree.rootNode, code, nodeTypes, language, filePath);
+            if (rawChunks.length === 0)
+                return [];
+            return this.refineChunks(rawChunks);
+        }
+        catch (err) {
+            console.warn(`AST parse failed for "${filePath}" (${language}):`, err);
+            return [];
+        }
+    }
+    static isSupported(language) {
+        return language.toLowerCase() in languageParsers;
+    }
+    extractChunks(node, code, splittableTypes, language, filePath) {
+        const chunks = [];
+        const traverse = (current, parentName) => {
+            if (splittableTypes.includes(current.type)) {
+                const text = code.slice(current.startIndex, current.endIndex);
+                if (text.trim().length > 0) {
+                    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, parentName);
+            }
+        };
+        traverse(node);
+        return chunks;
+    }
+    refineChunks(chunks) {
+        const result = [];
+        for (const chunk of chunks) {
+            if (chunk.content.length <= MAX_CHUNK_CHARS) {
+                result.push(chunk);
+            }
+            else {
+                result.push(...this.splitLargeChunk(chunk));
+            }
+        }
+        return result;
+    }
+    splitLargeChunk(chunk) {
+        const lines = chunk.content.split('\n');
+        const subChunks = [];
+        let current = '';
+        let startLine = chunk.startLine;
+        let lineCount = 0;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const addition = i < lines.length - 1 ? line + '\n' : line;
+            if (current.length + addition.length > MAX_CHUNK_CHARS && current.length > 0) {
+                subChunks.push({
+                    content: current,
+                    startLine,
+                    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;
+                lineCount = 1;
+            }
+            else {
+                current += addition;
+                lineCount++;
+            }
+        }
+        if (current.trim().length > 0) {
+            subChunks.push({
+                content: current,
+                startLine,
+                endLine: startLine + lineCount - 1,
+                language: chunk.language,
+                filePath: chunk.filePath,
+                symbolName: chunk.symbolName,
+                symbolKind: chunk.symbolKind,
+                symbolSignature: chunk.symbolSignature,
+                parentSymbol: chunk.parentSymbol,
+            });
+        }
+        return subChunks;
+    }
+}
+//# sourceMappingURL=ast.js.map

package/dist/splitter/line.d.ts

@@ -0,0 +1,10 @@
+import type { Splitter, CodeChunk } from './types.js';
+export declare class LineSplitter implements Splitter {
+    private chunkLines;
+    private overlapLines;
+    constructor(chunkLines?: number, overlapLines?: number);
+    split(code: string, language: string, filePath: string): CodeChunk[];
+    private refineChunks;
+    private splitLargeChunk;
+}
+//# sourceMappingURL=line.d.ts.map

package/dist/splitter/line.js

@@ -0,0 +1,103 @@
+import { MAX_CHUNK_CHARS } from './types.js';
+const DEFAULT_CHUNK_LINES = 60;
+const OVERLAP_LINES = 5;
+export class LineSplitter {
+    chunkLines;
+    overlapLines;
+    constructor(chunkLines = DEFAULT_CHUNK_LINES, overlapLines = OVERLAP_LINES) {
+        this.chunkLines = chunkLines;
+        this.overlapLines = Math.min(overlapLines, chunkLines - 1);
+    }
+    split(code, language, filePath) {
+        const lines = code.split('\n');
+        if (lines.length === 0)
+            return [];
+        const raw = [];
+        let start = 0;
+        while (start < lines.length) {
+            const end = Math.min(start + this.chunkLines, lines.length);
+            const content = lines.slice(start, end).join('\n');
+            if (content.trim().length > 0) {
+                raw.push({
+                    content,
+                    startLine: start + 1,
+                    endLine: end,
+                    language,
+                    filePath,
+                });
+            }
+            start = Math.max(start + 1, end - this.overlapLines);
+        }
+        return this.refineChunks(raw);
+    }
+    refineChunks(chunks) {
+        const result = [];
+        for (const chunk of chunks) {
+            if (chunk.content.length <= MAX_CHUNK_CHARS) {
+                result.push(chunk);
+            }
+            else {
+                result.push(...this.splitLargeChunk(chunk));
+            }
+        }
+        return result;
+    }
+    splitLargeChunk(chunk) {
+        const lines = chunk.content.split('\n');
+        const subChunks = [];
+        let current = '';
+        let startLine = chunk.startLine;
+        let lineCount = 0;
+        const flush = () => {
+            if (current.trim().length > 0) {
+                subChunks.push({
+                    content: current,
+                    startLine,
+                    endLine: startLine + lineCount - 1,
+                    language: chunk.language,
+                    filePath: chunk.filePath,
+                });
+            }
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const addition = i < lines.length - 1 ? line + '\n' : line;
+            if (current.length + addition.length > MAX_CHUNK_CHARS && current.length > 0) {
+                flush();
+                current = '';
+                startLine = chunk.startLine + i;
+                lineCount = 0;
+            }
+            if (addition.length > MAX_CHUNK_CHARS) {
+                if (current.length > 0) {
+                    flush();
+                    current = '';
+                    startLine = chunk.startLine + i;
+                    lineCount = 0;
+                }
+                const lineNum = chunk.startLine + i;
+                for (let offset = 0; offset < addition.length; offset += MAX_CHUNK_CHARS) {
+                    const slice = addition.slice(offset, offset + MAX_CHUNK_CHARS);
+                    if (slice.trim().length > 0) {
+                        subChunks.push({
+                            content: slice,
+                            startLine: lineNum,
+                            endLine: lineNum,
+                            language: chunk.language,
+                            filePath: chunk.filePath,
+                        });
+                    }
+                }
+                startLine = chunk.startLine + i + 1;
+                lineCount = 0;
+            }
+            else {
+                current += addition;
+                lineCount++;
+            }
+        }
+        flush();
+        return subChunks;
+    }
+}
+//# sourceMappingURL=line.js.map

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

@@ -0,0 +1,16 @@
+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[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/splitter/types.js

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

@@ -0,0 +1,7 @@
+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;
+export declare function findProjectByPath(dir: string): string | undefined;
+export {};
+//# sourceMappingURL=registry.d.ts.map