memarium 0.13.1

package/dist/src/commands/prune.js

@@ -0,0 +1,108 @@
+import { readdirSync, statSync, unlinkSync, rmdirSync } from "node:fs";
+import { join, relative, dirname } from "node:path";
+import chalk from "chalk";
+import { readConfig } from "../config.js";
+import { loadIndex } from "../index-store.js";
+/**
+ * `memarium prune` — find raw_sessions/*.md files on disk that are NOT
+ * referenced by `.memarium/index.json` and (optionally) delete them.
+ *
+ * Why this exists: pre-0.7.1 the Copilot adapter could write the same
+ * sessionId to two different .md paths (chatSessions/ + transcripts/ both
+ * extracted as separate sources, different nameSlug/date, only one wins
+ * in the index). The losing write left an orphan .md on disk. 0.7.1 dedupes
+ * at discover time so new orphans stop accruing — `prune` cleans up the
+ * pre-existing ones.
+ *
+ * Dry-run by default. Pass `--apply` to actually delete. Empty parent
+ * directories are removed after their last file goes away.
+ */
+export async function pruneCmd(opts = {}) {
+    const cfg = readConfig();
+    const repoPath = opts.repoPath ?? cfg.repoPath;
+    const apply = opts.apply ?? false;
+    const idx = loadIndex(repoPath);
+    const indexed = new Set();
+    for (const e of Object.values(idx.entries))
+        indexed.add(e.relativePath);
+    const rawRoot = join(repoPath, "raw_sessions");
+    const onDisk = walkMd(rawRoot, repoPath);
+    const orphans = onDisk.filter((rel) => !indexed.has(rel));
+    const deleted = [];
+    if (orphans.length === 0) {
+        console.log(chalk.green(`✓ no orphan .md files in ${rawRoot}`));
+        console.log(chalk.gray(`  scanned ${onDisk.length}, indexed ${indexed.size}`));
+        return { scanned: onDisk.length, indexed: indexed.size, orphans, deleted };
+    }
+    console.log(chalk.yellow(`found ${orphans.length} orphan .md file(s) (on disk but not in index):`));
+    for (const o of orphans)
+        console.log(`  ${o}`);
+    console.log();
+    if (!apply) {
+        console.log(chalk.cyan(`dry-run — pass --apply to delete`));
+        return { scanned: onDisk.length, indexed: indexed.size, orphans, deleted };
+    }
+    // Apply: delete each orphan + sweep its parent dir if empty
+    const dirsTouched = new Set();
+    for (const o of orphans) {
+        const abs = join(repoPath, o);
+        try {
+            unlinkSync(abs);
+            deleted.push(o);
+            dirsTouched.add(dirname(abs));
+        }
+        catch (err) {
+            console.log(chalk.red(`! could not delete ${o}: ${err.message}`));
+        }
+    }
+    // Sweep empty dirs upward from each touched dir until we hit a non-empty
+    // ancestor or escape rawRoot. We stop short of rawRoot itself.
+    for (const d of dirsTouched) {
+        let cur = d;
+        while (cur.startsWith(rawRoot) && cur !== rawRoot) {
+            let entries = [];
+            try {
+                entries = readdirSync(cur);
+            }
+            catch {
+                break;
+            }
+            if (entries.length > 0)
+                break;
+            try {
+                rmdirSync(cur);
+            }
+            catch {
+                break;
+            }
+            cur = dirname(cur);
+        }
+    }
+    console.log(chalk.green(`✓ deleted ${deleted.length} orphan(s)`));
+    return { scanned: onDisk.length, indexed: indexed.size, orphans, deleted };
+}
+function walkMd(dir, repoRoot) {
+    const out = [];
+    const stack = [dir];
+    while (stack.length > 0) {
+        const cur = stack.pop();
+        let entries;
+        try {
+            entries = readdirSync(cur, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const e of entries) {
+            const p = join(cur, e.name);
+            if (e.isDirectory())
+                stack.push(p);
+            else if (e.isFile() && e.name.endsWith(".md")) {
+                out.push(relative(repoRoot, p));
+            }
+        }
+    }
+    // Sanity: skip empty if rawRoot doesn't exist
+    void statSync;
+    return out;
+}

package/dist/src/commands/resume/config-pathmap.js

@@ -0,0 +1,38 @@
+import { readConfig, writeConfig } from "../../config.js";
+import { sanitizeBranchName } from "../../device.js";
+/** Parse "FROM=TO" and add it to ~/.memarium/config.json's pathMap. Throws
+ *  on malformed input. Used by the `memarium config --map-path` CLI flag.
+ *
+ *  The pathMap field is optional in the Config schema; if it doesn't exist
+ *  yet, this initializes it.
+ */
+export function setMapPath(spec) {
+    const idx = spec.indexOf("=");
+    if (idx < 0) {
+        throw new Error(`Invalid --map-path '${spec}': expected FROM=TO form`);
+    }
+    const from = spec.slice(0, idx);
+    const to = spec.slice(idx + 1);
+    if (!from)
+        throw new Error(`--map-path '${spec}': FROM is empty`);
+    if (!to)
+        throw new Error(`--map-path '${spec}': TO is empty`);
+    const cfg = readConfig();
+    const map = { ...(cfg.pathMap ?? {}), [from]: to };
+    writeConfig({ ...cfg, pathMap: map });
+}
+/** Set ~/.memarium/config.json's deviceBranch. Used by `memarium config
+ *  --device <name>` so existing users can replace a drift-prone hostname
+ *  (e.g. "Mac-mini-2.local") with a stable physical-label name (e.g. "mini2").
+ *  Returns the previous and new branch names so the CLI can hint the user
+ *  to delete the old remote branch.
+ */
+export function setDeviceBranch(name) {
+    const sanitized = sanitizeBranchName(name);
+    if (!sanitized)
+        throw new Error(`--device '${name}': sanitizes to empty branch name`);
+    const cfg = readConfig();
+    const previous = cfg.deviceBranch;
+    writeConfig({ ...cfg, deviceBranch: sanitized });
+    return { previous, current: sanitized };
+}

package/dist/src/commands/resume/fuzzy-match.js

@@ -0,0 +1,13 @@
+/**
+ * Match index entries by any of: full sessionId UUID, 8-char shortId, or any
+ * UUID prefix. Case-insensitive. Returns all matches (could be 0, 1, or many).
+ *
+ * The caller (resume.ts) decides whether to:
+ *  - 0 matches → throw "no session found"
+ *  - 1 match → proceed
+ *  - >1 matches → throw with candidate list, ask user for more specificity
+ */
+export function findEntries(idx, idOrPrefix) {
+    const needle = idOrPrefix.toLowerCase();
+    return Object.values(idx.entries).filter((e) => e.sessionId.toLowerCase().startsWith(needle));
+}

package/dist/src/commands/resume/list-sessions.js

@@ -0,0 +1,54 @@
+import { readConfig } from "../../config.js";
+import { loadIndex } from "../../index-store.js";
+import { loadAggregatedIndex } from "../../aggregated-store.js";
+/**
+ * Returns sessions from BOTH the device's own spool index AND the union
+ * `.memarium/index.aggregated.json` written by CI to main. Dedupes by
+ * `tool:sessionId` — when the same session appears in both, the own copy
+ * wins (it carries the latest local sourceSha256 / mtime).
+ *
+ * Filtered + sorted newest-first. Caller (CLI handler) prints as a table.
+ */
+export async function listSessionsCmd(opts) {
+    const cfg = readConfig();
+    const ownIdx = loadIndex(cfg.repoPath);
+    const aggIdx = loadAggregatedIndex();
+    const merged = new Map();
+    for (const e of Object.values(ownIdx.entries)) {
+        merged.set(`${e.tool}:${e.sessionId}`, { ...e, isOwn: true });
+    }
+    for (const e of Object.values(aggIdx?.entries ?? {})) {
+        const k = `${e.tool}:${e.sessionId}`;
+        if (!merged.has(k))
+            merged.set(k, { ...e, isOwn: false });
+    }
+    const cutoffMs = parseSince(opts.since);
+    const result = [];
+    for (const entry of merged.values()) {
+        if (opts.project && entry.project !== opts.project)
+            continue;
+        if (cutoffMs !== null && Date.parse(entry.endedAt) < cutoffMs)
+            continue;
+        if (opts.device) {
+            const entryDevice = entry.originDevice;
+            const isOwnFromThisDevice = entry.isOwn && cfg.deviceBranch === opts.device;
+            if (!isOwnFromThisDevice && entryDevice !== opts.device)
+                continue;
+        }
+        result.push(entry);
+    }
+    result.sort((a, b) => b.endedAt.localeCompare(a.endedAt));
+    return result;
+}
+/** Parse "7d" / "1d" / "30d" / "24h" / "4w" → cutoff timestamp in ms; null if no --since set. */
+function parseSince(since) {
+    if (!since)
+        return null;
+    const m = since.match(/^(\d+)([dhw])$/);
+    if (!m)
+        throw new Error(`Invalid --since '${since}'. Use NdHw form: 1d, 24h, 4w.`);
+    const n = parseInt(m[1], 10);
+    const unit = m[2];
+    const ms = unit === "d" ? 86400_000 : unit === "h" ? 3600_000 : 7 * 86400_000;
+    return Date.now() - n * ms;
+}

package/dist/src/commands/resume/render-prompt.js

@@ -0,0 +1,121 @@
+import { writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+/** macOS default ARG_MAX is 1 MB total args; Linux often higher. We use a
+ *  conservative cap matching the smaller platform, leaving 10% headroom.
+ *  The full prompt body + framing must fit under this; otherwise we fall
+ *  back to writing the prompt to /tmp and asking Claude to Read it. */
+export const ARG_MAX_BYTES = 256 * 1024;
+/** Extract the header section of a 0.7+ manifest_version:1 md — the
+ *  YAML frontmatter (with the manifest fields) plus the `# Table of
+ *  Contents` block. Returns null when the md predates manifest_version:1
+ *  (no `manifest_version: 1` line in the first 200 lines), so the caller
+ *  can fall back to the full-embed path.
+ *
+ *  The split point is the first `## User` or `## Assistant` heading at
+ *  the start of a line, which always appears immediately after the TOC.
+ */
+export function extractMdHeader(contextMd) {
+    const lookahead = contextMd.slice(0, 50 * 1024);
+    if (!/^manifest_version:\s*1\b/m.test(lookahead))
+        return null;
+    const m = contextMd.match(/\n## (User|Assistant)/);
+    if (!m)
+        return null;
+    return contextMd.slice(0, m.index);
+}
+/** Build the user-prompt text we'll feed Claude as the first turn. Used
+ *  for legacy (0.6) md without manifest_version:1, or as a fallback when
+ *  the header extractor can't locate the split point. */
+export function renderResumePrompt(entry, contextMd, ctx = {}) {
+    return [
+        `I had a coding session on another machine that I'd like to continue.`,
+        `Below is the full conversation history. Read it carefully — pay`,
+        `attention to what files were touched, what was decided, and any open`,
+        `questions or TODOs at the end. Then summarize back to me what state`,
+        `we're in, and ask me what I'd like to do next.`,
+        ``,
+        `---`,
+        `Session: ${entry.displayName}`,
+        `Source device: ${ctx.device ?? "(unknown)"}`,
+        `Started: ${entry.startedAt}`,
+        `Ended: ${entry.endedAt}`,
+        `---`,
+        ``,
+        contextMd,
+        ``,
+        `---`,
+        `End of prior session. What's our next step?`,
+    ].join("\n");
+}
+/** Chunked-resume prompt for 0.7+ manifest_version:1 md. Embeds only the
+ *  header (frontmatter + manifest + TOC) inline and points Claude at the
+ *  on-disk md for body access. The resuming Claude orients via the
+ *  manifest, then `Read offset:` jumps via the TOC's →L<line> column to
+ *  pull only the segments it needs — letting us resume 100MB sessions
+ *  without blowing the context window. */
+export function renderResumePromptChunked(entry, mdPath, headerMd, fullMdBytes, ctx = {}) {
+    const sizeStr = formatSize(fullMdBytes);
+    return [
+        `I had a coding session on another machine that I'd like to continue.`,
+        `The full transcript lives on disk at:`,
+        ``,
+        `  ${mdPath}`,
+        ``,
+        `It is ${sizeStr} — large enough that you should NOT Read the whole`,
+        `file at once. The header below has a manifest (mechanical facts about`,
+        `what was worked on) and a Table of Contents. Use them to navigate:`,
+        ``,
+        `1. Skim the manifest fields (commits / files_touched / candidate_decisions)`,
+        `   to understand the session's shape.`,
+        `2. Pick 3–5 TOC rows most relevant to where the work left off (commits`,
+        `   near the end, decisions, last few user turns).`,
+        `3. The TOC's "→L<number>" column is the absolute line number in the`,
+        `   file. Use the Read tool with offset:<number> and limit:200 to pull`,
+        `   just that turn.`,
+        `4. Summarize back to me what state we're in (last decisions, open`,
+        `   questions, next_steps), then ask what to do next.`,
+        ``,
+        `---`,
+        `Session: ${entry.displayName}`,
+        `Source device: ${ctx.device ?? "(unknown)"}`,
+        `Started: ${entry.startedAt}`,
+        `Ended: ${entry.endedAt}`,
+        `---`,
+        ``,
+        headerMd,
+        ``,
+        `---`,
+        `End of header. Body continues in the on-disk file above (line ~${headerMd.split("\n").length + 2} onward).`,
+        `What's our next step?`,
+    ].join("\n");
+}
+/** Decide how to pass the prompt to claude. Short prompts go via argv
+ *  (`claude "prompt"`); long ones get spilled to /tmp and Claude reads
+ *  them with its Read tool. The threshold leaves 10% headroom under
+ *  ARG_MAX_BYTES so other argv components have room. */
+export function chooseInvocation(prompt, shortId) {
+    if (Buffer.byteLength(prompt, "utf8") < ARG_MAX_BYTES * 0.9) {
+        return ["claude", prompt];
+    }
+    const tmpPath = join(tmpdir(), `.memarium-resume-${shortId}.md`);
+    writeFileSync(tmpPath, prompt, "utf8");
+    return ["claude", `Read ${tmpPath} and act on the instructions there.`];
+}
+/** 0.8.5: below this, resume uses full-embed mode (the whole md goes
+ *  inline). Above it, chunked mode (header inline + on-disk Read).
+ *  5000 tokens-ish — fits comfortably even in 200K context models,
+ *  and saves Claude 1-2 round-trips on small sessions where chunked
+ *  navigation buys nothing. */
+export const CHUNKED_THRESHOLD_BYTES = 50 * 1024;
+/** Adaptive byte → human size. Sub-MB shows KB; otherwise MB with one
+ *  decimal. Pre-0.8.5 we always printed MB.toFixed(1), which rendered
+ *  33 KB as `"0.0 MB"` — technically true, totally misleading next to
+ *  "large enough that you should NOT Read the whole file at once". */
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}

package/dist/src/commands/resume/resume.js

@@ -0,0 +1,121 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { join, resolve } from "node:path";
+import chalk from "chalk";
+import { readConfig } from "../../config.js";
+import { loadIndex } from "../../index-store.js";
+import { loadAggregatedIndex, aggregatedPath } from "../../aggregated-store.js";
+import { findEntries } from "./fuzzy-match.js";
+import { renderResumePrompt, renderResumePromptChunked, extractMdHeader, chooseInvocation, CHUNKED_THRESHOLD_BYTES, } from "./render-prompt.js";
+/**
+ * `memarium resume <id>` — find the source session's markdown, build a prompt
+ * with the conversation history, and launch a fresh `claude` session with
+ * that prompt as the first user turn. The new Claude reads the prior context
+ * and asks the user what to continue with.
+ *
+ * Does NOT touch ~/.claude/projects/, does NOT call `claude --resume`, does
+ * NOT update any Claude internal state. Uses only the public `claude [prompt]`
+ * CLI interface.
+ */
+export async function resumeCmd(opts) {
+    const cfg = readConfig();
+    const ownIdx = loadIndex(cfg.repoPath);
+    const aggIdx = loadAggregatedIndex();
+    const ownMatches = findEntries(ownIdx, opts.idOrPrefix).map((entry) => ({ entry, isOwn: true }));
+    const aggMatches = aggIdx
+        ? findEntries(aggIdx, opts.idOrPrefix)
+            .filter((e) => !ownIdx.entries[`${e.tool}:${e.sessionId}`]) // dedupe — own wins
+            .map((entry) => ({ entry, isOwn: false }))
+        : [];
+    const matches = [...ownMatches, ...aggMatches];
+    if (matches.length === 0) {
+        throw new Error(`No session matches '${opts.idOrPrefix}'. ` +
+            `Run 'memarium list-sessions' to see what's available.`);
+    }
+    if (matches.length > 1) {
+        const lines = [
+            `Multiple matches for '${opts.idOrPrefix}':`,
+            ...matches.map(({ entry: m, isOwn }) => `  ${m.shortId}  ${m.displayName.slice(0, 50)}  (${m.startedAt.slice(0, 10)})${isOwn ? "" : " [from another device]"}`),
+            ``,
+            `Pass a longer id prefix to disambiguate.`,
+        ];
+        throw new Error(lines.join("\n"));
+    }
+    const { entry, isOwn } = matches[0];
+    // 2. Validate cwd (after pathMap translation)
+    const pathMap = cfg.pathMap ?? {};
+    const expectedCwd = applyPathMap(entry.projectRaw, pathMap);
+    const actualCwd = resolve(opts.cwd ?? process.cwd());
+    if (actualCwd !== expectedCwd) {
+        throw new Error(`This session was for ${expectedCwd}\n` +
+            `cd there first:  cd ${expectedCwd}`);
+    }
+    // 3. Locate context md (handle legacy .raw.json relativePath by falling back to .md)
+    const mdRelative = entry.relativePath.replace(/\.raw\.json$/, ".md");
+    const baseRoot = isOwn ? cfg.repoPath : aggregatedPath();
+    const mdPath = join(baseRoot, mdRelative);
+    if (!existsSync(mdPath)) {
+        throw new Error(`Context md missing: ${mdPath}. ` +
+            (isOwn
+                ? `The source device may not have synced this session yet, or you're on a 0.5.x spool that hasn't been re-synced under 0.6.`
+                : `This is a sibling-device session — run \`memarium sync\` to refresh the aggregated worktree.`));
+    }
+    const contextMd = readFileSync(mdPath, "utf8");
+    const mdBytes = statSync(mdPath).size;
+    // 4. Build prompt. Chunked mode (header inline + on-disk Read) only
+    //    when BOTH conditions hold:
+    //      (a) md has `manifest_version: 1` (0.7.0+ schema), so the TOC
+    //          is available for Claude to navigate, AND
+    //      (b) file is bigger than CHUNKED_THRESHOLD_BYTES (50 KB). Below
+    //          that, chunked navigation is overhead — full embed is faster
+    //          and gives Claude the whole conversation in one prompt. 0.8.5
+    //          dogfood caught a 33 KB cross-device session getting chunked
+    //          unnecessarily.
+    //    Otherwise (no manifest, or small file) fall back to embedding the
+    //    full md.
+    const headerMd = extractMdHeader(contextMd);
+    const useChunked = headerMd !== null && mdBytes >= CHUNKED_THRESHOLD_BYTES;
+    const prompt = useChunked
+        ? renderResumePromptChunked(entry, mdPath, headerMd, mdBytes)
+        : renderResumePrompt(entry, contextMd);
+    const argv = chooseInvocation(prompt, entry.shortId);
+    // 5. Print or spawn
+    if (opts.print) {
+        console.log(`To continue, run:`);
+        console.log(`  cd ${expectedCwd}`);
+        console.log(`  ${argv.map(shellQuote).join(" ")}`);
+        return { matchedSessionId: entry.sessionId, expectedCwd, mdPath, invocation: argv, spawned: false };
+    }
+    console.log(chalk.green(`\n✓ Matched: "${entry.displayName}"`));
+    console.log(chalk.gray(`  Session id:  ${entry.sessionId}`));
+    console.log(chalk.gray(`  Started:     ${entry.startedAt}`));
+    console.log(chalk.gray(`  Context:     ${(mdBytes / 1024).toFixed(1)} KB ${useChunked ? "(chunked — header inline, body on disk)" : "(full embed)"}`));
+    console.log(chalk.cyan(`\nLaunching claude with context as first prompt...\n`));
+    const r = spawnSync(argv[0], argv.slice(1), {
+        cwd: expectedCwd,
+        stdio: "inherit",
+    });
+    if (r.error) {
+        throw new Error(`Failed to spawn 'claude': ${r.error.message}. ` +
+            `Make sure Claude Code is installed and on your PATH.`);
+    }
+    return { matchedSessionId: entry.sessionId, expectedCwd, mdPath, invocation: argv, spawned: true };
+}
+/** Apply longest-prefix-wins path translation to a single path string. */
+function applyPathMap(path, pathMap) {
+    const entries = Object.entries(pathMap).sort(([a], [b]) => b.length - a.length);
+    for (const [from, to] of entries) {
+        if (path === from)
+            return to;
+        if (path.startsWith(from + "/"))
+            return to + path.slice(from.length);
+    }
+    return path;
+}
+/** Minimal shell-quoting for the --print output. Wraps in single quotes
+ *  and escapes embedded single quotes via the standard close-quote dance. */
+function shellQuote(s) {
+    if (/^[A-Za-z0-9_/.,@:=+-]+$/.test(s))
+        return s;
+    return `'${s.replace(/'/g, `'\\''`)}'`;
+}

package/dist/src/commands/show.js

@@ -0,0 +1,21 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { readConfig } from "../config.js";
+import { loadIndex } from "../index-store.js";
+export async function showCmd(ref) {
+    const cfg = readConfig();
+    const idx = loadIndex(cfg.repoPath);
+    const entries = Object.values(idx.entries);
+    const hit = entries.find((e) => e.sessionId === ref ||
+        e.shortId === ref ||
+        e.nameSlug === ref ||
+        e.displayName === ref);
+    if (!hit) {
+        console.log(chalk.red(`no session matching "${ref}"`));
+        return;
+    }
+    const mdRel = hit.relativePath.replace(/\.raw\.json$/, ".md");
+    const abs = join(cfg.repoPath, mdRel);
+    process.stdout.write(readFileSync(abs).toString("utf8"));
+}