linksee-memory 0.0.1

package/dist/lib/session-parser.js

@@ -0,0 +1,303 @@
+// Parse a Claude Code session JSONL into a structured session model.
+// Input:  path to a *.jsonl file under ~/.claude/projects/<project>/
+// Output: normalized session with user messages, tool calls, file ops.
+import { readFileSync } from 'node:fs';
+function extractTextFromContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (typeof block === 'string') {
+            parts.push(block);
+            continue;
+        }
+        if (block?.type === 'text' && typeof block.text === 'string')
+            parts.push(block.text);
+    }
+    return parts.join('\n');
+}
+function extractToolCalls(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const calls = [];
+    for (const block of content) {
+        if (block?.type === 'tool_use') {
+            calls.push({ name: block.name, input: block.input, tool_use_id: block.id });
+        }
+    }
+    return calls.length > 0 ? calls : undefined;
+}
+function extractToolResults(content) {
+    if (!Array.isArray(content))
+        return undefined;
+    const results = [];
+    for (const block of content) {
+        if (block?.type === 'tool_result') {
+            const rawOutput = typeof block.content === 'string'
+                ? block.content
+                : Array.isArray(block.content)
+                    ? block.content.map((c) => (typeof c === 'string' ? c : c?.text ?? '')).join('\n')
+                    : '';
+            results.push({
+                tool_use_id: block.tool_use_id,
+                is_error: !!block.is_error,
+                output_preview: rawOutput.slice(0, 300),
+            });
+        }
+    }
+    return results.length > 0 ? results : undefined;
+}
+// Detect noise messages we should skip for "meaningful user text"
+export function isMetaOrNoise(text) {
+    if (!text)
+        return true;
+    const t = text.trim();
+    if (t.length === 0)
+        return true;
+    if (t.startsWith('<local-command-caveat>'))
+        return true;
+    if (t.startsWith('<system-reminder>'))
+        return true;
+    if (t.startsWith('<command-message>'))
+        return true;
+    if (t.startsWith('<command-name>'))
+        return true;
+    if (t.startsWith('<scheduled-task'))
+        return true; // cron-triggered, no real user intent
+    if (t.startsWith('<automated-'))
+        return true; // other automation wrappers
+    if (t.startsWith('<bash-') || t.startsWith('<ide-'))
+        return true;
+    if (t.startsWith('<task-notification>'))
+        return true; // background task completion notices
+    if (t.startsWith('<local-command-stdout>'))
+        return true; // shell command output capture
+    if (t.startsWith('<local-command-stderr>'))
+        return true;
+    if (t.startsWith('<command-stdout>') || t.startsWith('<command-stderr>'))
+        return true;
+    // Claude Code's auto-injected context-continuation summaries — these are NOT user warnings
+    if (t.startsWith('This session is being continued from a previous conversation'))
+        return true;
+    if (t.includes('Caveat: The messages below were generated by the user while running local commands'))
+        return true;
+    if (t.match(/^\/(compact|clear|exit|help|quit|login|logout|mcp)(\s|$)/))
+        return true;
+    // Reminders that are pure tool hints
+    if (t.includes('The TodoWrite tool hasn\'t been used recently'))
+        return true;
+    if (t.includes('PostToolUse:Write hook'))
+        return true;
+    return false;
+}
+// Detect content that's clearly a paste-back of assistant output / external system text,
+// not the user's own thought. Stricter than isMetaOrNoise — used for caveat/learning extraction
+// where we want only authentic user reflection, not pasted material.
+export function isPastedExternalContent(text) {
+    if (!text)
+        return false;
+    const t = text.trim();
+    // Assistant-style bullet/result markers at start
+    if (/^[●○◯◆■▶►]\s/.test(t))
+        return true;
+    if (/^Attempt #\d+ failed/i.test(t))
+        return true;
+    // Box-drawing characters (table dumps from CLI)
+    if (/[┌┐└┘├┤┬┴┼━─│]/.test(t.slice(0, 200)) && t.length > 100)
+        return true;
+    // System prompts being pasted in
+    if (/^You are (a|an|the) [A-Z]\w+/.test(t))
+        return true;
+    // Marketing emails / docs
+    if (/^(Welcome to|Hey there,|Hi there,|Dear)\s/i.test(t))
+        return true;
+    if (/^(Add|Enable|Disable|Configure) (organization|2FA|members|users)/i.test(t))
+        return true;
+    // Service status pages / logs
+    if (/^(Service offline|Failed|Success|Deployment|Build|Logs?|Error:)/.test(t.slice(0, 80)))
+        return true;
+    // Extractor-internal duplicate (was generating same caveat per session)
+    if (t === 'Review errors before repeating this workflow.')
+        return true;
+    // Pasted from forums/Reddit/etc. — block when "your post" / "Rule N:" patterns dominate
+    if (/Rule \d+:/.test(t.slice(0, 200)) && /your (post|submission)/i.test(t))
+        return true;
+    // Stack-trace like
+    if (/^\s*at\s+\w+.*\(.*:\d+:\d+\)/m.test(t.slice(0, 500)))
+        return true;
+    return false;
+}
+// Detect if a session is entirely/mostly automated (scheduled task, CI, etc.)
+export function isAutomatedSession(firstUserText) {
+    return /^\s*<scheduled-task|^\s*<automated-/.test(firstUserText);
+}
+export function parseSessionFile(jsonlPath) {
+    const raw = readFileSync(jsonlPath, 'utf8');
+    const lines = raw.split('\n').filter(Boolean);
+    if (lines.length === 0)
+        return null;
+    let session_id = '';
+    let project_cwd = '';
+    let git_branch;
+    let minTs = Number.MAX_SAFE_INTEGER;
+    let maxTs = 0;
+    const turns = [];
+    const file_ops = [];
+    let turn_count_user = 0;
+    let turn_count_assistant = 0;
+    let errors_count = 0;
+    // Track last meaningful user text so we can attach it as context to file edits
+    let lastUserText = '';
+    // First pass: build turns
+    // Also keep a map of tool_use_id → (turn_uuid, name, input) so we can join results
+    const toolUseIndex = new Map();
+    for (const line of lines) {
+        let event;
+        try {
+            event = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (!session_id && event.sessionId)
+            session_id = event.sessionId;
+        if (!project_cwd && event.cwd)
+            project_cwd = event.cwd;
+        if (!git_branch && event.gitBranch)
+            git_branch = event.gitBranch;
+        const ts = event.timestamp ? Math.floor(new Date(event.timestamp).getTime() / 1000) : 0;
+        if (ts > 0) {
+            if (ts < minTs)
+                minTs = ts;
+            if (ts > maxTs)
+                maxTs = ts;
+        }
+        if (event.type !== 'user' && event.type !== 'assistant')
+            continue;
+        if (event.isMeta || event.isSidechain)
+            continue;
+        const message = event.message;
+        if (!message)
+            continue;
+        const role = message.role;
+        if (role !== 'user' && role !== 'assistant')
+            continue;
+        const text = extractTextFromContent(message.content);
+        const tool_calls = role === 'assistant' ? extractToolCalls(message.content) : undefined;
+        const tool_results = role === 'user' ? extractToolResults(message.content) : undefined;
+        if (role === 'user')
+            turn_count_user++;
+        else
+            turn_count_assistant++;
+        if (tool_results) {
+            for (const tr of tool_results)
+                if (tr.is_error)
+                    errors_count++;
+        }
+        const turn = {
+            uuid: event.uuid ?? '',
+            role,
+            timestamp: ts,
+            text,
+            tool_calls,
+            tool_results,
+        };
+        turns.push(turn);
+        // Track latest user intent for "why" attribution
+        if (role === 'user' && !isMetaOrNoise(text) && !tool_results) {
+            lastUserText = text.trim();
+        }
+        // Capture file operations from assistant tool calls
+        if (role === 'assistant' && tool_calls) {
+            for (const call of tool_calls) {
+                toolUseIndex.set(call.tool_use_id, {
+                    turn_uuid: turn.uuid,
+                    name: call.name,
+                    input: call.input,
+                    timestamp: ts,
+                });
+                const op = classifyToolOp(call.name);
+                if (op && call.input?.file_path) {
+                    file_ops.push({
+                        operation: op,
+                        path: call.input.file_path,
+                        turn_uuid: turn.uuid,
+                        timestamp: ts,
+                        preceding_user_text: lastUserText.slice(0, 600),
+                        tool_input_preview: summarizeToolInput(call.name, call.input),
+                    });
+                }
+                else if (call.name === 'Bash' && typeof call.input?.command === 'string') {
+                    // capture git/build commands as 'bash' ops — no file_path but still useful
+                    const cmd = call.input.command;
+                    // extract file-like paths from the command if any, else store whole command
+                    file_ops.push({
+                        operation: 'bash',
+                        path: extractFirstPathFromCommand(cmd) ?? '(shell)',
+                        turn_uuid: turn.uuid,
+                        timestamp: ts,
+                        preceding_user_text: lastUserText.slice(0, 600),
+                        tool_input_preview: cmd.slice(0, 200),
+                    });
+                }
+            }
+        }
+    }
+    if (!session_id || turns.length === 0)
+        return null;
+    return {
+        session_id,
+        project_cwd: project_cwd || '(unknown)',
+        started_at: minTs === Number.MAX_SAFE_INTEGER ? 0 : minTs,
+        ended_at: maxTs,
+        git_branch,
+        turns,
+        file_ops,
+        turn_count_user,
+        turn_count_assistant,
+        errors_count,
+    };
+}
+function classifyToolOp(name) {
+    if (name === 'Read')
+        return 'read';
+    if (name === 'Edit' || name === 'MultiEdit' || name === 'NotebookEdit')
+        return 'edit';
+    if (name === 'Write')
+        return 'write';
+    return null;
+}
+function summarizeToolInput(name, input) {
+    try {
+        if (name === 'Edit') {
+            const old_s = (input.old_string ?? '').toString();
+            const new_s = (input.new_string ?? '').toString();
+            return `OLD(${old_s.length}ch): ${old_s.slice(0, 80)}... NEW(${new_s.length}ch): ${new_s.slice(0, 80)}...`;
+        }
+        if (name === 'Write') {
+            const c = (input.content ?? '').toString();
+            return `WRITE(${c.length}ch): ${c.slice(0, 120)}...`;
+        }
+        if (name === 'Read') {
+            return `READ ${input.file_path ?? ''}${input.offset ? ` +${input.offset}` : ''}`;
+        }
+        return JSON.stringify(input).slice(0, 200);
+    }
+    catch {
+        return '';
+    }
+}
+function extractFirstPathFromCommand(cmd) {
+    // heuristic: look for something that looks like a path in the command
+    const m = cmd.match(/[A-Za-z]:[\\/][\w\-\.\\/]+|(?<![A-Za-z0-9])\.?\/?[\w\-\.]+\/[\w\-\.\/]+/);
+    return m ? m[0] : null;
+}
+// Utility: project_cwd → project name (last path segment)
+export function projectNameFromCwd(cwd) {
+    if (!cwd)
+        return 'unknown';
+    return cwd.replace(/\\/g, '/').replace(/\/$/, '').split('/').filter(Boolean).pop() ?? 'unknown';
+}
+//# sourceMappingURL=session-parser.js.map

package/dist/mcp/read-smart.d.ts

@@ -0,0 +1,5 @@
+import type Database from 'better-sqlite3';
+export declare function handleReadSmart(db: Database.Database, args: {
+    path: string;
+    force?: boolean;
+}): string;

package/dist/mcp/read-smart.js

@@ -0,0 +1,132 @@
+// read_smart handler: the flagship token-saving feature.
+// Returns full content on first read, "unchanged" metadata on re-read (~50 tokens),
+// or only the changed chunks + unchanged summary on real modifications.
+import { readFileSync, statSync } from 'node:fs';
+import { chunkFile, hashFile } from '../lib/file-chunker.js';
+// Rough estimate: 1 token ≈ 4 chars for English+code, closer to 2-3 for JP.
+// Use 0.3 as a blended average.
+const TOKENS_PER_CHAR = 0.3;
+function estimateTokens(content) {
+    return Math.ceil(content.length * TOKENS_PER_CHAR);
+}
+function toMeta(c) {
+    return { id: c.id, kind: c.kind, start_line: c.start_line, end_line: c.end_line, hash: c.hash };
+}
+export function handleReadSmart(db, args) {
+    const { path, force = false } = args;
+    let stat;
+    try {
+        stat = statSync(path);
+    }
+    catch (e) {
+        return JSON.stringify({ ok: false, error: `File not found: ${path}` });
+    }
+    const mtime = Math.floor(stat.mtimeMs / 1000);
+    const size = stat.size;
+    const prior = db.prepare('SELECT * FROM file_snapshots WHERE path = ?').get(path);
+    // --- CASE A: first read or force ---
+    if (!prior || force) {
+        const content = readFileSync(path, 'utf8');
+        const fileHash = hashFile(content);
+        const chunks = chunkFile(path, content);
+        const chunkMeta = chunks.map(toMeta);
+        db.prepare(`INSERT INTO file_snapshots (path, content_hash, mtime, size_bytes, chunks, last_read_at, read_count)
+       VALUES (?, ?, ?, ?, ?, unixepoch(), 1)
+       ON CONFLICT(path) DO UPDATE SET
+         content_hash = excluded.content_hash,
+         mtime = excluded.mtime,
+         size_bytes = excluded.size_bytes,
+         chunks = excluded.chunks,
+         last_read_at = unixepoch(),
+         read_count = read_count + 1`).run(path, fileHash, mtime, size, JSON.stringify(chunkMeta));
+        return JSON.stringify({
+            ok: true,
+            status: force ? 'forced_full' : 'first_read',
+            path,
+            content,
+            chunks: chunkMeta,
+            bytes: size,
+            tokens_approx: estimateTokens(content),
+            tokens_saved: 0,
+        });
+    }
+    // --- CASE B: mtime unchanged → content guaranteed unchanged (fast path) ---
+    if (prior.mtime === mtime) {
+        db.prepare('UPDATE file_snapshots SET last_read_at = unixepoch(), read_count = read_count + 1 WHERE path = ?').run(path);
+        const storedChunks = JSON.parse(prior.chunks);
+        const factRows = db.prepare('SELECT fact, layer, chunk_hash FROM file_facts WHERE file_path = ?').all(path);
+        // Token savings = what a full read would have cost
+        const savedTokens = Math.round(size * TOKENS_PER_CHAR);
+        return JSON.stringify({
+            ok: true,
+            status: 'unchanged',
+            path,
+            last_read_at: new Date(prior.last_read_at * 1000).toISOString(),
+            chunk_count: storedChunks.length,
+            chunks: storedChunks,
+            file_facts: factRows,
+            tokens_saved: savedTokens,
+            note: 'File unchanged since last read. Call with force:true if full content is needed.',
+        });
+    }
+    // --- CASE C: mtime changed → compute hash, maybe false alarm ---
+    const content = readFileSync(path, 'utf8');
+    const fileHash = hashFile(content);
+    if (fileHash === prior.content_hash) {
+        db.prepare('UPDATE file_snapshots SET mtime = ?, last_read_at = unixepoch(), read_count = read_count + 1 WHERE path = ?').run(mtime, path);
+        return JSON.stringify({
+            ok: true,
+            status: 'unchanged_content',
+            path,
+            note: 'mtime changed but sha256 identical (file was touched but not modified).',
+            tokens_saved: Math.round(size * TOKENS_PER_CHAR),
+        });
+    }
+    // --- CASE D: real diff ---
+    const newChunks = chunkFile(path, content);
+    const oldChunks = JSON.parse(prior.chunks);
+    const oldById = new Map(oldChunks.map((c) => [c.id, c]));
+    const changedChunks = [];
+    const unchangedChunks = [];
+    const seenIds = new Set();
+    for (const c of newChunks) {
+        seenIds.add(c.id);
+        const prev = oldById.get(c.id);
+        if (!prev) {
+            changedChunks.push({ id: c.id, kind: c.kind, status: 'added', start_line: c.start_line, end_line: c.end_line, content: c.content });
+        }
+        else if (prev.hash !== c.hash) {
+            changedChunks.push({ id: c.id, kind: c.kind, status: 'modified', start_line: c.start_line, end_line: c.end_line, content: c.content });
+        }
+        else {
+            unchangedChunks.push({ id: c.id, kind: c.kind, start_line: c.start_line, end_line: c.end_line, hash: c.hash });
+        }
+    }
+    const removedChunks = oldChunks
+        .filter((c) => !seenIds.has(c.id))
+        .map((c) => ({ id: c.id, kind: c.kind, prev_lines: `${c.start_line}-${c.end_line}` }));
+    const newChunkMeta = newChunks.map(toMeta);
+    db.prepare(`UPDATE file_snapshots SET content_hash = ?, mtime = ?, size_bytes = ?, chunks = ?, last_read_at = unixepoch(), read_count = read_count + 1 WHERE path = ?`).run(fileHash, mtime, size, JSON.stringify(newChunkMeta), path);
+    const fullTokens = estimateTokens(content);
+    const returnedTokens = changedChunks.reduce((s, c) => s + estimateTokens(c.content), 0) + 80; // ~80 for the envelope
+    const savedTokens = Math.max(0, fullTokens - returnedTokens);
+    const pctSaved = fullTokens > 0 ? Math.round((savedTokens / fullTokens) * 100) : 0;
+    return JSON.stringify({
+        ok: true,
+        status: 'modified',
+        path,
+        changed_chunks: changedChunks,
+        unchanged_chunks: unchangedChunks,
+        removed_chunks: removedChunks,
+        summary: {
+            changed: changedChunks.length,
+            unchanged: unchangedChunks.length,
+            removed: removedChunks.length,
+            tokens_full: fullTokens,
+            tokens_returned: returnedTokens,
+            tokens_saved: savedTokens,
+            pct_saved: pctSaved,
+        },
+    });
+}
+//# sourceMappingURL=read-smart.js.map

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};