claude-eidetic 0.1.0 → 0.1.2

package/dist/precompact/tier0-writer.js

@@ -0,0 +1,74 @@
+/**
+ * Maintain .session-index.json for Tier-0 fast SessionStart context injection.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { extractDate, writeFileAtomic } from './utils.js';
+const MAX_SESSIONS = 10;
+const INDEX_FILENAME = '.session-index.json';
+/**
+ * Update the session index with a new session record.
+ * Prepends the new session and keeps only the last 10.
+ * Uses atomic write to prevent corruption from concurrent access.
+ */
+export function updateSessionIndex(notesDir, session, noteFile) {
+    const indexPath = path.join(notesDir, INDEX_FILENAME);
+    // Load existing index or create new
+    let index;
+    if (fs.existsSync(indexPath)) {
+        try {
+            const content = fs.readFileSync(indexPath, 'utf-8');
+            index = JSON.parse(content);
+        }
+        catch {
+            // Corrupted index, start fresh
+            index = createEmptyIndex(session.projectName);
+        }
+    }
+    else {
+        index = createEmptyIndex(session.projectName);
+    }
+    // Create new record
+    const record = {
+        sessionId: session.sessionId,
+        date: extractDate(session.startTime),
+        branch: session.branch,
+        filesModified: session.filesModified,
+        tasksCreated: session.tasksCreated,
+        trigger: session.trigger,
+        noteFile,
+    };
+    // Prepend new session and trim to max
+    index.sessions = [record, ...index.sessions].slice(0, MAX_SESSIONS);
+    index.project = session.projectName;
+    index.lastUpdated = new Date().toISOString();
+    // Ensure directory exists
+    fs.mkdirSync(notesDir, { recursive: true });
+    // Write atomically to prevent corruption from concurrent hooks
+    writeFileAtomic(indexPath, JSON.stringify(index, null, 2));
+}
+/**
+ * Read the session index for a project.
+ * Returns null if not found or corrupted.
+ */
+export function readSessionIndex(notesDir) {
+    const indexPath = path.join(notesDir, INDEX_FILENAME);
+    if (!fs.existsSync(indexPath)) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(indexPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function createEmptyIndex(project) {
+    return {
+        project,
+        sessions: [],
+        lastUpdated: new Date().toISOString(),
+    };
+}
+//# sourceMappingURL=tier0-writer.js.map

package/dist/precompact/transcript-parser.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parse Claude Code transcript JSONL to extract session data.
+ * Extracts deterministic data from tool calls - no LLM needed.
+ */
+import type { ExtractedSession } from './types.js';
+/**
+ * Parse a transcript JSONL file and extract session data.
+ */
+export declare function parseTranscript(transcriptPath: string, sessionId: string, projectName: string, projectPath: string, trigger?: 'auto' | 'manual' | 'session_end'): Promise<ExtractedSession>;
+//# sourceMappingURL=transcript-parser.d.ts.map

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

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

@@ -0,0 +1,42 @@
+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. ${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