claude-eidetic 0.1.1 → 0.1.2

package/dist/precompact/transcript-parser.js

@@ -0,0 +1,148 @@
+/**
+ * Parse Claude Code transcript JSONL to extract session data.
+ * Extracts deterministic data from tool calls - no LLM needed.
+ */
+import fs from 'node:fs';
+import readline from 'node:readline';
+import { truncateUnicode } from './utils.js';
+const MAX_BASH_COMMANDS = 20;
+const MAX_USER_MESSAGES = 5;
+const BASH_COMMAND_MAX_LENGTH = 120;
+const USER_MESSAGE_MAX_LENGTH = 200;
+/**
+ * Parse a transcript JSONL file and extract session data.
+ */
+export async function parseTranscript(transcriptPath, sessionId, projectName, projectPath, trigger = 'auto') {
+    const filesModified = new Set();
+    const bashCommands = [];
+    const mcpToolsCalled = new Set();
+    const tasksCreated = [];
+    const tasksUpdated = [];
+    const taskIdToSubject = new Map();
+    const userMessages = [];
+    let branch = null;
+    let startTime = null;
+    let endTime = null;
+    const fileStream = fs.createReadStream(transcriptPath);
+    const rl = readline.createInterface({
+        input: fileStream,
+        crlfDelay: Infinity,
+    });
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            // Skip malformed JSON lines
+            continue;
+        }
+        // Extract timestamps
+        if (parsed.timestamp) {
+            if (!startTime)
+                startTime = parsed.timestamp;
+            endTime = parsed.timestamp;
+        }
+        // Extract git branch from first entry that has it
+        if (!branch && parsed.gitBranch) {
+            branch = parsed.gitBranch;
+        }
+        // Extract user messages
+        if (parsed.type === 'user' && userMessages.length < MAX_USER_MESSAGES) {
+            const text = extractUserText(parsed);
+            if (text) {
+                userMessages.push(truncateUnicode(text, USER_MESSAGE_MAX_LENGTH));
+            }
+        }
+        // Extract tool calls from assistant messages
+        if (parsed.type === 'assistant' && parsed.message?.content) {
+            for (const content of parsed.message.content) {
+                if (content.type !== 'tool_use')
+                    continue;
+                const toolContent = content;
+                processToolCall(toolContent, {
+                    filesModified,
+                    bashCommands,
+                    mcpToolsCalled,
+                    tasksCreated,
+                    tasksUpdated,
+                    taskIdToSubject,
+                });
+            }
+        }
+    }
+    return {
+        sessionId,
+        projectName,
+        projectPath,
+        branch,
+        startTime: startTime ?? 'unknown',
+        endTime: endTime ?? 'unknown',
+        filesModified: Array.from(filesModified).sort(),
+        bashCommands,
+        mcpToolsCalled: Array.from(mcpToolsCalled).sort(),
+        tasksCreated,
+        tasksUpdated,
+        userMessages,
+        trigger,
+    };
+}
+function processToolCall(content, state) {
+    const { name, input } = content;
+    // File modifications
+    if (name === 'Write' || name === 'Edit') {
+        const filePath = input.file_path;
+        if (typeof filePath === 'string') {
+            state.filesModified.add(filePath);
+        }
+    }
+    // Bash commands (enforce limit during collection)
+    if (name === 'Bash' && state.bashCommands.length < MAX_BASH_COMMANDS) {
+        const command = input.command;
+        if (typeof command === 'string') {
+            state.bashCommands.push(truncateUnicode(command, BASH_COMMAND_MAX_LENGTH));
+        }
+    }
+    // Task operations - track subject by taskId for later updates
+    if (name === 'TaskCreate') {
+        const subject = input.subject;
+        const taskId = input.taskId;
+        if (typeof subject === 'string') {
+            state.tasksCreated.push(subject);
+            // Track subject by taskId if available (for future TaskUpdate lookups)
+            if (typeof taskId === 'string') {
+                state.taskIdToSubject.set(taskId, subject);
+            }
+        }
+    }
+    if (name === 'TaskUpdate') {
+        const taskId = input.taskId;
+        const status = input.status;
+        // Try to get subject from input first, then from tracked tasks
+        let subject = input.subject;
+        if (typeof subject !== 'string' && typeof taskId === 'string') {
+            subject = state.taskIdToSubject.get(taskId);
+        }
+        if (typeof subject === 'string' && typeof status === 'string') {
+            state.tasksUpdated.push(`${subject} → ${status}`);
+        }
+    }
+    // MCP tools
+    if (name.startsWith('mcp__')) {
+        state.mcpToolsCalled.add(name);
+    }
+}
+function extractUserText(line) {
+    const content = line.message?.content;
+    if (!Array.isArray(content))
+        return null;
+    for (const block of content) {
+        if (block.type === 'text' && typeof block.text === 'string') {
+            return block.text;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=transcript-parser.js.map

package/dist/precompact/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Types for PreCompact hook - automatic session persistence before context compaction.
+ */
+/**
+ * Input received from Claude Code PreCompact hook via stdin.
+ */
+export interface PreCompactInput {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    trigger: 'auto' | 'manual';
+    hook_event_name: 'PreCompact';
+}
+/**
+ * Input received from Claude Code SessionEnd hook via stdin.
+ */
+export interface SessionEndInput {
+    session_id: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: 'SessionEnd';
+    reason?: string;
+}
+/**
+ * Session data extracted from transcript JSONL.
+ * Contains deterministic data parsed directly from tool calls.
+ */
+export interface ExtractedSession {
+    sessionId: string;
+    projectName: string;
+    projectPath: string;
+    branch: string | null;
+    startTime: string;
+    endTime: string;
+    filesModified: string[];
+    bashCommands: string[];
+    mcpToolsCalled: string[];
+    tasksCreated: string[];
+    tasksUpdated: string[];
+    userMessages: string[];
+    trigger: 'auto' | 'manual' | 'session_end';
+}
+/**
+ * Compact session record for Tier-0 fast lookup.
+ * Stored in .session-index.json for instant SessionStart injection.
+ */
+export interface Tier0Record {
+    sessionId: string;
+    date: string;
+    branch: string | null;
+    filesModified: string[];
+    tasksCreated: string[];
+    trigger: 'auto' | 'manual' | 'session_end';
+    noteFile: string;
+}
+/**
+ * Session index for a project - enables fast SessionStart context injection.
+ * Stored at ~/.eidetic/notes/<project>/.session-index.json
+ */
+export interface SessionIndex {
+    project: string;
+    sessions: Tier0Record[];
+    lastUpdated: string;
+}
+/**
+ * A single line from the Claude Code transcript JSONL.
+ */
+export interface TranscriptLine {
+    type: 'user' | 'assistant' | 'system';
+    timestamp?: string;
+    gitBranch?: string;
+    message?: {
+        role?: string;
+        content?: TranscriptContent[];
+    };
+}
+/**
+ * Content block within a transcript message.
+ */
+export type TranscriptContent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_use';
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: unknown;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/precompact/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for PreCompact hook - automatic session persistence before context compaction.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/precompact/utils.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared utilities for precompact module.
+ */
+/**
+ * Extract YYYY-MM-DD date from ISO timestamp or return today's date.
+ */
+export declare function extractDate(timestamp: string): string;
+/**
+ * Get the notes directory for a project.
+ * Uses paths.ts normalization for consistency.
+ */
+export declare function getNotesDir(projectName: string): string;
+/**
+ * Truncate a string to maxLength with proper Unicode handling.
+ * Avoids splitting surrogate pairs (emoji, CJK characters).
+ * Adds ellipsis if truncated.
+ */
+export declare function truncateUnicode(str: string, maxLength: number): string;
+/**
+ * Write file atomically using write-to-temp-then-rename pattern.
+ * Prevents corruption from concurrent writes or process termination.
+ */
+export declare function writeFileAtomic(filePath: string, content: string): void;
+/**
+ * Generate a stable project identifier from path.
+ * Handles project name collisions by including path hash.
+ */
+export declare function getProjectId(projectPath: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/precompact/utils.js

@@ -0,0 +1,95 @@
+/**
+ * Shared utilities for precompact module.
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+import { getConfig } from '../config.js';
+import { normalizePath } from '../paths.js';
+/**
+ * Extract YYYY-MM-DD date from ISO timestamp or return today's date.
+ */
+export function extractDate(timestamp) {
+    if (timestamp === 'unknown' || !timestamp) {
+        return new Date().toISOString().slice(0, 10);
+    }
+    // Handle ISO format: 2026-02-19T10:00:00Z
+    const match = /^(\d{4}-\d{2}-\d{2})/.exec(timestamp);
+    if (match) {
+        return match[1];
+    }
+    return new Date().toISOString().slice(0, 10);
+}
+/**
+ * Get the notes directory for a project.
+ * Uses paths.ts normalization for consistency.
+ */
+export function getNotesDir(projectName) {
+    const config = getConfig();
+    // Expand ~ and normalize path
+    const dataDir = normalizePath(config.eideticDataDir);
+    return path.join(dataDir, 'notes', projectName);
+}
+/**
+ * Truncate a string to maxLength with proper Unicode handling.
+ * Avoids splitting surrogate pairs (emoji, CJK characters).
+ * Adds ellipsis if truncated.
+ */
+export function truncateUnicode(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    // Convert to array of code points to handle surrogate pairs correctly
+    const codePoints = Array.from(str);
+    if (codePoints.length <= maxLength)
+        return str;
+    // Leave room for ellipsis
+    const truncated = codePoints.slice(0, maxLength - 1).join('');
+    return truncated + '…';
+}
+/**
+ * Write file atomically using write-to-temp-then-rename pattern.
+ * Prevents corruption from concurrent writes or process termination.
+ */
+export function writeFileAtomic(filePath, content) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    // Create temp file in same directory (required for atomic rename)
+    const tempPath = path.join(dir, `.tmp-${process.pid}-${Date.now()}`);
+    try {
+        fs.writeFileSync(tempPath, content, 'utf-8');
+        fs.renameSync(tempPath, filePath);
+    }
+    catch (err) {
+        // Clean up temp file on failure
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+        throw err;
+    }
+}
+/**
+ * Generate a stable project identifier from path.
+ * Handles project name collisions by including path hash.
+ */
+export function getProjectId(projectPath) {
+    const normalized = normalizePath(projectPath);
+    const basename = path.basename(normalized);
+    // Create short hash of full path to disambiguate same-named projects
+    const hash = simpleHash(normalized).slice(0, 6);
+    return `${basename}-${hash}`;
+}
+/**
+ * Simple non-cryptographic hash for path disambiguation.
+ */
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(36);
+}
+//# sourceMappingURL=utils.js.map

package/dist/setup-message.d.ts

@@ -1,3 +1,3 @@
-/** Centralized setup/error messages — easy to update links and instructions. */
-export declare function getSetupErrorMessage(errorDetail: string): string;
+export type SetupContext = 'missing' | 'invalid' | 'unknown';
+export declare function getSetupErrorMessage(errorDetail: string, context?: SetupContext): string;
 //# sourceMappingURL=setup-message.d.ts.map

package/dist/setup-message.js

@@ -1,23 +1,42 @@
-/** Centralized setup/error messages — easy to update links and instructions. */
-const OPENAI_KEY_URL = 'https://platform.openai.com/api-keys';
-export function getSetupErrorMessage(errorDetail) {
-    return (`Eidetic setup required: ${errorDetail}\n\n` +
+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';
+}
+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. **Get an API key**: ${OPENAI_KEY_URL}\n` +
-        '2. **Add it to your config** (pick one):\n\n' +
-        '### Quick (CLI)\n\n' +
-        '```\nclaude mcp update claude-eidetic -e OPENAI_API_KEY=sk-your-key-here\n```\n\n' +
-        '### Manual\n\n' +
-        'Edit `~/.claude/plugins/claude-eidetic/config.json`:\n' +
-        '```json\n' +
-        '{\n' +
-        '  "env": {\n' +
-        '    "OPENAI_API_KEY": "sk-your-key-here"\n' +
-        '  }\n' +
-        '}\n' +
-        '```\n\n' +
-        '### Using Ollama instead (free, local)\n\n' +
-        'Set `EMBEDDING_PROVIDER=ollama` in the same env block (requires Ollama running locally with `nomic-embed-text`).\n\n' +
-        '3. **Restart Claude Code** for changes to take effect.');
+        `1. ${block.step1}\n` +
+        '2. **Set or update your config** (pick one):\n\n' +
+        msgs.setup.config_instructions +
+        `3. ${msgs.setup.footer}`);
+}
+// Called by plugin/hooks/session-start.sh
+if (process.argv[1] === __filename) {
+    const context = process.argv[2] ?? 'missing';
+    const detail = process.argv[3] ?? 'OPENAI_API_KEY is not set.';
+    console.log(JSON.stringify({ additionalContext: getSetupErrorMessage(detail, context) }));
 }
 //# sourceMappingURL=setup-message.js.map

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