code-session-memory 0.4.4 → 0.7.0

package/dist/src/cli-sessions.js

@@ -3,12 +3,10 @@
 /**
  * sessions sub-commands for code-session-memory CLI
  *
- *   sessions [list]              Browse sessions (interactive TUI)
- *   sessions list --filter       Browse with filter step first
+ *   sessions [list]              Browse sessions (3-level tree: source → date → session)
  *   sessions print [id]          Print all chunks of a session to stdout
- *   sessions print --filter      Pick session interactively with filter, then print
  *   sessions delete [id]         Delete a session from the DB
- *   sessions delete --filter     Pick session interactively with filter, then delete
+ *   sessions purge [--days <n>] [--yes]  Delete all sessions older than N days
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -47,6 +45,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdSessionsList = cmdSessionsList;
 exports.cmdSessionsPrint = cmdSessionsPrint;
 exports.cmdSessionsDelete = cmdSessionsDelete;
+exports.cmdSessionsPurge = cmdSessionsPurge;
 exports.cmdSessions = cmdSessions;
 const clack = __importStar(require("@clack/prompts"));
 const database_1 = require("./database");
@@ -66,7 +65,11 @@ function fmtDate(unixMs) {
     return new Date(unixMs).toISOString().slice(0, 10);
 }
 function fmtSource(source) {
-    return source === "opencode" ? cyan("opencode") : yellow("claude-code");
+    if (source === "opencode")
+        return cyan("opencode");
+    if (source === "cursor")
+        return green("cursor");
+    return yellow("claude-code");
 }
 function fmtTitle(title) {
     return title || dim("(untitled)");
@@ -77,11 +80,14 @@ function fmtProject(project) {
     const parts = project.replace(/\\/g, "/").split("/").filter(Boolean);
     return parts.length > 2 ? dim("…/" + parts.slice(-2).join("/")) : dim(project);
 }
+function fmtChunks(n) {
+    return `${n} chunk${n !== 1 ? "s" : ""}`;
+}
 function hr(char = "─", width = 72) {
     return char.repeat(width);
 }
 // ---------------------------------------------------------------------------
-// DB helpers (open/close around each command)
+// DB helpers
 // ---------------------------------------------------------------------------
 function withDb(fn) {
     const dbPath = (0, database_1.resolveDbPath)();
@@ -94,129 +100,131 @@ function withDb(fn) {
     }
 }
 // ---------------------------------------------------------------------------
-// Label builder for the session picker
+// Label builders
 // ---------------------------------------------------------------------------
 function sessionLabel(s) {
-    const date = fmtDate(s.updated_at);
-    const chunks = `${s.chunk_count} chunk${s.chunk_count !== 1 ? "s" : ""}`;
+    const chunks = fmtChunks(s.chunk_count);
     const title = fmtTitle(s.session_title).padEnd(40);
-    return `${title}  ${date}  ${chunks}`;
+    return `${title}  ${chunks}`;
 }
 function sessionHint(s) {
     return `${fmtSource(s.source)}  ${fmtProject(s.project)}`;
 }
-// ---------------------------------------------------------------------------
-// Filter step (shown when --filter flag is present)
-// ---------------------------------------------------------------------------
-async function runFilterStep() {
-    clack.intro(bold("Filter sessions"));
-    const sourceAnswer = await clack.select({
-        message: "Source",
-        options: [
-            { value: "all", label: "All tools" },
-            { value: "opencode", label: "OpenCode" },
-            { value: "claude-code", label: "Claude Code" },
-        ],
-        initialValue: "all",
-    });
-    if (clack.isCancel(sourceAnswer)) {
-        clack.cancel("Cancelled.");
-        process.exit(0);
+async function pickSessionTree(allSessions) {
+    if (allSessions.length === 0)
+        return null;
+    // ── Level 1: choose source ──────────────────────────────────────────────
+    // Group by source, count sessions + chunks
+    const sourceMap = new Map();
+    for (const s of allSessions) {
+        if (!sourceMap.has(s.source))
+            sourceMap.set(s.source, []);
+        sourceMap.get(s.source).push(s);
     }
-    const dateAnswer = await clack.select({
-        message: "Date range",
-        options: [
-            { value: "all", label: "All time" },
-            { value: "7d", label: "Last 7 days" },
-            { value: "30d", label: "Last 30 days" },
-            { value: "90d", label: "Last 90 days" },
-            { value: "recent", label: "Last N days", hint: "enter a number" },
-            { value: "older", label: "Older than N days", hint: "enter a number" },
-        ],
-        initialValue: "all",
+    // Sort sources by session count descending
+    const sources = [...sourceMap.entries()].sort((a, b) => b[1].length - a[1].length);
+    const sourceOptions = [
+        ...sources.map(([src, rows]) => ({
+            value: src,
+            label: sourceLabelText(src),
+            hint: `${rows.length} session${rows.length !== 1 ? "s" : ""}  ${fmtChunks(rows.reduce((n, r) => n + r.chunk_count, 0))}`,
+        })),
+        { value: "__all__", label: dim("All sessions"), hint: `${allSessions.length} total` },
+        { value: "__exit__", label: dim("Exit") },
+    ];
+    const srcChoice = await clack.select({
+        message: "Source",
+        options: sourceOptions,
+        maxItems: 8,
     });
-    if (clack.isCancel(dateAnswer)) {
-        clack.cancel("Cancelled.");
-        process.exit(0);
-    }
-    const filter = {};
-    if (sourceAnswer !== "all") {
-        filter.source = sourceAnswer;
-    }
-    const nowMs = Date.now();
-    const DAY_MS = 86400 * 1000;
-    if (dateAnswer === "7d") {
-        filter.fromDate = nowMs - 7 * DAY_MS;
-    }
-    else if (dateAnswer === "30d") {
-        filter.fromDate = nowMs - 30 * DAY_MS;
-    }
-    else if (dateAnswer === "90d") {
-        filter.fromDate = nowMs - 90 * DAY_MS;
+    if (clack.isCancel(srcChoice) || srcChoice === "__exit__")
+        return null;
+    const filteredBySrc = srcChoice === "__all__" ? allSessions : sourceMap.get(srcChoice);
+    // ── Level 2: choose date (skip if only one date or "All sessions") ──────
+    let filteredByDate;
+    if (srcChoice === "__all__") {
+        // Skip date level — go straight to all sessions
+        filteredByDate = filteredBySrc;
     }
-    else if (dateAnswer === "recent") {
-        const nAnswer = await clack.text({
-            message: "Show sessions from the last how many days?",
-            placeholder: "14",
-            validate(v) {
-                if (!v || isNaN(Number(v)) || Number(v) <= 0)
-                    return "Please enter a positive number.";
-            },
-        });
-        if (clack.isCancel(nAnswer)) {
-            clack.cancel("Cancelled.");
-            process.exit(0);
+    else {
+        // Group by YYYY-MM-DD
+        const dateMap = new Map();
+        for (const s of filteredBySrc) {
+            const d = fmtDate(s.updated_at);
+            if (!dateMap.has(d))
+                dateMap.set(d, []);
+            dateMap.get(d).push(s);
         }
-        filter.fromDate = nowMs - Number(nAnswer) * DAY_MS;
-    }
-    else if (dateAnswer === "older") {
-        const nAnswer = await clack.text({
-            message: "Show sessions older than how many days?",
-            placeholder: "30",
-            validate(v) {
-                if (!v || isNaN(Number(v)) || Number(v) <= 0)
-                    return "Please enter a positive number.";
-            },
-        });
-        if (clack.isCancel(nAnswer)) {
-            clack.cancel("Cancelled.");
-            process.exit(0);
+        if (dateMap.size === 1) {
+            // Only one date — skip level 2
+            filteredByDate = filteredBySrc;
+        }
+        else {
+            const dates = [...dateMap.entries()].sort((a, b) => b[0].localeCompare(a[0]));
+            const dateOptions = [
+                ...dates.map(([date, rows]) => ({
+                    value: date,
+                    label: date,
+                    hint: `${rows.length} session${rows.length !== 1 ? "s" : ""}`,
+                })),
+                { value: "__back__", label: dim("Back") },
+            ];
+            const dateChoice = await clack.select({
+                message: `Date  ${dim("(" + sourceLabelText(srcChoice) + ")")}`,
+                options: dateOptions,
+                maxItems: 10,
+            });
+            if (clack.isCancel(dateChoice) || dateChoice === "__back__") {
+                // Go back to level 1
+                return pickSessionTree(allSessions);
+            }
+            filteredByDate = dateMap.get(dateChoice);
         }
-        filter.toDate = nowMs - Number(nAnswer) * DAY_MS;
-    }
-    return filter;
-}
-// ---------------------------------------------------------------------------
-// Shared session picker
-// Returns the chosen SessionRow, or null if the user cancelled / exited.
-// When withFilter is true, runs the filter step first.
-// ---------------------------------------------------------------------------
-async function pickSession(withFilter) {
-    let filter = {};
-    if (withFilter) {
-        filter = await runFilterStep();
-        console.log();
-    }
-    const sessions = withDb((db) => (0, database_2.listSessions)(db, filter));
-    if (sessions.length === 0) {
-        clack.log.warn("No sessions match the current filter.");
-        return null;
     }
-    const chosen = await clack.select({
-        message: `${sessions.length} session${sessions.length !== 1 ? "s" : ""}${withFilter ? dim("  (filtered)") : ""}  — pick one`,
-        options: [
-            ...sessions.map((s) => ({
-                value: s.session_id,
-                label: sessionLabel(s),
-                hint: sessionHint(s),
-            })),
-            { value: "__cancel__", label: dim("Cancel") },
-        ],
+    // ── Level 3: choose session ──────────────────────────────────────────────
+    const sessionOptions = [
+        ...filteredByDate.map((s) => ({
+            value: s.session_id,
+            label: sessionLabel(s),
+            hint: sessionHint(s),
+        })),
+        { value: "__back__", label: dim("Back") },
+    ];
+    const backLabel = srcChoice === "__all__"
+        ? "Source"
+        : dateMap_size(filteredBySrc) === 1 ? "Source" : "Date";
+    const sessionOptions2 = sessionOptions.map((o) => o.value === "__back__" ? { ...o, hint: `back to ${backLabel}` } : o);
+    const sessionChoice = await clack.select({
+        message: srcChoice === "__all__"
+            ? `Session  ${dim("(all sources)")}`
+            : `Session  ${dim("(" + sourceLabelText(srcChoice) + ")")}`,
+        options: sessionOptions2,
         maxItems: 12,
     });
-    if (clack.isCancel(chosen) || chosen === "__cancel__")
-        return null;
-    return sessions.find((s) => s.session_id === chosen) ?? null;
+    if (clack.isCancel(sessionChoice) || sessionChoice === "__back__") {
+        if (srcChoice === "__all__" || dateMap_size(filteredBySrc) === 1) {
+            // Back to level 1
+            return pickSessionTree(allSessions);
+        }
+        // Back to level 2 — re-run from source choice but pre-select the date level
+        // Simplest: restart from level 1 (preserves the loop invariant)
+        return pickSessionTree(allSessions);
+    }
+    return filteredByDate.find((s) => s.session_id === sessionChoice) ?? null;
+}
+// Helper: plain text source label (no ANSI) for use in hints/messages
+function sourceLabelText(source) {
+    if (source === "opencode")
+        return "OpenCode";
+    if (source === "cursor")
+        return "Cursor";
+    if (source === "claude-code")
+        return "Claude Code";
+    return source;
+}
+// Helper to count unique dates in a session list without capturing dateMap
+function dateMap_size(sessions) {
+    return new Set(sessions.map((s) => fmtDate(s.updated_at))).size;
 }
 // ---------------------------------------------------------------------------
 // Action loop for a selected session (used by sessions list)
@@ -225,7 +233,7 @@ async function sessionActionLoop(session) {
     while (true) {
         clack.log.message([
             `${bold(fmtTitle(session.session_title))}`,
-            `${fmtSource(session.source)}  ${fmtDate(session.updated_at)}  ${session.chunk_count} chunks`,
+            `${fmtSource(session.source)}  ${fmtDate(session.updated_at)}  ${fmtChunks(session.chunk_count)}`,
             `Project: ${session.project || dim("—")}`,
             `ID: ${dim(session.session_id)}`,
         ].join("\n"), { symbol: "○" });
@@ -246,7 +254,7 @@ async function sessionActionLoop(session) {
         }
         if (action === "delete") {
             const confirmed = await clack.confirm({
-                message: `Delete "${fmtTitle(session.session_title)}" (${session.chunk_count} chunks)?`,
+                message: `Delete "${fmtTitle(session.session_title)}" (${fmtChunks(session.chunk_count)})?`,
                 initialValue: false,
             });
             if (clack.isCancel(confirmed) || !confirmed) {
@@ -263,59 +271,44 @@ async function sessionActionLoop(session) {
 // ---------------------------------------------------------------------------
 // sessions list
 // ---------------------------------------------------------------------------
-async function cmdSessionsList(args) {
-    const withFilter = args.includes("--filter");
-    if (!withFilter) {
-        clack.intro(bold("Sessions"));
-    }
-    // Main browse loop — re-shown after back/delete so the user can keep browsing
-    let filter = {};
-    let filterResolved = false;
+async function cmdSessionsList() {
+    clack.intro(bold("Sessions"));
     while (true) {
-        // Run filter step once (first iteration only, if --filter was passed)
-        if (withFilter && !filterResolved) {
-            filter = await runFilterStep();
-            filterResolved = true;
-            console.log();
-        }
-        const sessions = withDb((db) => (0, database_2.listSessions)(db, filter));
+        const sessions = withDb((db) => (0, database_2.listSessions)(db));
         if (sessions.length === 0) {
-            clack.log.warn("No sessions match the current filter.");
+            clack.log.warn("No sessions indexed yet.");
             clack.outro("Done.");
             return;
         }
-        const chosen = await clack.select({
-            message: `${sessions.length} session${sessions.length !== 1 ? "s" : ""}  ${withFilter ? dim("(filtered)") : ""}`,
-            options: [
-                ...sessions.map((s) => ({
-                    value: s.session_id,
-                    label: sessionLabel(s),
-                    hint: sessionHint(s),
-                })),
-                { value: "__exit__", label: dim("Exit") },
-            ],
-            maxItems: 12,
-        });
-        if (clack.isCancel(chosen) || chosen === "__exit__") {
+        const session = await pickSessionTree(sessions);
+        if (!session) {
             clack.outro("Done.");
             return;
         }
-        const session = sessions.find((s) => s.session_id === chosen);
         const result = await sessionActionLoop(session);
         if (result === "exit")
             return;
-        // result === "back" → loop again, refresh session list
+        // result === "back" → loop, refresh session list and restart tree
+    }
+}
+// ---------------------------------------------------------------------------
+// Shared session picker (for print / delete sub-commands)
+// ---------------------------------------------------------------------------
+async function pickSession() {
+    const sessions = withDb((db) => (0, database_2.listSessions)(db));
+    if (sessions.length === 0) {
+        clack.log.warn("No sessions indexed yet.");
+        return null;
     }
+    return pickSessionTree(sessions);
 }
 // ---------------------------------------------------------------------------
 // sessions print [id]
 // ---------------------------------------------------------------------------
-async function cmdSessionsPrint(sessionId, args = []) {
-    const withFilter = args.includes("--filter");
+async function cmdSessionsPrint(sessionId) {
     if (!sessionId) {
-        // No ID given — launch interactive picker
         clack.intro(bold("Print session"));
-        const session = await pickSession(withFilter);
+        const session = await pickSession();
         if (!session) {
             clack.outro("Cancelled.");
             return;
@@ -340,15 +333,18 @@ function printSession(sessionId) {
     const useTty = process.stdout.isTTY;
     const b = (s) => useTty ? bold(s) : s;
     const d = (s) => useTty ? dim(s) : s;
-    const c = (s) => useTty ? cyan(s) : s;
-    const y = (s) => useTty ? yellow(s) : s;
+    const fmtSrc = (src) => {
+        if (!useTty)
+            return src;
+        return fmtSource(src);
+    };
     const title = session?.session_title || "(untitled)";
     const source = session?.source || "unknown";
     const date = session ? fmtDate(session.updated_at) : "unknown";
     const project = session?.project || "—";
     console.log(hr());
     console.log(`${b("Session:")} ${title}`);
-    console.log(`${b("Source:")}  ${source === "opencode" ? c(source) : y(source)}  ${d(date)}`);
+    console.log(`${b("Source:")}  ${fmtSrc(source)}  ${d(date)}`);
     console.log(`${b("Project:")} ${project}`);
     console.log(`${b("ID:")}      ${d(sessionId)}`);
     console.log(`${b("Chunks:")}  ${chunks.length}`);
@@ -367,13 +363,11 @@ function printSession(sessionId) {
 // ---------------------------------------------------------------------------
 // sessions delete [id]
 // ---------------------------------------------------------------------------
-async function cmdSessionsDelete(sessionId, args = []) {
-    const withFilter = args.includes("--filter");
+async function cmdSessionsDelete(sessionId) {
     clack.intro(bold("Delete session"));
     let session = null;
     if (!sessionId) {
-        // No ID given — launch interactive picker
-        session = await pickSession(withFilter);
+        session = await pickSession();
         if (!session) {
             clack.outro("Cancelled.");
             return;
@@ -391,12 +385,12 @@ async function cmdSessionsDelete(sessionId, args = []) {
     }
     clack.log.message([
         `${bold(fmtTitle(session.session_title))}`,
-        `${fmtSource(session.source)}  ${fmtDate(session.updated_at)}  ${session.chunk_count} chunks`,
+        `${fmtSource(session.source)}  ${fmtDate(session.updated_at)}  ${fmtChunks(session.chunk_count)}`,
         `Project: ${session.project || dim("—")}`,
         `ID: ${dim(session.session_id)}`,
     ].join("\n"), { symbol: "○" });
     const confirmed = await clack.confirm({
-        message: `Delete this session (${session.chunk_count} chunks)?`,
+        message: `Delete this session (${fmtChunks(session.chunk_count)})?`,
         initialValue: false,
     });
     if (clack.isCancel(confirmed) || !confirmed) {
@@ -409,6 +403,78 @@ async function cmdSessionsDelete(sessionId, args = []) {
     clack.outro("Done.");
 }
 // ---------------------------------------------------------------------------
+// sessions purge [--days <n>] [--yes]
+// ---------------------------------------------------------------------------
+async function cmdSessionsPurge(args) {
+    const DAY_MS = 86400 * 1000;
+    // Parse --days <n>
+    let days;
+    const daysIdx = args.indexOf("--days");
+    if (daysIdx !== -1 && args[daysIdx + 1]) {
+        const parsed = Number(args[daysIdx + 1]);
+        if (!Number.isInteger(parsed) || parsed <= 0) {
+            console.error("--days must be a positive integer");
+            process.exit(1);
+        }
+        days = parsed;
+    }
+    const skipConfirm = args.includes("--yes");
+    if (!skipConfirm) {
+        clack.intro(bold("Purge old sessions"));
+    }
+    // Prompt for days if not provided
+    if (days === undefined) {
+        const answer = await clack.text({
+            message: "Delete sessions older than how many days?",
+            placeholder: "30",
+            validate(v) {
+                const n = Number(v);
+                if (!v || !Number.isInteger(n) || n <= 0)
+                    return "Please enter a positive integer.";
+            },
+        });
+        if (clack.isCancel(answer)) {
+            clack.cancel("Cancelled.");
+            return;
+        }
+        days = Number(answer);
+    }
+    const cutoff = Date.now() - days * DAY_MS;
+    const candidates = withDb((db) => (0, database_2.listSessions)(db, { toDate: cutoff }));
+    if (candidates.length === 0) {
+        const msg = `No sessions older than ${days} day${days !== 1 ? "s" : ""} found.`;
+        if (skipConfirm) {
+            console.log(msg);
+        }
+        else {
+            clack.log.info(msg);
+            clack.outro("Nothing to purge.");
+        }
+        return;
+    }
+    const totalChunks = candidates.reduce((n, s) => n + s.chunk_count, 0);
+    const summary = `${candidates.length} session${candidates.length !== 1 ? "s" : ""} (${totalChunks} chunks) older than ${days} day${days !== 1 ? "s" : ""}`;
+    if (skipConfirm) {
+        // Non-interactive: just do it
+        const result = withDb((db) => (0, database_2.deleteSessionsOlderThan)(db, cutoff));
+        console.log(`Deleted ${result.sessions} sessions (${result.chunks} chunks).`);
+        return;
+    }
+    clack.log.warn(`Found ${summary}.`);
+    const confirmed = await clack.confirm({
+        message: `Permanently delete ${summary}?`,
+        initialValue: false,
+    });
+    if (clack.isCancel(confirmed) || !confirmed) {
+        clack.cancel("Purge cancelled — database was not modified.");
+        return;
+    }
+    const result = withDb((db) => (0, database_2.deleteSessionsOlderThan)(db, cutoff));
+    clack.log.success(`Deleted ${result.sessions} sessions (${result.chunks} chunks).`);
+    clack.log.warn("Note: sessions will be re-indexed on the next agent turn if source files still exist.");
+    clack.outro("Done.");
+}
+// ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
 function sessionsHelp() {
@@ -417,22 +483,18 @@ function sessionsHelp() {
 ${b("sessions")} — Browse, inspect, and delete indexed sessions
 
 ${b("Usage:")}
-  npx code-session-memory sessions                Browse sessions interactively
-  npx code-session-memory sessions --filter       Apply source/date filters before browsing
+  npx code-session-memory sessions                Browse sessions (tree: source → date → session)
   npx code-session-memory sessions list           Same as above (explicit sub-command)
-  npx code-session-memory sessions list --filter  Same with filter step
 
   npx code-session-memory sessions print          Pick a session interactively, then print
-  npx code-session-memory sessions print --filter Pick with filter, then print
   npx code-session-memory sessions print <id>     Print all chunks of a session directly
 
   npx code-session-memory sessions delete         Pick a session interactively, then delete
-  npx code-session-memory sessions delete --filter Pick with filter, then delete
   npx code-session-memory sessions delete <id>    Delete a session directly
 
-${b("Filter options")} (with --filter):
-  Source:     All tools / OpenCode / Claude Code
-  Date range: Last 7 / 30 / 90 days, last N days (custom), older than N days (custom)
+  npx code-session-memory sessions purge          Delete sessions older than N days (interactive)
+  npx code-session-memory sessions purge --days <n>         Non-interactive, prompts for confirmation
+  npx code-session-memory sessions purge --days <n> --yes   Fully non-interactive (no confirmation)
 
 ${b("Notes:")}
   - Deleting a session only removes it from the DB. If the source files still
@@ -441,36 +503,34 @@ ${b("Notes:")}
 `);
 }
 // ---------------------------------------------------------------------------
-// Entry point: dispatch sessions sub-commands
+// Entry point
 // ---------------------------------------------------------------------------
 async function cmdSessions(argv) {
     const sub = argv[0] ?? "list";
-    // Help flag anywhere in argv
     if (argv.includes("--help") || argv.includes("-h")) {
         sessionsHelp();
         return;
     }
     switch (sub) {
         case "list":
-            await cmdSessionsList(argv.slice(1));
+            await cmdSessionsList();
             break;
         case "print": {
-            // argv[1] is either an ID or a flag (--filter) or absent
             const maybeId = argv[1] && !argv[1].startsWith("-") ? argv[1] : undefined;
-            const restArgs = maybeId ? argv.slice(2) : argv.slice(1);
-            await cmdSessionsPrint(maybeId, restArgs);
+            await cmdSessionsPrint(maybeId);
             break;
         }
         case "delete": {
             const maybeId = argv[1] && !argv[1].startsWith("-") ? argv[1] : undefined;
-            const restArgs = maybeId ? argv.slice(2) : argv.slice(1);
-            await cmdSessionsDelete(maybeId, restArgs);
+            await cmdSessionsDelete(maybeId);
             break;
         }
+        case "purge":
+            await cmdSessionsPurge(argv.slice(1));
+            break;
         default:
-            // Treat unknown first arg as implicit "list" (e.g. `sessions --filter`)
             if (sub.startsWith("-")) {
-                await cmdSessionsList(argv);
+                await cmdSessionsList();
             }
             else {
                 console.error(`Unknown sessions sub-command: ${sub}`);