sessionmem 1.2.0 → 1.4.0

package/dist/cli/commands/dedupe.js

@@ -1,7 +1,7 @@
 import { createCliContext } from "../context.js";
 import { listMemoriesByProject } from "../../core/storage/memoryRepo.js";
 const SIMILARITY_THRESHOLD = 0.85;
-const MAX_TAG_LEN = 200;
+const MAX_PREVIEW_LEN = 200;
 function cosineSimilarity(a, b) {
     if (a.length !== b.length || a.length === 0)
         return 0;
@@ -14,31 +14,82 @@ function cosineSimilarity(a, b) {
     const denom = Math.sqrt(normA) * Math.sqrt(normB);
     return denom === 0 ? 0 : dot / denom;
 }
+/**
+ * Parse and validate the `--threshold` flag. An unparseable or out-of-range
+ * value used to flow through as NaN, and every `sim >= NaN` comparison is
+ * false — so `--threshold banana` reported "no duplicates found" rather than
+ * telling the user their input was rejected.
+ */
+function resolveThreshold(raw) {
+    if (raw === undefined)
+        return SIMILARITY_THRESHOLD;
+    const parsed = Number(raw.trim());
+    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) {
+        console.error(`Invalid --threshold "${raw}": expected a number greater than 0 and at most 1.`);
+        process.exit(1);
+    }
+    return parsed;
+}
+/** Parse a stored embedding, returning null when it is absent or malformed. */
+function parseVector(embedding) {
+    if (!embedding)
+        return null;
+    try {
+        const parsed = JSON.parse(embedding);
+        if (!Array.isArray(parsed) || !parsed.every((n) => Number.isFinite(n))) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
 export async function dedupeCommand(options = {}, ctx) {
     const context = ctx ?? createCliContext();
-    const threshold = options.threshold ? parseFloat(options.threshold) : SIMILARITY_THRESHOLD;
+    const threshold = resolveThreshold(options.threshold);
     const dryRun = options.dry !== false;
-    const memories = listMemoriesByProject(context.db, context.projectId);
-    const withEmbeddings = memories.filter((m) => m.embedding && m.embedding_dim);
-    if (withEmbeddings.length < 2) {
+    // Parse each embedding ONCE. The inner loop used to re-parse the same
+    // candidate's JSON for every outer element — O(n²) JSON.parse calls over a
+    // list that only has n distinct vectors.
+    const candidates = [];
+    for (const memory of listMemoriesByProject(context.db, context.projectId)) {
+        const vector = parseVector(memory.embedding);
+        if (!vector || !memory.embedding_dim)
+            continue;
+        candidates.push({
+            id: memory.id,
+            content: memory.content,
+            importance: memory.importance,
+            vector,
+        });
+    }
+    if (candidates.length < 2) {
         process.stdout.write("Not enough memories with embeddings to compare.\n");
         return;
     }
+    // Highest importance first, id as the tie-break. Pairs are emitted in this
+    // order and the first element of a pair is the one kept, so the survivor of
+    // any duplicate cluster is deterministic.
+    //
+    // Without this the order came from `ORDER BY updated_at DESC`, which is not a
+    // total order — memories written in the same clock tick tie, and the winner
+    // varied by platform. The same three memories could collapse to a different
+    // survivor on Windows than on Linux, and `--apply` is a hard delete.
+    candidates.sort((left, right) => right.importance - left.importance || left.id.localeCompare(right.id));
     const pairs = [];
-    for (let i = 0; i < withEmbeddings.length; i++) {
-        const a = withEmbeddings[i];
-        const vecA = JSON.parse(a.embedding);
-        for (let j = i + 1; j < withEmbeddings.length; j++) {
-            const b = withEmbeddings[j];
-            const vecB = JSON.parse(b.embedding);
-            const sim = cosineSimilarity(vecA, vecB);
+    for (let i = 0; i < candidates.length; i++) {
+        const a = candidates[i];
+        for (let j = i + 1; j < candidates.length; j++) {
+            const b = candidates[j];
+            const sim = cosineSimilarity(a.vector, b.vector);
             if (sim >= threshold) {
                 pairs.push({
                     idA: a.id,
                     idB: b.id,
                     similarity: sim,
-                    contentA: a.content.slice(0, MAX_TAG_LEN),
-                    contentB: b.content.slice(0, MAX_TAG_LEN),
+                    contentA: a.content.slice(0, MAX_PREVIEW_LEN),
+                    contentB: b.content.slice(0, MAX_PREVIEW_LEN),
                 });
             }
         }
@@ -47,26 +98,42 @@ export async function dedupeCommand(options = {}, ctx) {
         process.stdout.write(`No near-duplicate memories found (threshold: ${threshold}).\n`);
         return;
     }
+    const byId = new Map(candidates.map((c) => [c.id, c]));
+    const deleted = new Set();
     process.stdout.write(`Found ${pairs.length} near-duplicate pair(s) (threshold: ${threshold}):\n\n`);
     for (const pair of pairs) {
+        // Skip a pair whose partner is already gone. Similarity is not transitive:
+        // in a chain A~B, B~C with A≁C, deleting B for the (A,B) pair left the
+        // (B,C) pair still to process, and that pass could delete C — a memory
+        // whose only duplicate no longer existed. Nothing kept C from being
+        // dropped on the strength of an already-deleted row.
+        if (deleted.has(pair.idA) || deleted.has(pair.idB))
+            continue;
         process.stdout.write(`Similarity: ${(pair.similarity * 100).toFixed(1)}%\n`);
-        process.stdout.write(`  A [${pair.idA}]: ${pair.contentA}${pair.contentA.length >= MAX_TAG_LEN ? "…" : ""}\n`);
-        process.stdout.write(`  B [${pair.idB}]: ${pair.contentB}${pair.contentB.length >= MAX_TAG_LEN ? "…" : ""}\n`);
+        process.stdout.write(`  A [${pair.idA}]: ${pair.contentA}${pair.contentA.length >= MAX_PREVIEW_LEN ? "…" : ""}\n`);
+        process.stdout.write(`  B [${pair.idB}]: ${pair.contentB}${pair.contentB.length >= MAX_PREVIEW_LEN ? "…" : ""}\n`);
         if (!dryRun) {
-            // Keep A (higher importance or first by date), delete B.
-            const memA = withEmbeddings.find((m) => m.id === pair.idA);
-            const memB = withEmbeddings.find((m) => m.id === pair.idB);
+            const memA = byId.get(pair.idA);
+            const memB = byId.get(pair.idB);
+            if (!memA || !memB)
+                continue;
             const keepId = memA.importance >= memB.importance ? pair.idA : pair.idB;
             const dropId = keepId === pair.idA ? pair.idB : pair.idA;
-            await context.service.call("forgetMemory", {
+            const result = await context.service.call("forgetMemory", {
                 projectId: context.projectId,
                 memoryId: dropId,
             });
-            process.stdout.write(`  → Deleted ${dropId} (kept ${keepId})\n`);
+            if (result.ok) {
+                deleted.add(dropId);
+                process.stdout.write(`  → Deleted ${dropId} (kept ${keepId})\n`);
+            }
+            else {
+                process.stdout.write(`  → Failed to delete ${dropId}: ${result.error.message}\n`);
+            }
         }
         process.stdout.write("\n");
     }
-    if (dryRun && pairs.length > 0) {
+    if (dryRun) {
         process.stdout.write(`Run with --apply to delete the lower-importance duplicate in each pair.\n`);
     }
 }

package/dist/cli/commands/import.js

@@ -14,7 +14,7 @@ export async function importCommand(pathArg, options, ctx) {
     // Read and parse the JSON file
     let parsed;
     try {
-        const raw = readFileSync(inPath, "utf8");
+        const raw = new TextDecoder("utf-8", { fatal: true }).decode(readFileSync(inPath));
         parsed = JSON.parse(raw);
     }
     catch (err) {
@@ -27,61 +27,32 @@ export async function importCommand(pathArg, options, ctx) {
         console.error("Import file must be a JSON array of memory records.");
         process.exit(1);
     }
-    const records = parsed;
-    let toImport = records;
-    let skippedCount = 0;
-    if (!options.merge) {
-        // By default, skip existing IDs (pre-filter). `id` is a
-        // globally-unique PRIMARY KEY (not scoped by project), so the duplicate
-        // check must consider every project's ids -- otherwise a record whose id
-        // collides with another project's memory would not be pre-filtered here
-        // and could fall through to the service's ON CONFLICT(id) upsert.
-        const existingIds = listAllMemoryIds(context.db);
-        const filtered = records.filter((r) => {
-            const id = typeof r.id === "string" ? r.id : undefined;
-            return id === undefined || !existingIds.has(id);
-        });
-        skippedCount = records.length - filtered.length;
-        toImport = filtered;
-    }
-    if (toImport.length === 0 && skippedCount > 0) {
-        console.log(`Imported 0, skipped ${skippedCount} duplicates.`);
-        return;
-    }
-    // Map to the expected shape, then validate each record before sending to the service
-    const mapped = toImport.map((r) => ({
-        id: r.id,
-        projectId: r.projectId ?? context.projectId,
-        sessionId: r.sessionId,
-        sourceAdapter: r.sourceAdapter,
-        kind: r.kind,
-        content: r.content,
-        importance: r.importance,
-        createdAt: r.createdAt,
-        updatedAt: r.updatedAt,
-    }));
-    // Validate each record but skip-and-warn on individual invalid
-    // records (consistent with the duplicate-skip UX) instead of aborting the
-    // entire import on the first invalid record, which would discard earlier
-    // valid records with no partial import.
+    const existingIds = options.merge ? undefined : listAllMemoryIds(context.db);
     const validMemories = [];
+    let skippedCount = 0;
     let invalidCount = 0;
-    for (let i = 0; i < mapped.length; i++) {
-        const check = importMemoryRecordSchema.safeParse(mapped[i]);
+    for (const [index, record] of parsed.entries()) {
+        const isRecord = record !== null && typeof record === "object" && !Array.isArray(record);
+        if (isRecord && typeof record.id === "string" && existingIds?.has(record.id)) {
+            skippedCount += 1;
+            continue;
+        }
+        // Validate unknown values before accessing fields. Keep the source index in
+        // diagnostics even when earlier records were duplicates, and preserve the
+        // optional provenance fields carried by exports.
+        const check = importMemoryRecordSchema.safeParse(isRecord ? { ...record, projectId: record.projectId ?? context.projectId } : record);
         if (!check.success) {
-            console.error(`Record at index ${i} is invalid, skipping: ${check.error.message}`);
+            console.error(`Record at index ${index} is invalid, skipping: ${check.error.message}`);
             invalidCount += 1;
             continue;
         }
-        // Use the parsed/transformed record so `kind` is narrowed to the
-        // canonical enum (memoryKindSchema maps legacy values like `architecture`).
         validMemories.push(check.data);
     }
     if (validMemories.length === 0) {
         if (invalidCount > 0) {
             console.log(`Imported 0, skipped ${invalidCount} invalid record(s).`);
         }
-        else if (skippedCount > 0) {
+        else {
             console.log(`Imported 0, skipped ${skippedCount} duplicates.`);
         }
         return;

package/dist/cli/commands/ingestHook.js

@@ -5,6 +5,22 @@ const CAPTURED_TOOL_TYPES = new Set(["Bash", "Edit", "Write", "MultiEdit"]);
 // Max payload size stored per hook event (chars). The full hook payload can be
 // large (file diffs); cap it so a single tool use can't bloat session_events.
 const MAX_HOOK_PAYLOAD_CHARS = 4000;
+// Per-field cap applied BEFORE serialization. Truncating the serialized JSON
+// instead would produce a string that is no longer valid JSON, which the
+// `payloadJson` contract rejects (it parses the value) — the event would then be
+// dropped, silently, by the catch-all below. Trim the inputs, not the output.
+const MAX_FIELD_CHARS = 1200;
+// One-line human summary shown in session summaries (summaryShape reads `text`).
+const MAX_TEXT_CHARS = 300;
+/** Emit a hook diagnostic to stderr when SESSIONMEM_DEBUG=1. */
+function debug(message) {
+    if (process.env.SESSIONMEM_DEBUG === "1") {
+        process.stderr.write(`[sessionmem] ingest-hook: ${message}\n`);
+    }
+}
+function truncate(value, max) {
+    return value.length > max ? `${value.slice(0, max)}…` : value;
+}
 async function readStdinJson() {
     if (process.stdin.isTTY)
         return {};
@@ -40,6 +56,65 @@ function resolveSessionId(payload) {
     }
     return process.env.CLAUDE_CODE_SESSION_ID ?? process.env.SESSION_ID ?? `session-${Date.now()}`;
 }
+/**
+ * Shorten every string in a tool input to MAX_FIELD_CHARS, recursively. Keeps
+ * the object's shape (so it still serializes to valid JSON) while bounding the
+ * size contributed by large fields such as a Write tool's `content` or an Edit
+ * tool's replacement text.
+ */
+function shrinkValue(value, depth = 0) {
+    if (typeof value === "string")
+        return truncate(value, MAX_FIELD_CHARS);
+    if (depth >= 4)
+        return undefined;
+    if (Array.isArray(value)) {
+        return value.slice(0, 20).map((item) => shrinkValue(item, depth + 1));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, inner] of Object.entries(value)) {
+            out[key] = shrinkValue(inner, depth + 1);
+        }
+        return out;
+    }
+    // Numbers/booleans/null pass through; functions/undefined/symbols drop out.
+    return value === undefined || typeof value === "function" || typeof value === "symbol"
+        ? undefined
+        : value;
+}
+/**
+ * A short human-readable line describing the tool use. Stored alongside the
+ * structured input as `text`, which the local summarizer prefers over the raw
+ * payload — so session summaries read as prose instead of dumped JSON.
+ */
+function describeToolUse(toolName, input) {
+    const str = (key) => typeof input?.[key] === "string" ? input[key] : "";
+    if (toolName === "Bash") {
+        const command = str("command").replace(/\s+/g, " ").trim();
+        return truncate(command ? `Ran: ${command}` : "Ran a shell command", MAX_TEXT_CHARS);
+    }
+    const filePath = str("file_path") || str("path") || str("notebook_path");
+    const verb = toolName === "Write" ? "Wrote" : "Edited";
+    return truncate(filePath ? `${verb} ${filePath}` : `${verb} a file`, MAX_TEXT_CHARS);
+}
+/**
+ * Serialize the event payload, guaranteeing valid JSON within
+ * MAX_HOOK_PAYLOAD_CHARS. Per-field shrinking handles the common case; if the
+ * result is still over budget (many fields, or one huge key set), drop the
+ * structured input and keep only the human-readable summary rather than
+ * emitting truncated — and therefore unparseable — JSON.
+ */
+function buildPayloadJson(toolName, text, input, cwd) {
+    const full = JSON.stringify({
+        tool: toolName,
+        text,
+        input: shrinkValue(input),
+        cwd,
+    });
+    if (full.length <= MAX_HOOK_PAYLOAD_CHARS)
+        return full;
+    return JSON.stringify({ tool: toolName, text, cwd, truncated: true });
+}
 /**
  * `sessionmem ingest-hook` — PostToolUse hook handler.
  * Reads Claude Code's PostToolUse JSON payload from stdin and stores it as a
@@ -47,34 +122,36 @@ function resolveSessionId(payload) {
  * Also auto-stores git commits as decision memories (git commit detection).
  */
 export async function ingestHookCommand(ctx) {
+    let context;
     try {
         const payload = await readStdinJson();
         const toolName = payload.tool_name ?? "";
-        if (!CAPTURED_TOOL_TYPES.has(toolName))
+        if (!CAPTURED_TOOL_TYPES.has(toolName)) {
+            debug(`skipped: tool "${toolName}" is not captured`);
             return;
-        const context = ctx ?? createCliContext();
+        }
+        context = ctx ?? createCliContext();
         const sessionId = resolveSessionId(payload);
         const projectId = context.projectId;
-        // Trim payload to cap storage per event.
-        const fullPayload = JSON.stringify({
-            tool: toolName,
-            input: payload.tool_input,
-            cwd: payload.cwd,
-        });
-        const trimmedPayload = fullPayload.length > MAX_HOOK_PAYLOAD_CHARS
-            ? fullPayload.slice(0, MAX_HOOK_PAYLOAD_CHARS) + "…"
-            : fullPayload;
-        // Store as a session event (for SessionEnd auto-summarize).
-        await context.service.call("ingestSessionEvents", {
+        const text = describeToolUse(toolName, payload.tool_input);
+        // eventIndex is intentionally omitted: the service assigns the next free
+        // index per session inside an immediate transaction, so parallel tool calls
+        // cannot collide (see nextSessionEventIndex).
+        const result = await context.service.call("ingestSessionEvents", {
             projectId,
             sessionId,
             events: [{
                     id: randomUUID(),
-                    eventIndex: Date.now(), // monotonic within the session
                     eventType: `tool_use:${toolName.toLowerCase()}`,
-                    payloadJson: trimmedPayload,
+                    payloadJson: buildPayloadJson(toolName, text, payload.tool_input, payload.cwd),
                 }],
         });
+        if (!result.ok) {
+            debug(`ingest failed: ${result.error.message}`);
+        }
+        else {
+            debug(`ingested ${result.ingested} event(s) for session ${sessionId} (project ${projectId})`);
+        }
         // Git commit detection: auto-store as a decision memory.
         if (toolName === "Bash") {
             const cmd = typeof payload.tool_input?.command === "string"
@@ -96,9 +173,21 @@ export async function ingestHookCommand(ctx) {
                 }
             }
         }
-        context.db.close();
     }
-    catch {
-        // Never block tool use — swallow all errors silently.
+    catch (err) {
+        // Never block tool use — a hook failure must not surface as a tool error.
+        debug(err instanceof Error ? err.message : String(err));
+    }
+    finally {
+        // Close only a context this command opened; an injected ctx belongs to the
+        // caller (tests reuse it across assertions). Previously the close was
+        // inside the try block, so it was skipped on every error path and leaked
+        // the sqlite handle.
+        if (!ctx && context) {
+            try {
+                context.db.close();
+            }
+            catch { /* already closed */ }
+        }
     }
 }

package/dist/cli/commands/install.js

@@ -3,7 +3,7 @@ import { join } from "path";
 import { homedir } from "os";
 import { AdapterFactory } from "../../adapters/factory.js";
 import { injectGuidanceBlock } from "../../adapters/claudeMdInjector.js";
-import { createCliContext } from "../context.js";
+import { createCliContext, resolveDbPath } from "../context.js";
 /**
  * Resolve the adapter to install into: an explicit `--adapter` flag wins, then
  * the SESSIONMEM_ADAPTER env override, else auto-detection from the host env.
@@ -53,8 +53,8 @@ export async function installCommand(options, contextOverrides) {
         dbPath = ctx.dbPath;
     }
     catch (err) {
-        console.error(`✗ DB init failed (~/.sessionmem/memories.db): ${err instanceof Error ? err.message : String(err)}`);
-        console.error("Hint: ensure ~/.sessionmem directory is writable and run `sessionmem install` again.");
+        console.error(`✗ DB init failed (${resolveDbPath(contextOverrides?.dbPath)}): ${err instanceof Error ? err.message : String(err)}`);
+        console.error("Hint: ensure the database parent directory is writable and run `sessionmem install` again.");
         process.exit(1);
     }
     console.log(`✓ DB initialized (${dbPath})`);

package/dist/cli/commands/list.js

@@ -10,4 +10,7 @@ export async function listCommand(ctx) {
         process.exit(1);
     }
     console.log(formatTable(result.memories));
+    if (result.total > result.memories.length) {
+        console.error(`Showing ${result.memories.length} of ${result.total} memories. Use \`sessionmem export\` for the full project.`);
+    }
 }

package/dist/cli/commands/run.js

@@ -1,19 +1,15 @@
 import { AdapterFactory } from "../../adapters/factory.js";
 import { mkdirSync, writeFileSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
+import { join, dirname } from "path";
 import { deriveProjectId } from "../projectId.js";
-import { expandTilde } from "../context.js";
+import { resolveDbPath } from "../context.js";
 export async function runMcpServer() {
     const adapter = AdapterFactory.detectAdapter();
-    // Startup diagnostics: written to ~/.sessionmem/logs/mcp.log
-    const logDir = join(homedir(), ".sessionmem", "logs");
+    // Keep diagnostics beside the selected database so an override never
+    // creates the default home directory just to write a log.
+    const dbPath = resolveDbPath();
+    const logDir = join(dirname(dbPath), "logs");
     const logPath = join(logDir, "mcp.log");
-    // Derive db path for diagnostics (mirrors context.ts defaultDbPath)
-    const envDbPath = process.env.SESSIONMEM_DB_PATH;
-    const dbPath = envDbPath && envDbPath.trim() !== ""
-        ? expandTilde(envDbPath)
-        : join(homedir(), ".sessionmem", "memories.db");
     // Derive project ID for diagnostics. Shares the exact derivation the server
     // uses (createCliContext → deriveProjectId) so the logged id never diverges
     // from the bucket the server actually serves.
@@ -21,8 +17,10 @@ export async function runMcpServer() {
     const adapterName = adapter.name;
     const logMessage = `[${new Date().toISOString()}] Started sessionmem | adapter=${adapterName} db=${dbPath} project=${projectId}\n`;
     try {
-        mkdirSync(logDir, { recursive: true });
-        writeFileSync(logPath, logMessage, { flag: "a" });
+        if (dbPath !== ":memory:") {
+            mkdirSync(logDir, { recursive: true });
+            writeFileSync(logPath, logMessage, { flag: "a" });
+        }
     }
     catch {
         // best-effort logging; ignore failures

package/dist/cli/commands/savings.js

@@ -63,7 +63,9 @@ export function savingsCommand(ctx, options) {
         ? [
             "Storage compression:",
             "  No session data ingested yet.",
-            "  Tip: call ingestSessionEvents during sessions to track token usage.",
+            "  Session events are captured automatically by the PostToolUse hook.",
+            "  If this stays empty, run `sessionmem install` to (re)register the hook,",
+            "  then check `sessionmem stats` for the session_events counter.",
         ]
         : [
             "Storage compression:",

package/dist/cli/commands/search.js

@@ -1,18 +1,22 @@
 import { createCliContext } from "../context.js";
 import { formatTable } from "../output.js";
-const DEFAULT_LIMIT = 20;
+const DEFAULT_LIMIT = 10;
 function coerceLimit(value) {
     if (value === undefined)
         return DEFAULT_LIMIT;
-    const parsed = Number.parseInt(String(value), 10);
-    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_LIMIT;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 100) {
+        throw new Error(`Invalid --limit "${value}": expected an integer from 1 to 100.`);
+    }
+    return parsed;
 }
 export async function searchCommand(query, options = {}, ctx) {
+    const limit = coerceLimit(options.limit);
     const context = ctx ?? createCliContext();
     const result = await context.service.call("retrieveMemories", {
         projectId: context.projectId,
         query,
-        limit: coerceLimit(options.limit),
+        limit,
         mode: "auto",
         depth: "default",
     });

package/dist/cli/commands/stats.js

@@ -2,6 +2,7 @@ import { statSync } from "fs";
 import { createCliContext } from "../context.js";
 import { countTokens } from "../../core/injection/tokenBudget.js";
 import { listMemoriesByProject } from "../../core/storage/memoryRepo.js";
+import { countDistinctSessions } from "../../core/storage/tokenSavingsRepo.js";
 import { configFilePath, readPolicyConfig, } from "../../core/config/policyConfig.js";
 export async function statsCommand(ctx, options) {
     const context = ctx ?? createCliContext();
@@ -38,7 +39,13 @@ export async function statsCommand(ctx, options) {
         retentionLine = `Retention: ${retentionDays} days (${eligible} memories eligible for pruning)`;
     }
     const redactionLine = `Redaction: ${redactionEnabled ? "enabled" : "disabled"}`;
+    // Surface the session-event counters. The auto-ingest pipeline is silent by
+    // design (a hook must never fail a tool call), so without these lines a
+    // pipeline that captures nothing looks identical to one that works.
+    const sessions = countDistinctSessions(context.db, context.projectId);
     process.stdout.write(`memories: ${result.totalMemories}\n` +
+        `sessions: ${sessions}\n` +
+        `session_events: ${result.totalSessionEvents}\n` +
         `db_size_bytes: ${sizeBytes}\n` +
         `total_content_tokens: ${totalTokens}\n` +
         `${retentionLine}\n` +

package/dist/cli/commands/uninstall.js

@@ -1,6 +1,7 @@
 import { existsSync, rmSync } from "fs";
 import { join } from "path";
 import { homedir } from "os";
+import { resolveDbPath } from "../context.js";
 import { AdapterFactory } from "../../adapters/factory.js";
 import { removeClaudeMdBlock } from "../../adapters/claudeMdInjector.js";
 /**
@@ -51,7 +52,7 @@ export async function uninstallCommand(options = {}) {
         }
     }
     // Resolve dbPath: use injected override (for tests) or the default location
-    const dbPath = options.dbPath ?? join(homedir(), ".sessionmem", "memories.db");
+    const dbPath = resolveDbPath(options.dbPath);
     if (options.purge) {
         // --purge: delete only memories.db, not logs or the ~/.sessionmem directory
         if (existsSync(dbPath)) {

package/dist/cli/context.js

@@ -42,19 +42,21 @@ export function expandTilde(p) {
     }
     return p;
 }
-function defaultDbPath(dir) {
+export function resolveDbPath(override) {
+    if (override !== undefined)
+        return expandTilde(override);
     // Env override seam (see deriveProjectId). Defaults to ~/.sessionmem/memories.db.
     const envDbPath = process.env.SESSIONMEM_DB_PATH;
     if (envDbPath && envDbPath.trim() !== "")
         return expandTilde(envDbPath);
-    // `dir` is the fixed ~/.sessionmem dir computed above, not user input.
     // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
-    return join(dir, "memories.db");
+    return join(homedir(), ".sessionmem", "memories.db");
 }
 export function createCliContext(overrides = {}) {
-    const dir = join(homedir(), ".sessionmem");
-    mkdirSync(dir, { recursive: true });
-    const dbPath = overrides.dbPath ?? defaultDbPath(dir);
+    const dbPath = resolveDbPath(overrides.dbPath);
+    if (!overrides.db && dbPath !== ":memory:") {
+        mkdirSync(dirname(dbPath), { recursive: true });
+    }
     const here = dirname(fileURLToPath(import.meta.url));
     const migrationsDir = overrides.migrationsDir ?? join(here, "..", "core", "schema", "migrations");
     const username = overrides.username ?? localUsername();