linksee-memory 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Synapse Arrows PTE. LTD.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# linksee-memory
+
+> Local-first agent memory MCP. A cross-agent brain for Claude Code, Cursor, and ChatGPT Desktop — with a token-saving file diff cache that nobody else does.
+
+[![npm](https://img.shields.io/npm/v/linksee-memory.svg)](https://www.npmjs.com/package/linksee-memory)
+[![license](https://img.shields.io/npm/l/linksee-memory.svg)](./LICENSE)
+
+## What it does
+
+Most "agent memory" services (Mem0, Letta, Zep) save a flat list of facts. Then the agent looks at "edited file X 30 times" and has no idea why. **linksee-memory keeps the WHY.**
+
+It is a Model Context Protocol (MCP) server that gives any AI agent four superpowers:
+
+| | Mem0 / Letta / Zep | Claude Code auto-memory | linksee-memory |
+|---|---|---|---|
+| Cross-agent | △ (cloud) | ❌ Claude only | ✅ single SQLite file |
+| 6-layer WHY structure | ❌ flat | ❌ flat markdown | ✅ goal / context / emotion / impl / caveat / learning |
+| File diff cache | ❌ | ❌ | ✅ AST-aware, 50-99% token savings on re-reads |
+| Active forgetting | △ | ❌ | ✅ Ebbinghaus curve, caveat layer protected |
+| Local-first / private | ❌ | ✅ | ✅ |
+
+## Three pillars
+
+1. **Token savings** via `read_smart` — sha256 + AST/heading/indent chunking. Re-reads return only diffs. **Measured 86% saved on a typical TS file edit, 99% saved on unchanged re-reads.**
+2. **Cross-agent portability** — single SQLite file at `~/.linksee-memory/memory.db`. Same brain for Claude Code, Cursor, ChatGPT Desktop.
+3. **WHY-first structured memory** — six explicit layers (`goal` / `context` / `emotion` / `implementation` / `caveat` / `learning`). Solves "flat fact memory is useless without goals".
+
+## Install
+
+```bash
+npm install -g linksee-memory
+linksee-memory-import --help   # bundled importer for Claude Code session history
+```
+
+Or use `npx` ad hoc:
+
+```bash
+npx linksee-memory             # starts the MCP server on stdio
+```
+
+The default database lives at `~/.linksee-memory/memory.db`. Override with the `LINKSEE_MEMORY_DIR` environment variable.
+
+## Register with Claude Code
+
+```bash
+claude mcp add -s user linksee -- npx -y linksee-memory
+```
+
+Restart Claude Code. Tools appear as `mcp__linksee__remember`, `mcp__linksee__recall`, `mcp__linksee__recall_file`, `mcp__linksee__read_smart`, `mcp__linksee__forget`, `mcp__linksee__consolidate`.
+
+### Optional: auto-capture every session (Stop hook)
+
+Add to `~/.claude/settings.json` to record every Claude Code session to your local brain automatically:
+
+```json
+{
+  "hooks": {
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          { "type": "command", "command": "npx -y linksee-memory-sync" }
+        ]
+      }
+    ]
+  }
+}
+```
+
+Each turn end takes ~100 ms. Failures are silent (Claude Code never blocks). Logs at `~/.linksee-memory/hook.log`.
+
+## Tools
+
+| Tool | Purpose |
+|---|---|
+| `remember` | Store memory in 1 of 6 layers for an entity |
+| `recall` | FTS5 + heat-score + momentum composite ranking, JP/EN trigram search |
+| `recall_file` | Get the COMPLETE edit history of a file across all sessions, with per-edit user-intent context |
+| `read_smart` | Diff-only file read. Returns full content on first read, ~50 tokens on unchanged re-reads, only changed chunks on real edits |
+| `forget` | Explicit delete OR auto-sweep based on forgettingRisk (importance × heat × age) |
+| `consolidate` | Sleep-mode compression: cluster cold low-importance memories → protected learning-layer summary |
+
+## The 6 memory layers
+
+Each entity (person / company / project / file / concept) can have memories across six layers. The layer encodes meaning, not category:
+
+```json
+{
+  "goal":    { "primary": "...", "sub_tasks": [], "deadline": "..." },
+  "context": { "why_now": "...", "triggering_event": "...", "when": "..." },
+  "emotion": { "temperature": "hot|warm|cold", "user_tone": "..." },
+  "implementation": {
+    "success": [{ "what": "...", "evidence": "..." }],
+    "failure": [{ "what": "...", "why_failed": "..." }]
+  },
+  "caveat":  [{ "rule": "...", "reason": "...", "from_incident": "..." }],
+  "learning":[{ "at": "...", "learned": "...", "prior_belief": "..." }]
+}
+```
+
+- `caveat` memories are auto-protected from forgetting (pain lessons, never lost).
+- `goal` memories bypass decay while the goal is active.
+
+## Architecture
+
+A single SQLite file (`better-sqlite3` + FTS5 trigram tokenizer for JP/EN) contains five layers:
+
+- **Layer 1** — `entities` (facts: people / companies / projects / concepts / files)
+- **Layer 2** — `edges` (associations, graph adjacency)
+- **Layer 3** — `memories` (6-layer structured meanings per entity)
+- **Layer 4** — `events` (time-series log for heat / momentum computation)
+- **Layer 5** — `file_snapshots` + `session_file_edits` (diff cache + conversation↔file linkage)
+
+The conversation↔file linkage is the key. Every file edit captured by the Stop hook is stored alongside the **user message that drove the edit**. So `recall_file("server.ts")` returns "this file was edited 30 times across 3 days, and here are the actual user instructions that motivated each change".
+
+## Why the design choices
+
+- **Local-first** — your conversation history is private. Nothing leaves your machine.
+- **Single file** — `memory.db` is one portable artifact. Backup = file copy.
+- **MCP stdio** — works with every agent that speaks MCP, no plugins per host.
+- **Reuses proven schemas** — `heat_score` / `momentum_score` ported from a production sales-intelligence codebase. Rule-based, no LLM dependency in the hot path.
+
+## Roadmap
+
+- ✅ Core 6 MCP tools (`remember` / `recall` / `recall_file` / `forget` / `consolidate` / `read_smart`)
+- ✅ Stop-hook auto-capture for Claude Code
+- ✅ JP/EN trigram FTS5
+- 🚧 `PreToolUse` hook to auto-intercept `Read` (zero-config token savings)
+- 🚧 Cursor + ChatGPT Desktop adapters
+- 🔮 Vector search via `sqlite-vec` once an embedding backend is chosen (Ollama / API / etc.)
+- 🔮 Optional anonymized telemetry → MCP-quality intelligence layer
+
+## Comparison with Claude Code auto-memory
+
+Claude Code ships a built-in memory feature at `~/.claude/projects/<path>/memory/*.md` — flat markdown notes for user preferences. linksee-memory **complements** it:
+
+- auto-memory = your scrapbook of "remember I prefer X"
+- linksee-memory = structured cross-agent brain with file diff cache and per-edit WHY
+
+Use both.
+
+## License
+
+MIT — Synapse Arrows PTE. LTD.

package/dist/bin/import-sessions.d.ts

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

package/dist/bin/import-sessions.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+// Batch importer: scan Claude Code session JSONL files and populate linksee-memory.
+// Usage:
+//   node dist/bin/import-sessions.js [project_dir ...]
+//   node dist/bin/import-sessions.js --dry-run [project_dir ...]
+//   node dist/bin/import-sessions.js --all                   (scans all ~/.claude/projects/*)
+//   node dist/bin/import-sessions.js --session-file <path>   (single jsonl — used by hook)
+//
+// All inserts are IDEMPOTENT: existing data for a given session_id is wiped before re-insert.
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { openDb, runMigrations } from '../db/migrate.js';
+import { parseSessionFile, projectNameFromCwd } from '../lib/session-parser.js';
+import { extractSession } from '../lib/session-extractor.js';
+const CLAUDE_PROJECTS = join(homedir(), '.claude', 'projects');
+function usage() {
+    console.log(`Usage:
+  node dist/bin/import-sessions.js [--dry-run] [--all | <projectDir> [<projectDir> ...]]
+    --all         : scan every project under ~/.claude/projects/*
+    --dry-run     : parse + extract but do not write to DB
+    projectDir    : absolute path to a project dir (must contain *.jsonl files)`);
+}
+function collectJsonlFiles(projectDir) {
+    try {
+        return readdirSync(projectDir)
+            .filter((f) => f.endsWith('.jsonl'))
+            .map((f) => join(projectDir, f))
+            .filter((p) => {
+            try {
+                return statSync(p).isFile();
+            }
+            catch {
+                return false;
+            }
+        });
+    }
+    catch {
+        return [];
+    }
+}
+// Idempotent wipe: remove all rows tied to a given session_id BEFORE re-inserting.
+// Uses LIKE matching on the JSON-encoded source field for memories/events.
+function wipeSession(db, sessionId) {
+    const sidNeedle = `%"session_id":"${sessionId}"%`;
+    const editDel = db.prepare('DELETE FROM session_file_edits WHERE session_id = ?').run(sessionId);
+    const memDel = db.prepare('DELETE FROM memories WHERE source LIKE ?').run(sidNeedle);
+    const evtDel = db.prepare('DELETE FROM events WHERE payload LIKE ?').run(sidNeedle);
+    return { memories: memDel.changes, edits: editDel.changes, events: evtDel.changes };
+}
+async function main() {
+    const args = process.argv.slice(2);
+    if (args.includes('-h') || args.includes('--help')) {
+        usage();
+        return;
+    }
+    const dryRun = args.includes('--dry-run');
+    const scanAll = args.includes('--all');
+    const sessionFileIdx = args.indexOf('--session-file');
+    const sessionFile = sessionFileIdx >= 0 ? args[sessionFileIdx + 1] : null;
+    const projectArgs = args.filter((a, i) => !a.startsWith('--') && (sessionFileIdx < 0 || i !== sessionFileIdx + 1));
+    // Single-file mode (used by the Stop hook)
+    if (sessionFile) {
+        const db = dryRun ? null : openDb();
+        if (db)
+            runMigrations(db);
+        let parsed;
+        try {
+            parsed = parseSessionFile(sessionFile);
+        }
+        catch (e) {
+            console.error(`[error] cannot parse ${sessionFile}: ${e?.message ?? e}`);
+            process.exit(1);
+        }
+        if (!parsed) {
+            console.log(`[skip] empty or invalid session: ${sessionFile}`);
+            return;
+        }
+        const projectName = projectNameFromCwd(parsed.project_cwd) || 'unknown';
+        const result = extractSession(parsed, projectName);
+        if (dryRun) {
+            console.log(`[dry] session ${result.session_id.slice(0, 8)} (${projectName}): ${result.memories.length} memories, ${result.file_edits.length} file_edits`);
+            return;
+        }
+        if (!db)
+            return;
+        // Idempotent: wipe any prior data for THIS session before re-inserting
+        const wiped = wipeSession(db, result.session_id);
+        // Resolve project entity
+        let projectEntityId;
+        const canonicalKey = parsed.project_cwd;
+        const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
+        if (existing) {
+            projectEntityId = existing.id;
+        }
+        else {
+            const ins = db.prepare('INSERT INTO entities (kind, name, canonical_key) VALUES (?, ?, ?)').run('project', projectName, canonicalKey);
+            projectEntityId = Number(ins.lastInsertRowid);
+        }
+        const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source) VALUES (?, ?, ?, ?, ?)');
+        const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+        const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
+        let inserted = { memories: 0, edits: 0 };
+        db.transaction(() => {
+            const memContentToId = new Map();
+            for (const m of result.memories) {
+                const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, JSON.stringify(m.source));
+                memContentToId.set(m.content, Number(res.lastInsertRowid));
+                inserted.memories++;
+            }
+            for (const fe of result.file_edits) {
+                const memId = fe.memory_content ? memContentToId.get(fe.memory_content) ?? null : null;
+                insEdit.run(fe.session_id, memId, fe.file_path, fe.operation, fe.turn_uuid ?? null, fe.context_snippet, fe.occurred_at);
+                inserted.edits++;
+            }
+            insEvt.run(projectEntityId, 'session_imported', JSON.stringify({
+                session_id: result.session_id,
+                memories: result.memories.length,
+                file_edits: result.file_edits.length,
+                stats: result.stats,
+            }), parsed.started_at || Math.floor(Date.now() / 1000));
+        })();
+        console.log(`[ok] ${result.session_id.slice(0, 8)} (${projectName}): wiped ${wiped.memories}m/${wiped.edits}e/${wiped.events}ev → inserted ${inserted.memories}m/${inserted.edits}e`);
+        db.close();
+        return;
+    }
+    let projectDirs = [];
+    if (scanAll) {
+        try {
+            projectDirs = readdirSync(CLAUDE_PROJECTS)
+                .map((d) => join(CLAUDE_PROJECTS, d))
+                .filter((p) => {
+                try {
+                    return statSync(p).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch (e) {
+            console.error(`Cannot scan ${CLAUDE_PROJECTS}:`, e);
+            process.exit(1);
+        }
+    }
+    else {
+        projectDirs = projectArgs;
+    }
+    if (projectDirs.length === 0) {
+        usage();
+        process.exit(1);
+    }
+    const db = dryRun ? null : openDb();
+    if (db)
+        runMigrations(db);
+    const agg = {
+        projects: 0,
+        sessions_parsed: 0,
+        sessions_skipped: 0,
+        memories_planned: 0,
+        memories_inserted: 0,
+        file_edits_inserted: 0,
+        errors: 0,
+    };
+    for (const projectDir of projectDirs) {
+        const files = collectJsonlFiles(projectDir);
+        if (files.length === 0) {
+            console.log(`[skip] no .jsonl in ${projectDir}`);
+            continue;
+        }
+        agg.projects++;
+        const dirName = projectDir.replace(/\\/g, '/').split('/').filter(Boolean).pop() ?? 'unknown';
+        console.log(`\n=== Project: ${dirName} (${files.length} session files) ===`);
+        let projectEntityId = null;
+        for (const f of files) {
+            let parsed;
+            try {
+                parsed = parseSessionFile(f);
+            }
+            catch (e) {
+                agg.errors++;
+                console.warn(`  [error] ${f}: ${e?.message ?? e}`);
+                continue;
+            }
+            if (!parsed) {
+                agg.sessions_skipped++;
+                continue;
+            }
+            const projectName = projectNameFromCwd(parsed.project_cwd) || dirName;
+            const result = extractSession(parsed, projectName);
+            agg.sessions_parsed++;
+            agg.memories_planned += result.memories.length;
+            if (dryRun) {
+                console.log(`  [dry] session ${result.session_id.slice(0, 8)} (${projectName}): ${result.memories.length} memories, ${result.file_edits.length} file_edits, stats=${JSON.stringify(result.stats)}`);
+                continue;
+            }
+            if (!db)
+                continue;
+            // Ensure entity exists (once per project)
+            if (projectEntityId === null) {
+                const canonicalKey = parsed.project_cwd;
+                const existing = db.prepare('SELECT id FROM entities WHERE canonical_key = ? OR (kind = ? AND LOWER(name) = LOWER(?))').get(canonicalKey, 'project', projectName);
+                if (existing) {
+                    projectEntityId = existing.id;
+                }
+                else {
+                    const ins = db.prepare('INSERT INTO entities (kind, name, canonical_key) VALUES (?, ?, ?)').run('project', projectName, canonicalKey);
+                    projectEntityId = Number(ins.lastInsertRowid);
+                }
+            }
+            // Idempotent: wipe any prior data for THIS session before re-inserting (Phase B)
+            wipeSession(db, result.session_id);
+            // Insert memories + file_edits in a single transaction per session
+            const insMem = db.prepare('INSERT INTO memories (entity_id, layer, content, importance, source) VALUES (?, ?, ?, ?, ?)');
+            const insEdit = db.prepare(`INSERT INTO session_file_edits (session_id, memory_id, file_path, operation, turn_uuid, context_snippet, occurred_at) VALUES (?, ?, ?, ?, ?, ?, ?)`);
+            const insEvt = db.prepare('INSERT INTO events (entity_id, kind, payload, occurred_at) VALUES (?, ?, ?, ?)');
+            const tx = db.transaction(() => {
+                const memContentToId = new Map();
+                for (const m of result.memories) {
+                    const srcJson = JSON.stringify(m.source);
+                    const res = insMem.run(projectEntityId, m.layer, m.content, m.importance, srcJson);
+                    memContentToId.set(m.content, Number(res.lastInsertRowid));
+                    agg.memories_inserted++;
+                }
+                for (const fe of result.file_edits) {
+                    const memId = fe.memory_content ? memContentToId.get(fe.memory_content) ?? null : null;
+                    insEdit.run(fe.session_id, memId, fe.file_path, fe.operation, fe.turn_uuid ?? null, fe.context_snippet, fe.occurred_at);
+                    agg.file_edits_inserted++;
+                }
+                insEvt.run(projectEntityId, 'session_imported', JSON.stringify({
+                    session_id: result.session_id,
+                    memories: result.memories.length,
+                    file_edits: result.file_edits.length,
+                    stats: result.stats,
+                }), parsed.started_at || Math.floor(Date.now() / 1000));
+            });
+            try {
+                tx();
+            }
+            catch (e) {
+                agg.errors++;
+                console.warn(`  [tx error] ${f}: ${e?.message ?? e}`);
+            }
+        }
+    }
+    console.log(`\n=== Summary ===`);
+    console.log(`  projects:           ${agg.projects}`);
+    console.log(`  sessions parsed:    ${agg.sessions_parsed}`);
+    console.log(`  sessions skipped:   ${agg.sessions_skipped}`);
+    console.log(`  memories planned:   ${agg.memories_planned}`);
+    console.log(`  memories inserted:  ${agg.memories_inserted}${dryRun ? ' (DRY RUN — nothing written)' : ''}`);
+    console.log(`  file_edits inserted:${agg.file_edits_inserted}${dryRun ? ' (DRY RUN)' : ''}`);
+    console.log(`  errors:             ${agg.errors}`);
+    if (db)
+        db.close();
+}
+main().catch((e) => { console.error(e); process.exit(1); });
+//# sourceMappingURL=import-sessions.js.map

package/dist/bin/sync-session.d.ts

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

package/dist/bin/sync-session.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+// Stop-hook entrypoint for Claude Code.
+//
+// Claude Code invokes this script when an assistant turn finishes (Stop event).
+// It receives JSON on stdin like: { session_id, transcript_path, cwd, ... }
+// We use transcript_path (the active jsonl) and feed it to the importer.
+//
+// CONTRACT:
+//   - MUST exit 0 on success OR failure — never block Claude Code
+//   - MUST be silent on stdout (Claude does not need feedback)
+//   - All errors logged to ~/.linksee-memory/hook.log
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, appendFileSync, existsSync, statSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+const LOG_DIR = process.env.LINKSEE_MEMORY_DIR ?? join(homedir(), '.linksee-memory');
+const LOG_FILE = join(LOG_DIR, 'hook.log');
+const LOG_MAX_BYTES = 1024 * 1024; // 1 MB → rotate
+function log(msg) {
+    try {
+        mkdirSync(LOG_DIR, { recursive: true });
+        // Rotate if too big
+        if (existsSync(LOG_FILE) && statSync(LOG_FILE).size > LOG_MAX_BYTES) {
+            try {
+                renameSync(LOG_FILE, LOG_FILE + '.1');
+            }
+            catch { /* ignore */ }
+        }
+        appendFileSync(LOG_FILE, `[${new Date().toISOString()}] ${msg}\n`);
+    }
+    catch { /* never throw from log */ }
+}
+async function readStdin() {
+    return new Promise((resolve) => {
+        let data = '';
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => { data += chunk; });
+        process.stdin.on('end', () => resolve(data));
+        // If no stdin within 500ms (e.g. invoked manually), give up — Stop hook always provides JSON
+        setTimeout(() => resolve(data), 500);
+    });
+}
+async function main() {
+    const startedAt = Date.now();
+    let payload = {};
+    try {
+        const raw = await readStdin();
+        if (raw.trim())
+            payload = JSON.parse(raw);
+    }
+    catch (e) {
+        log(`stdin parse error: ${e?.message ?? e}`);
+        process.exit(0);
+    }
+    const transcriptPath = payload.transcript_path;
+    const sessionId = payload.session_id;
+    const cwd = payload.cwd;
+    const stopHookActive = !!payload.stop_hook_active;
+    if (!transcriptPath) {
+        log(`no transcript_path in payload (session=${sessionId ?? '?'}, keys=${Object.keys(payload).join(',')})`);
+        process.exit(0);
+    }
+    if (stopHookActive) {
+        // We're in a recursive Stop chain — do nothing
+        log(`stop_hook_active=true, skipping (session=${sessionId})`);
+        process.exit(0);
+    }
+    // Find the importer script — it lives next to us in dist/bin/
+    const __filename = fileURLToPath(import.meta.url);
+    const importerPath = join(dirname(__filename), 'import-sessions.js');
+    if (!existsSync(transcriptPath)) {
+        log(`transcript missing: ${transcriptPath}`);
+        process.exit(0);
+    }
+    const r = spawnSync(process.execPath, [importerPath, '--session-file', transcriptPath], {
+        encoding: 'utf8',
+        timeout: 30000,
+    });
+    const elapsed = Date.now() - startedAt;
+    if (r.error) {
+        log(`importer spawn error (session=${sessionId}, ${elapsed}ms): ${r.error.message}`);
+    }
+    else if (r.status !== 0) {
+        log(`importer exited ${r.status} (session=${sessionId}, ${elapsed}ms): ${(r.stderr || '').slice(0, 500)}`);
+    }
+    else {
+        const out = (r.stdout || '').trim().split('\n').slice(-1)[0] || '';
+        log(`ok (session=${sessionId}, cwd=${cwd}, ${elapsed}ms): ${out}`);
+    }
+    process.exit(0);
+}
+main().catch((e) => {
+    log(`unhandled: ${e?.message ?? e}`);
+    process.exit(0);
+});
+//# sourceMappingURL=sync-session.js.map

package/dist/db/migrate.d.ts

@@ -0,0 +1,4 @@
+import Database from 'better-sqlite3';
+export declare function getDbPath(): string;
+export declare function openDb(): Database.Database;
+export declare function runMigrations(db: Database.Database): void;

package/dist/db/migrate.js

@@ -0,0 +1,48 @@
+import Database from 'better-sqlite3';
+import { readFileSync } from 'node:fs';
+import { mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+const DEFAULT_DB_DIR = process.env.LINKSEE_MEMORY_DIR ?? join(homedir(), '.linksee-memory');
+const DB_PATH = join(DEFAULT_DB_DIR, 'memory.db');
+export function getDbPath() {
+    return DB_PATH;
+}
+export function openDb() {
+    mkdirSync(DEFAULT_DB_DIR, { recursive: true });
+    const db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    return db;
+}
+export function runMigrations(db) {
+    const __filename = fileURLToPath(import.meta.url);
+    const schemaPath = join(dirname(__filename), 'schema.sql');
+    const sql = readFileSync(schemaPath, 'utf8');
+    // v3 → v4: rebuild memories_fts with trigram tokenizer for JP/CJK support
+    const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    if (versionRow && Number(versionRow.value) < 4) {
+        // Drop old triggers + table; CREATE statements below will recreate them
+        db.exec(`
+      DROP TRIGGER IF EXISTS trg_memories_fts_ai;
+      DROP TRIGGER IF EXISTS trg_memories_fts_ad;
+      DROP TRIGGER IF EXISTS trg_memories_fts_au;
+      DROP TABLE IF EXISTS memories_fts;
+    `);
+    }
+    db.exec(sql);
+    // After v4 schema is applied, repopulate FTS index from existing memories
+    if (versionRow && Number(versionRow.value) < 4) {
+        db.exec(`INSERT INTO memories_fts(rowid, content) SELECT id, content FROM memories;`);
+    }
+}
+// CLI entrypoint
+if (import.meta.url === `file://${process.argv[1]}` || process.argv[1]?.endsWith('migrate.ts') || process.argv[1]?.endsWith('migrate.js')) {
+    const db = openDb();
+    runMigrations(db);
+    const row = db.prepare("SELECT value FROM meta WHERE key = 'schema_version'").get();
+    console.log(`[linksee-memory] migrated ${DB_PATH} (schema v${row?.value ?? '?'})`);
+    db.close();
+}
+//# sourceMappingURL=migrate.js.map