linksee-memory 0.12.0 → 0.13.0

package/dist/bin/setup.js

@@ -2,15 +2,17 @@
 // setup: One-command setup for Linksee Memory — the "Use Linksee" installer.
 //
 // Usage:
-//   npx linksee-memory setup          (interactive setup)
-//   npx linksee-memory setup --yes    (accept all defaults, no prompts)
+//   npx linksee-memory setup             (interactive setup)
+//   npx linksee-memory setup --yes       (accept all defaults, no prompts)
 //   npx linksee-memory setup --dry-run
+//   npx linksee-memory setup --no-guard  (skip the re-injection guard)
+//   npx linksee-memory setup --project-guard  (wire the guard to THIS repo only)
 //
 // Does four things:
 //   1. Registers the MCP server with Claude Code
 //   2. Installs the SKILL.md (agent trigger phrases)
 //   3. Configures the Stop hook (auto-capture sessions) — user-global
-//   4. Offers to wire the re-injection guard into THIS project's .claude/settings.json
+//   4. Wires the re-injection guard into ~/.claude/settings.json (every project)
 //
 // After setup, every Claude Code session:
 //   - Auto-captures decisions, learnings, caveats to local memory
@@ -21,15 +23,30 @@
 // Why: Competing memory tools (claude-mem, etc.) are one-install-and-done.
 // Our MCP approach gives more precision, but the setup was 3 manual steps.
 // This command eliminates that friction entirely.
+//
+// Why the guard is user-global (2026-09-07): memory is global — one SQLite file holding the
+// anchors for every repo — but the guard used to be wired per project, opt-in. So the anchors
+// existed everywhere and were enforced nowhere. The author's own machine had 42 active anchors
+// and no PreToolUse hook in any project; the one layer no competing tool has was switched off
+// where it was written. A founder running twenty repos should not run setup twenty times.
+//
+// Safe by construction: the hook is fail-open, and it can only DENY when an anchor was
+// explicitly hardened via resolve_drift(action:'harden'). Anything else re-injects text.
+// Anchors with `affects` globs only fire on matching paths; unscoped ones fire on their own
+// detect_terms / violation_signal, so cross-repo noise is bounded by what you declared.
 import { spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, copyFileSync } from 'node:fs';
 import { join, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
+import { guardFullyWired, wireGuard, syncWiredFor } from '../lib/guard-wiring.js';
 const args = process.argv.slice(2);
 const dryRun = args.includes('--dry-run');
 const autoYes = args.includes('--yes') || args.includes('-y');
+const noGuard = args.includes('--no-guard');
+// Opt back into the old behaviour: wire the guard to this repo instead of every repo.
+const projectGuard = args.includes('--project-guard');
 const showHelp = args.includes('--help') || args.includes('-h');
 if (showHelp) {
     console.log(`linksee-memory-setup — One-command setup for Linksee Memory
@@ -62,11 +79,9 @@ const MCP_COMMAND = `claude mcp add -s user ${SERVER_NAME} -- npx -y linksee-mem
 // Subcommand form (npx -y linksee-memory <sub>) so the hooks resolve for a cold user —
 // npx can resolve the package name, but not sibling bin names like linksee-memory-sync.
 const HOOK_COMMAND = 'npx -y linksee-memory sync';
-// Re-injection guard — wired into the PROJECT (not user-global) settings, because it enforces THIS
-// project's accepted decisions. Mirrors the dogfood wiring's ${CLAUDE_PROJECT_DIR}/dist/bin path, but
-// points at the globally-installed `linksee-memory-guard` bin so it ships without a build step. Shell
-// form (resolved at run time) survives npx-cache eviction; a baked dist path would not.
-const GUARD_COMMAND = 'npx -y linksee-memory guard';
+// Re-injection guard: command + merge rules live in lib/guard-wiring.ts (shared with the tests).
+// It points at the globally-installed bin rather than a dist path, so it ships without a build
+// step, and the shell form is resolved at run time so it survives npx-cache eviction.
 const PROJECT_DIR = process.cwd();
 const PROJECT_CLAUDE_DIR = join(PROJECT_DIR, '.claude');
 const PROJECT_SETTINGS_PATH = join(PROJECT_CLAUDE_DIR, 'settings.json');
@@ -195,7 +210,9 @@ if (existsSync(SETTINGS_PATH)) {
 }
 // Check if hook already exists
 const stopHooks = settings?.hooks?.Stop ?? [];
-const alreadyHooked = stopHooks.some((entry) => entry.hooks?.some((h) => h.command?.includes('linksee-memory-sync')));
+// Recognise every shape the sync hook has been wired in (npx subcommand, global bin, dist
+// path, exec form) — a narrower probe appended a second copy, see lib/guard-wiring.ts.
+const alreadyHooked = syncWiredFor(settings, 'Stop');
 if (alreadyHooked) {
     console.log(`  ${SKIP} Stop hook already configured`);
 }
@@ -217,17 +234,7 @@ else {
     console.log(`  ${CHECK} Stop hook added → ${SETTINGS_PATH}`);
 }
 console.log('');
-const GUARD_EVENTS = ['SessionStart', 'PreToolUse'];
-const GUARD_HOOKS = {
-    // matchers + timeouts mirror the dogfood .claude/settings.json
-    SessionStart: { matcher: 'startup|resume|compact', hooks: [{ type: 'command', command: GUARD_COMMAND, timeout: 15 }] },
-    PreToolUse: { matcher: 'Edit|Write|Bash', hooks: [{ type: 'command', command: GUARD_COMMAND, timeout: 8 }] },
-};
-// Idempotency probe: is OUR guard already wired for this event? (Match by bin name so a manually-added
-// or previously-installed entry isn't duplicated, and other people's hooks are never touched.)
-function guardWiredFor(s, ev) {
-    return (s.hooks?.[ev] ?? []).some((entry) => entry?.hooks?.some((h) => typeof h?.command === 'string' && h.command.includes('linksee-memory-guard')));
-}
+// ── Step 4: Wire the re-injection guard (user-global by default) ─────────
 function askYesNo(question, defaultYes = true) {
     return new Promise((resolve) => {
         const rl = createInterface({ input: process.stdin, output: process.stdout });
@@ -241,54 +248,60 @@ function askYesNo(question, defaultYes = true) {
     });
 }
 async function configureGuard() {
-    console.log(`${BOLD}[4/4]${RESET} Configuring re-injection guard (this project)...`);
-    let project = {};
-    if (existsSync(PROJECT_SETTINGS_PATH)) {
+    // Default target is the user-global settings — the same scope the MCP server is registered
+    // at, and the same scope the memory itself lives at. --project-guard keeps the old per-repo
+    // behaviour for people who want the guard in one repo only.
+    const targetPath = projectGuard ? PROJECT_SETTINGS_PATH : SETTINGS_PATH;
+    const targetDir = projectGuard ? PROJECT_CLAUDE_DIR : CLAUDE_DIR;
+    const scopeLabel = projectGuard ? 'this project' : 'all projects';
+    console.log(`${BOLD}[4/4]${RESET} Configuring re-injection guard (${scopeLabel})...`);
+    if (noGuard) {
+        console.log(`  ${SKIP} Skipped (--no-guard). Enable later: npx -y linksee-memory setup`);
+        return false;
+    }
+    let settings = {};
+    if (existsSync(targetPath)) {
         try {
             // Strip a leading BOM (U+FEFF) — Windows editors (Notepad) emit UTF-8+BOM, which JSON.parse rejects.
-            const raw = readFileSync(PROJECT_SETTINGS_PATH, 'utf8');
-            project = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw);
+            const raw = readFileSync(targetPath, 'utf8');
+            settings = JSON.parse(raw.charCodeAt(0) === 0xfeff ? raw.slice(1) : raw);
         }
         catch {
             // Never clobber a file we can't parse — the user may have hand-authored it.
-            console.log(`  ${FAIL} Could not parse ${PROJECT_SETTINGS_PATH} — left untouched`);
+            console.log(`  ${FAIL} Could not parse ${targetPath} — left untouched`);
             console.log(`  ${DIM}Add the guard block by hand (see README → Re-injection Guard).${RESET}`);
             return false;
         }
     }
-    if (GUARD_EVENTS.every((ev) => guardWiredFor(project, ev))) {
-        console.log(`  ${SKIP} Guard already wired in ${PROJECT_SETTINGS_PATH}`);
+    if (guardFullyWired(settings)) {
+        console.log(`  ${SKIP} Guard already wired in ${targetPath}`);
         return true;
     }
     if (dryRun) {
-        console.log(`  ${DIM}[dry-run] Would merge SessionStart + PreToolUse guard hooks into ${PROJECT_SETTINGS_PATH}${RESET}`);
+        console.log(`  ${DIM}[dry-run] Would merge SessionStart + PreToolUse guard hooks into ${targetPath}${RESET}`);
         return false;
     }
-    // "Offer" — opt-in, because the guard can deny tool calls on a 'hard' contradiction.
-    if (!autoYes) {
-        if (!process.stdin.isTTY) {
-            console.log(`  ${SKIP} Skipped (non-interactive shell). Re-run with --yes, or paste the README block.`);
-            return false;
-        }
+    // Ask when there is someone to ask. A non-interactive run used to skip silently, which is
+    // how the guard ended up installed nowhere — setup's job is to configure, so it configures
+    // and says so loudly instead.
+    if (!autoYes && process.stdin.isTTY) {
         console.log(`  ${DIM}Re-injects your accepted decisions before Edit/Write/Bash and on session start.`);
-        console.log(`  Fail-open — only an action that contradicts a 'hard' anchor is ever blocked.${RESET}`);
-        const ok = await askYesNo(`  Wire it into ${PROJECT_SETTINGS_PATH}?`);
+        console.log(`  Fail-open — only an action contradicting a 'hard' anchor is ever blocked.${RESET}`);
+        const ok = await askYesNo(`  Wire it into ${targetPath}?`);
         if (!ok) {
             console.log(`  ${SKIP} Skipped. Enable later via the README → Re-injection Guard.`);
             return false;
         }
     }
-    // Merge, don't replace: append only the events we don't already own; leave foreign hooks intact.
-    const hooks = project.hooks ?? (project.hooks = {});
-    for (const ev of GUARD_EVENTS) {
-        if (!Array.isArray(hooks[ev]))
-            hooks[ev] = [];
-        if (!guardWiredFor(project, ev))
-            hooks[ev].push(GUARD_HOOKS[ev]);
+    // Merge, don't replace (see lib/guard-wiring.ts for the rules it holds to).
+    wireGuard(settings);
+    mkdirSync(targetDir, { recursive: true });
+    writeFileSync(targetPath, JSON.stringify(settings, null, 2), 'utf8');
+    console.log(`  ${CHECK} Guard wired → ${targetPath} ${DIM}(${scopeLabel})${RESET}`);
+    if (!projectGuard) {
+        console.log(`  ${DIM}Active in every repo. Scope an anchor with \`affects\` globs to limit where it fires;`);
+        console.log(`  --no-guard to skip, --project-guard for this repo only.${RESET}`);
     }
-    mkdirSync(PROJECT_CLAUDE_DIR, { recursive: true });
-    writeFileSync(PROJECT_SETTINGS_PATH, JSON.stringify(project, null, 2), 'utf8');
-    console.log(`  ${CHECK} Guard wired → ${PROJECT_SETTINGS_PATH}`);
     return true;
 }
 const guardConfigured = await configureGuard();

package/dist/db/migrate.js

@@ -70,11 +70,11 @@ export function runMigrations(db) {
     // v3 → v4: rebuild memories_fts with trigram tokenizer for JP/CJK support.
     // Only runs when upgrading an existing DB from schema v1-3.
     if (currentVersion > 0 && currentVersion < 4) {
-        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(`
+      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;
     `);
     }
     // v4 → v5: add normalized_name column BEFORE schema.sql runs,
@@ -118,9 +118,9 @@ export function runMigrations(db) {
             db.exec('ALTER TABLE memories ADD COLUMN thread_id TEXT');
         }
         // Backfill thread_id from content JSON session_id for existing memories
-        db.exec(`
-      UPDATE memories SET thread_id = json_extract(content, '$.session_id')
-      WHERE thread_id IS NULL AND json_valid(content) AND json_extract(content, '$.session_id') IS NOT NULL
+        db.exec(`
+      UPDATE memories SET thread_id = json_extract(content, '$.session_id')
+      WHERE thread_id IS NULL AND json_valid(content) AND json_extract(content, '$.session_id') IS NOT NULL
     `);
     }
     // v8 → v9: ProjectCoreNode — extend drift_anchors into the Current Truth Map node.
@@ -221,12 +221,12 @@ function migrateV5EntityNormalization(db) {
         }
     })();
     // 4. Auto-merge duplicate entities (same kind + normalized_name)
-    const dupes = db.prepare(`
-    SELECT kind, normalized_name, GROUP_CONCAT(id) as ids
-    FROM entities
-    WHERE normalized_name IS NOT NULL
-    GROUP BY kind, normalized_name
-    HAVING COUNT(*) > 1
+    const dupes = db.prepare(`
+    SELECT kind, normalized_name, GROUP_CONCAT(id) as ids
+    FROM entities
+    WHERE normalized_name IS NOT NULL
+    GROUP BY kind, normalized_name
+    HAVING COUNT(*) > 1
   `).all();
     if (dupes.length > 0) {
         console.log(`[linksee-memory] v5 migration: merging ${dupes.length} duplicate entity clusters`);
@@ -247,12 +247,12 @@ function mergeEntityCluster(db, ids) {
     if (ids.length < 2)
         return;
     // Score each entity: prefer most memories, then has canonical_key, then lowest id
-    const rows = db.prepare(`
-    SELECT e.id, e.name, e.canonical_key, COUNT(m.id) as mem_count
-    FROM entities e LEFT JOIN memories m ON m.entity_id = e.id
-    WHERE e.id IN (${ids.map(() => '?').join(',')})
-    GROUP BY e.id
-    ORDER BY mem_count DESC, (e.canonical_key IS NOT NULL) DESC, e.id ASC
+    const rows = db.prepare(`
+    SELECT e.id, e.name, e.canonical_key, COUNT(m.id) as mem_count
+    FROM entities e LEFT JOIN memories m ON m.entity_id = e.id
+    WHERE e.id IN (${ids.map(() => '?').join(',')})
+    GROUP BY e.id
+    ORDER BY mem_count DESC, (e.canonical_key IS NOT NULL) DESC, e.id ASC
   `).all(...ids);
     const keep = rows[0];
     const mergeIds = rows.slice(1).map(r => r.id);
@@ -273,16 +273,16 @@ function mergeEntityCluster(db, ids) {
         db.prepare('UPDATE events SET entity_id = ? WHERE entity_id = ?').run(keep.id, mid);
         // Reassign edges (both directions)
         // Handle UNIQUE constraint: delete duplicates first
-        db.prepare(`
-      DELETE FROM edges WHERE from_id = ? AND EXISTS (
-        SELECT 1 FROM edges e2 WHERE e2.from_id = ? AND e2.to_id = edges.to_id AND e2.relation = edges.relation
-      )
+        db.prepare(`
+      DELETE FROM edges WHERE from_id = ? AND EXISTS (
+        SELECT 1 FROM edges e2 WHERE e2.from_id = ? AND e2.to_id = edges.to_id AND e2.relation = edges.relation
+      )
     `).run(mid, keep.id);
         db.prepare('UPDATE edges SET from_id = ? WHERE from_id = ?').run(keep.id, mid);
-        db.prepare(`
-      DELETE FROM edges WHERE to_id = ? AND EXISTS (
-        SELECT 1 FROM edges e2 WHERE e2.to_id = ? AND e2.from_id = edges.from_id AND e2.relation = edges.relation
-      )
+        db.prepare(`
+      DELETE FROM edges WHERE to_id = ? AND EXISTS (
+        SELECT 1 FROM edges e2 WHERE e2.to_id = ? AND e2.from_id = edges.from_id AND e2.relation = edges.relation
+      )
     `).run(mid, keep.id);
         db.prepare('UPDATE edges SET to_id = ? WHERE to_id = ?').run(keep.id, mid);
         // Reassign consolidations