claude-eidetic 0.1.1 → 0.1.2

package/dist/paths.d.ts

@@ -1,11 +1,10 @@
-/**
- * Normalize a path to forward slashes, resolve to absolute, remove trailing slash.
- * This is the single source of truth for path handling — called at every boundary.
- */
 export declare function normalizePath(inputPath: string): string;
 export declare function getDataDir(): string;
 export declare function getSnapshotDir(): string;
 export declare function getCacheDir(): string;
 export declare function getRegistryPath(): string;
 export declare function pathToCollectionName(absolutePath: string): string;
+export declare function getDocMetadataPath(): string;
+export declare function getMemoryDbPath(): string;
+export declare function docCollectionName(library: string): string;
 //# sourceMappingURL=paths.d.ts.map

package/dist/paths.js

@@ -1,10 +1,6 @@
 import path from 'node:path';
 import os from 'node:os';
 import { getConfig } from './config.js';
-/**
- * Normalize a path to forward slashes, resolve to absolute, remove trailing slash.
- * This is the single source of truth for path handling — called at every boundary.
- */
 export function normalizePath(inputPath) {
     let resolved = inputPath;
     if (resolved.startsWith('~')) {
@@ -38,4 +34,18 @@ export function pathToCollectionName(absolutePath) {
         .replace(/^_|_$/g, '');
     return `eidetic_${safe}`;
 }
+export function getDocMetadataPath() {
+    return `${getDataDir()}/doc-metadata.json`;
+}
+export function getMemoryDbPath() {
+    return `${getDataDir()}/memory-history.db`;
+}
+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/precompact/hook.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Hook entry point for PreCompact and SessionEnd events.
+ *
+ * PreCompact: Parses transcript, writes session note, updates index, spawns background indexer.
+ * SessionEnd: Same as PreCompact + runs memory extraction pipeline (semantic facts → Qdrant).
+ */
+export {};
+//# sourceMappingURL=hook.d.ts.map

package/dist/precompact/hook.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+/**
+ * Hook entry point for PreCompact and SessionEnd events.
+ *
+ * PreCompact: Parses transcript, writes session note, updates index, spawns background indexer.
+ * SessionEnd: Same as PreCompact + runs memory extraction pipeline (semantic facts → Qdrant).
+ */
+import { z } from 'zod';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseTranscript } from './transcript-parser.js';
+import { writeSessionNote } from './note-writer.js';
+import { updateSessionIndex, readSessionIndex } from './tier0-writer.js';
+import { spawnBackgroundIndexer } from './session-indexer.js';
+import { getNotesDir, getProjectId } from './utils.js';
+// Resolve index-runner path at module boundary (follows project convention)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const INDEX_RUNNER_PATH = path.join(__dirname, 'index-runner.js');
+// Zod schema — handles both PreCompact and SessionEnd hook events
+const HookInputSchema = z.discriminatedUnion('hook_event_name', [
+    z.object({
+        session_id: z.string(),
+        transcript_path: z.string(),
+        cwd: z.string(),
+        trigger: z.enum(['auto', 'manual']),
+        hook_event_name: z.literal('PreCompact'),
+    }),
+    z.object({
+        session_id: z.string(),
+        transcript_path: z.string(),
+        cwd: z.string(),
+        hook_event_name: z.literal('SessionEnd'),
+        reason: z.string().optional(),
+    }),
+]);
+async function main() {
+    try {
+        const input = await readStdin();
+        const parseResult = HookInputSchema.safeParse(JSON.parse(input));
+        if (!parseResult.success) {
+            outputError(`Invalid hook input: ${parseResult.error.message}`);
+            return;
+        }
+        const hookInput = parseResult.data;
+        const projectId = getProjectId(hookInput.cwd);
+        const notesDir = getNotesDir(projectId);
+        const trigger = hookInput.hook_event_name === 'PreCompact' ? hookInput.trigger : 'session_end';
+        // Parse transcript
+        const session = await parseTranscript(hookInput.transcript_path, hookInput.session_id, projectId, hookInput.cwd, trigger);
+        let noteFile;
+        let skippedNote = false;
+        if (hookInput.hook_event_name === 'SessionEnd') {
+            // Dedup check: skip note if already captured by PreCompact
+            const existingIndex = readSessionIndex(notesDir);
+            const alreadyCaptured = existingIndex?.sessions.some((s) => s.sessionId === hookInput.session_id) ?? false;
+            if (alreadyCaptured) {
+                skippedNote = true;
+                // Use placeholder path — note already exists
+                // existingIndex is non-null here: alreadyCaptured implies existingIndex?.sessions.some() returned true
+                const sessions = existingIndex?.sessions ?? [];
+                const existing = sessions.find((s) => s.sessionId === hookInput.session_id);
+                noteFile = existing?.noteFile ?? writeSessionNote(notesDir, session);
+                process.stderr.write(`[eidetic] SessionEnd: session ${hookInput.session_id} already captured by PreCompact, skipping note\n`);
+            }
+            else {
+                noteFile = writeSessionNote(notesDir, session);
+                updateSessionIndex(notesDir, session, noteFile);
+                spawnBackgroundIndexer(notesDir, INDEX_RUNNER_PATH);
+            }
+            // Run memory extraction (best-effort — graceful failure if Qdrant unavailable)
+            const memoryActions = await extractMemories(session);
+            outputSuccess({
+                noteFile,
+                skippedNote,
+                filesModified: session.filesModified.length,
+                tasksCreated: session.tasksCreated.length,
+                memoriesExtracted: memoryActions,
+            });
+        }
+        else {
+            // PreCompact: original flow
+            noteFile = writeSessionNote(notesDir, session);
+            updateSessionIndex(notesDir, session, noteFile);
+            spawnBackgroundIndexer(notesDir, INDEX_RUNNER_PATH);
+            outputSuccess({
+                noteFile,
+                filesModified: session.filesModified.length,
+                tasksCreated: session.tasksCreated.length,
+            });
+        }
+    }
+    catch (err) {
+        outputError(err instanceof Error ? err.message : String(err));
+    }
+}
+/**
+ * Build content string for memory extraction from an ExtractedSession.
+ */
+function buildMemoryContent(session) {
+    const parts = [];
+    if (session.userMessages.length > 0) {
+        parts.push('User messages:');
+        session.userMessages.forEach((msg, i) => {
+            parts.push(`${i + 1}. ${msg}`);
+        });
+    }
+    if (session.filesModified.length > 0) {
+        parts.push(`\nFiles modified: ${session.filesModified.join(', ')}`);
+    }
+    if (session.tasksCreated.length > 0) {
+        parts.push(`Tasks: ${session.tasksCreated.join(', ')}`);
+    }
+    if (session.branch) {
+        parts.push(`Branch: ${session.branch}`);
+    }
+    return parts.join('\n');
+}
+/**
+ * Run memory extraction pipeline. Returns count of actions taken.
+ * Fails gracefully — logs to stderr if Qdrant or LLM unavailable.
+ */
+async function extractMemories(session) {
+    const content = buildMemoryContent(session);
+    if (!content.trim())
+        return 0;
+    try {
+        // Dynamic imports to avoid loading heavy deps on every hook invocation
+        const [{ loadConfig }, { createEmbedding }, { QdrantVectorDB }, { MemoryHistory }, { MemoryStore }, { getMemoryDbPath },] = await Promise.all([
+            import('../config.js'),
+            import('../embedding/factory.js'),
+            import('../vectordb/qdrant.js'),
+            import('../memory/history.js'),
+            import('../memory/store.js'),
+            import('../paths.js'),
+        ]);
+        const config = loadConfig();
+        const embedding = createEmbedding(config);
+        await embedding.initialize();
+        const vectordb = new QdrantVectorDB();
+        const history = new MemoryHistory(getMemoryDbPath());
+        const memoryStore = new MemoryStore(embedding, vectordb, history);
+        const actions = await memoryStore.addMemory(content, 'session-end-hook');
+        process.stderr.write(`[eidetic] Memory extraction: ${actions.length} action(s) (${actions.map((a) => a.event).join(', ') || 'none'})\n`);
+        return actions.length;
+    }
+    catch (err) {
+        process.stderr.write(`[eidetic] Memory extraction failed (non-fatal): ${err instanceof Error ? err.message : String(err)}\n`);
+        return 0;
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}
+function outputSuccess(result) {
+    const output = {
+        hookSpecificOutput: { success: true, ...result },
+    };
+    process.stdout.write(JSON.stringify(output));
+}
+function outputError(message) {
+    process.stderr.write(JSON.stringify({ error: message }) + '\n');
+    process.stdout.write(JSON.stringify({ hookSpecificOutput: {} }));
+}
+void main();
+//# sourceMappingURL=hook.js.map

package/dist/precompact/index-runner.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for background indexing of session notes.
+ * Called by session-indexer.ts as a detached child process.
+ *
+ * Usage: node index-runner.js <notes-directory>
+ */
+export {};
+//# sourceMappingURL=index-runner.d.ts.map

package/dist/precompact/index-runner.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+/**
+ * Standalone CLI for background indexing of session notes.
+ * Called by session-indexer.ts as a detached child process.
+ *
+ * Usage: node index-runner.js <notes-directory>
+ */
+import { indexCodebase } from '../core/indexer.js';
+import { createEmbedding } from '../embedding/factory.js';
+import { QdrantVectorDB } from '../vectordb/qdrant.js';
+import { bootstrapQdrant } from '../infra/qdrant-bootstrap.js';
+import { loadConfig } from '../config.js';
+import { registerProject } from '../state/registry.js';
+async function main() {
+    const notesDir = process.argv[2];
+    if (!notesDir) {
+        process.stderr.write('Usage: index-runner.js <notes-directory>\n');
+        process.exit(1);
+    }
+    try {
+        // Load config (requires OPENAI_API_KEY in env)
+        const config = loadConfig();
+        // Create embedding provider
+        const embedding = createEmbedding(config);
+        await embedding.initialize();
+        // Create vectordb using factory pattern (respects VECTORDB_PROVIDER)
+        let vectordb;
+        if (config.vectordbProvider === 'milvus') {
+            const { MilvusVectorDB } = await import('../vectordb/milvus.js');
+            vectordb = new MilvusVectorDB();
+        }
+        else {
+            const qdrantUrl = await bootstrapQdrant();
+            vectordb = new QdrantVectorDB(qdrantUrl, config.qdrantApiKey);
+        }
+        // Index the notes directory
+        const result = await indexCodebase(notesDir, embedding, vectordb, false, // don't force re-index
+        undefined, // no progress callback
+        ['.md'], // only markdown files
+        []);
+        // Register project in registry for discovery
+        registerProject(notesDir);
+        process.stderr.write(`Indexed ${result.totalFiles} files (${result.totalChunks} chunks) in ${result.durationMs}ms\n`);
+    }
+    catch (err) {
+        // Best effort - log error but don't crash loudly
+        process.stderr.write(`Background indexing failed: ${String(err)}\n`);
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=index-runner.js.map

package/dist/precompact/note-writer.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Format and write session notes compatible with /wrapup and /catchup.
+ */
+import type { ExtractedSession } from './types.js';
+/**
+ * Format an extracted session as a markdown note.
+ * Output format matches /wrapup template for /catchup compatibility.
+ */
+export declare function formatSessionNote(session: ExtractedSession): string;
+/**
+ * Write a session note to disk.
+ * Returns the full path to the written file.
+ */
+export declare function writeSessionNote(notesDir: string, session: ExtractedSession): string;
+//# sourceMappingURL=note-writer.d.ts.map

package/dist/precompact/note-writer.js

@@ -0,0 +1,109 @@
+/**
+ * Format and write session notes compatible with /wrapup and /catchup.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { extractDate, writeFileAtomic } from './utils.js';
+/**
+ * Format an extracted session as a markdown note.
+ * Output format matches /wrapup template for /catchup compatibility.
+ */
+export function formatSessionNote(session) {
+    const date = extractDate(session.startTime);
+    const branch = session.branch ?? 'unknown';
+    const lines = [];
+    // YAML frontmatter
+    lines.push('---');
+    lines.push(`project: ${session.projectName}`);
+    lines.push(`date: ${date}`);
+    lines.push(`branch: ${branch}`);
+    lines.push(`session_id: ${session.sessionId}`);
+    lines.push(`trigger: ${session.trigger}`);
+    lines.push('---');
+    lines.push('');
+    // Header
+    lines.push(`# ${session.projectName} — ${date}: Auto-captured session`);
+    lines.push('');
+    lines.push(`**Date:** ${date}`);
+    lines.push(`**Project:** ${session.projectName}`);
+    lines.push(`**Branch:** ${branch}`);
+    lines.push('');
+    // User Requests
+    if (session.userMessages.length > 0) {
+        lines.push('## User Requests');
+        session.userMessages.forEach((msg, i) => {
+            lines.push(`${i + 1}. ${msg}`);
+        });
+        lines.push('');
+    }
+    // Changes
+    lines.push('## Changes');
+    if (session.filesModified.length > 0) {
+        session.filesModified.forEach((file) => {
+            lines.push(`- \`${file}\``);
+        });
+    }
+    else {
+        lines.push('*No file modifications detected.*');
+    }
+    lines.push('');
+    // Tasks
+    lines.push('## Tasks');
+    if (session.tasksCreated.length > 0 || session.tasksUpdated.length > 0) {
+        session.tasksCreated.forEach((task) => {
+            lines.push(`- Created: ${task}`);
+        });
+        session.tasksUpdated.forEach((task) => {
+            lines.push(`- Updated: ${task}`);
+        });
+    }
+    else {
+        lines.push('*No tasks created or updated.*');
+    }
+    lines.push('');
+    // Commands
+    lines.push('## Commands');
+    if (session.bashCommands.length > 0) {
+        session.bashCommands.forEach((cmd) => {
+            lines.push(`- \`${cmd}\``);
+        });
+    }
+    else {
+        lines.push('*No commands recorded.*');
+    }
+    lines.push('');
+    // MCP Tools
+    if (session.mcpToolsCalled.length > 0) {
+        lines.push('## MCP Tools');
+        session.mcpToolsCalled.forEach((tool) => {
+            lines.push(`- ${tool}`);
+        });
+        lines.push('');
+    }
+    // Decisions (placeholder)
+    lines.push('## Decisions');
+    lines.push('*Auto-captured. Run /wrapup for decisions with rationale.*');
+    lines.push('');
+    // Open Questions (placeholder)
+    lines.push('## Open Questions');
+    lines.push('*Run /wrapup to capture open questions.*');
+    lines.push('');
+    return lines.join('\n');
+}
+/**
+ * Write a session note to disk.
+ * Returns the full path to the written file.
+ */
+export function writeSessionNote(notesDir, session) {
+    // Ensure directory exists
+    fs.mkdirSync(notesDir, { recursive: true });
+    const date = extractDate(session.startTime);
+    const shortId = session.sessionId.slice(0, 8);
+    const filename = `${date}-auto-${shortId}.md`;
+    const filePath = path.join(notesDir, filename);
+    const content = formatSessionNote(session);
+    // Use atomic write for note files (less critical than index, but still good)
+    writeFileAtomic(filePath, content);
+    return filePath;
+}
+//# sourceMappingURL=note-writer.js.map

package/dist/precompact/session-indexer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Spawn background process to index session notes into Qdrant.
+ * Non-blocking: hook returns immediately while indexing continues.
+ */
+/**
+ * Spawn a detached background process to index the notes directory.
+ * The process runs independently and won't block the hook.
+ *
+ * @param notesDir - Directory containing session notes to index
+ * @param indexRunnerPath - Full path to the index-runner.js script
+ */
+export declare function spawnBackgroundIndexer(notesDir: string, indexRunnerPath: string): void;
+//# sourceMappingURL=session-indexer.d.ts.map

package/dist/precompact/session-indexer.js

@@ -0,0 +1,31 @@
+/**
+ * Spawn background process to index session notes into Qdrant.
+ * Non-blocking: hook returns immediately while indexing continues.
+ */
+import { spawn } from 'node:child_process';
+/**
+ * Spawn a detached background process to index the notes directory.
+ * The process runs independently and won't block the hook.
+ *
+ * @param notesDir - Directory containing session notes to index
+ * @param indexRunnerPath - Full path to the index-runner.js script
+ */
+export function spawnBackgroundIndexer(notesDir, indexRunnerPath) {
+    try {
+        const child = spawn(process.execPath, [indexRunnerPath, notesDir], {
+            detached: true,
+            stdio: 'ignore',
+            // Inherit environment for OPENAI_API_KEY, QDRANT_URL, etc.
+            env: process.env,
+            // Prevent the parent process from waiting for this child
+            windowsHide: true,
+        });
+        // Unref so the parent can exit independently
+        child.unref();
+    }
+    catch {
+        // Best effort - if spawn fails, just skip indexing
+        // The notes are already saved, indexing can happen later
+    }
+}
+//# sourceMappingURL=session-indexer.js.map

package/dist/precompact/tier0-inject.d.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+/**
+ * Inject Tier-0 context at SessionStart.
+ * Called by session-start hook to output compact session summary.
+ *
+ * Outputs to stdout for hook to capture and inject into session.
+ */
+declare function detectProjectRoot(cwd: string): string | null;
+declare function formatTier0Context(session: {
+    date: string;
+    branch: string | null;
+    filesModified: string[];
+    tasksCreated: string[];
+}, totalSessions: number): string;
+export { formatTier0Context, detectProjectRoot };
+//# sourceMappingURL=tier0-inject.d.ts.map

package/dist/precompact/tier0-inject.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+/**
+ * Inject Tier-0 context at SessionStart.
+ * Called by session-start hook to output compact session summary.
+ *
+ * Outputs to stdout for hook to capture and inject into session.
+ */
+import { execSync } from 'node:child_process';
+import path from 'node:path';
+import { readSessionIndex } from './tier0-writer.js';
+import { getNotesDir, getProjectId } from './utils.js';
+const MAX_FILES_SHOWN = 5;
+function main() {
+    try {
+        // Get cwd from environment (set by Claude Code) or detect from git
+        const cwd = process.env.CLAUDE_CWD || process.cwd();
+        // Detect project root from git
+        const projectPath = detectProjectRoot(cwd);
+        if (!projectPath) {
+            // Not in a git repo, nothing to inject
+            return;
+        }
+        // Use consistent project ID (handles name collisions)
+        const projectId = getProjectId(projectPath);
+        const notesDir = getNotesDir(projectId);
+        // Read session index
+        const index = readSessionIndex(notesDir);
+        if (!index || index.sessions.length === 0) {
+            // No previous sessions
+            return;
+        }
+        // Get most recent session
+        const latest = index.sessions[0];
+        // Format compact output (~50 tokens)
+        const output = formatTier0Context(latest, index.sessions.length);
+        process.stdout.write(output);
+    }
+    catch (err) {
+        // Write to stderr for debugging, but don't break session start
+        process.stderr.write(`Tier-0 inject failed: ${String(err)}\n`);
+    }
+}
+function detectProjectRoot(cwd) {
+    try {
+        const result = execSync('git rev-parse --show-toplevel', {
+            cwd,
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
+function formatTier0Context(session, totalSessions) {
+    const lines = [];
+    lines.push(`## Eidetic: Last session (${session.date}, branch: ${session.branch ?? 'unknown'})`);
+    // Files modified
+    if (session.filesModified.length > 0) {
+        const shown = session.filesModified.slice(0, MAX_FILES_SHOWN);
+        const remaining = session.filesModified.length - shown.length;
+        const fileList = shown.map((f) => path.basename(f)).join(', ');
+        if (remaining > 0) {
+            lines.push(`- Files modified: ${fileList} (+${remaining} more)`);
+        }
+        else {
+            lines.push(`- Files modified: ${fileList}`);
+        }
+    }
+    // Tasks
+    if (session.tasksCreated.length > 0) {
+        lines.push(`- Tasks: ${session.tasksCreated.join(', ')}`);
+    }
+    // Prompt for more
+    if (totalSessions > 1) {
+        lines.push(`- Run /catchup for full context (${totalSessions} sessions available).`);
+    }
+    else {
+        lines.push('- Run /catchup for full context.');
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+// Export for testing
+export { formatTier0Context, detectProjectRoot };
+main();
+//# sourceMappingURL=tier0-inject.js.map

package/dist/precompact/tier0-writer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Maintain .session-index.json for Tier-0 fast SessionStart context injection.
+ */
+import type { ExtractedSession, SessionIndex } from './types.js';
+/**
+ * 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 declare function updateSessionIndex(notesDir: string, session: ExtractedSession, noteFile: string): void;
+/**
+ * Read the session index for a project.
+ * Returns null if not found or corrupted.
+ */
+export declare function readSessionIndex(notesDir: string): SessionIndex | null;
+//# sourceMappingURL=tier0-writer.d.ts.map

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