letmecook 0.0.19 → 0.0.21

package/index.ts

@@ -2,10 +2,17 @@
 
 import pkg from "./package.json";
 import { parseRepoSpec, type RepoSpec } from "./src/types";
-import { listSessions, getSession, updateLastAccessed, deleteAllSessions } from "./src/sessions";
+import {
+  listSessions,
+  getSession,
+  updateLastAccessed,
+  deleteAllSessions,
+  deleteSession,
+} from "./src/sessions";
 import { createRenderer, destroyRenderer } from "./src/ui/renderer";
 import { showNewSessionPrompt } from "./src/ui/new-session";
 import { showSessionList } from "./src/ui/list";
+import { showNukeConfirm } from "./src/ui/confirm-nuke";
 import { createNewSession, resumeSession } from "./src/flows";
 import { handleTUIMode } from "./src/tui-mode";
 
@@ -19,8 +26,8 @@ Usage:
   letmecook <owner/repo> [owner/repo:branch...] Create or resume a session (CLI)
   letmecook --list                             List all sessions
   letmecook --resume <session-name>            Resume a session
-  letmecook --nuke <session-name>              Delete a session
-  letmecook --nuke-all                         Delete all sessions
+  letmecook --delete <session-name>            Delete a session
+  letmecook --nuke [--yes]                     Nuke everything
   letmecook --why                              Show why this tool exists
   letmecook --help                             Show this help
   letmecook --version                          Show version
@@ -124,11 +131,16 @@ async function handleList(): Promise<void> {
           console.log("[TODO] Delete session flow");
           break;
 
-        case "nuke-all":
-          const count = await deleteAllSessions();
-          destroyRenderer();
-          console.log(`\nNuked ${count} session(s).`);
-          return;
+        case "nuke": {
+          const choice = await showNukeConfirm(renderer, sessions.length);
+          if (choice === "confirm") {
+            const count = await deleteAllSessions();
+            destroyRenderer();
+            console.log(`\nNuked ${count} session(s) and all data.`);
+            return;
+          }
+          break;
+        }
 
         case "quit":
           destroyRenderer();
@@ -168,13 +180,52 @@ async function handleResume(sessionName: string): Promise<void> {
   });
 }
 
-async function handleNuke(_sessionName: string): Promise<void> {
-  console.log("[TODO] Nuke session flow");
+async function handleDelete(sessionName: string): Promise<void> {
+  const session = await getSession(sessionName);
+
+  if (!session) {
+    console.error(`Session not found: ${sessionName}`);
+    const sessions = await listSessions();
+    if (sessions.length > 0) {
+      console.log("\nAvailable sessions:");
+      sessions.forEach((s) => console.log(`  - ${s.name}`));
+    }
+    process.exit(1);
+  }
+
+  const deleted = await deleteSession(sessionName);
+  if (deleted) {
+    console.log(`Deleted session: ${sessionName}`);
+  } else {
+    console.error(`Failed to delete session: ${sessionName}`);
+    process.exit(1);
+  }
 }
 
-async function handleNukeAll(): Promise<void> {
-  const count = await deleteAllSessions();
-  console.log(`Nuked ${count} session(s).`);
+async function handleNuke(skipConfirm = false): Promise<void> {
+  const sessions = await listSessions();
+  if (sessions.length === 0) {
+    console.log("Nothing to nuke.");
+    return;
+  }
+
+  // Skip confirmation if --yes flag or non-interactive (piped input)
+  if (skipConfirm || !process.stdin.isTTY) {
+    const count = await deleteAllSessions();
+    console.log(`Nuked ${count} session(s) and all data.`);
+    return;
+  }
+
+  const renderer = await createRenderer();
+  const choice = await showNukeConfirm(renderer, sessions.length);
+  destroyRenderer();
+
+  if (choice === "confirm") {
+    const count = await deleteAllSessions();
+    console.log(`Nuked ${count} session(s) and all data.`);
+  } else {
+    console.log("Cancelled.");
+  }
 }
 
 async function handleCLIMode(args: string[]): Promise<void> {
@@ -189,15 +240,16 @@ async function handleCLIMode(args: string[]): Promise<void> {
       process.exit(1);
     }
     await handleResume(sessionName);
-  } else if (firstArg === "--nuke") {
+  } else if (firstArg === "--delete" || firstArg === "-d") {
     const sessionName = args[1];
     if (!sessionName) {
-      console.error("Missing session name. Usage: letmecook --nuke <session-name>");
+      console.error("Missing session name. Usage: letmecook --delete <session-name>");
       process.exit(1);
     }
-    await handleNuke(sessionName);
-  } else if (firstArg === "--nuke-all") {
-    await handleNukeAll();
+    await handleDelete(sessionName);
+  } else if (firstArg === "--nuke") {
+    const hasYes = args.includes("--yes") || args.includes("-y");
+    await handleNuke(hasYes);
   } else if (firstArg?.startsWith("-")) {
     console.error(`Unknown option: ${firstArg}`);
     printUsage();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecook",
-  "version": "0.0.19",
+  "version": "0.0.21",
   "repository": {
     "type": "git",
     "url": "https://github.com/rustydotwtf/letmecook.git"

package/src/sessions.ts

@@ -191,7 +191,8 @@ export async function deleteAllSessions(): Promise<number> {
   const count = sessions.length;
 
   try {
-    await rm(SESSIONS_DIR, { recursive: true, force: true });
+    // Nuke entire .letmecook directory including SQLite history
+    await rm(LETMECOOK_DIR, { recursive: true, force: true });
     return count;
   } catch {
     return 0;

package/src/tui-mode.ts

@@ -9,10 +9,17 @@ import { showMainMenu } from "./ui/main-menu";
 import { showSessionDetails } from "./ui/session-details";
 import { showSessionSettings } from "./ui/session-settings";
 import { showDeleteConfirm } from "./ui/confirm-delete";
+import { showNukeConfirm } from "./ui/confirm-nuke";
 import { showQuitWarning } from "./ui/background-warning";
 import type { Session } from "./types";
 import { createNewSession, resumeSession } from "./flows";
-import { listSessions, deleteSession, updateLastAccessed, updateSessionSettings } from "./sessions";
+import {
+  listSessions,
+  deleteSession,
+  deleteAllSessions,
+  updateLastAccessed,
+  updateSessionSettings,
+} from "./sessions";
 import { getRunningProcesses, killAllProcesses } from "./process-registry";
 
 export async function handleTUIMode(): Promise<void> {
@@ -41,6 +48,17 @@ export async function handleTUIMode(): Promise<void> {
           break;
         }
 
+        case "nuke": {
+          const choice = await showNukeConfirm(renderer, sessions.length);
+          if (choice === "confirm") {
+            const count = await deleteAllSessions();
+            destroyRenderer();
+            console.log(`\nNuked ${count} session(s) and all data.`);
+            return;
+          }
+          break;
+        }
+
         case "quit": {
           const runningProcesses = await getRunningProcesses();
           if (runningProcesses.length > 0) {

package/src/ui/confirm-nuke.ts

@@ -0,0 +1,95 @@
+import {
+  type CliRenderer,
+  TextRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type KeyEvent,
+} from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import { showFooter, hideFooter } from "./common/footer";
+import { isEscape } from "./common/keyboard";
+
+export type NukeConfirmChoice = "confirm" | "cancel";
+
+export function showNukeConfirm(
+  renderer: CliRenderer,
+  sessionCount: number,
+): Promise<NukeConfirmChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Delete all sessions");
+
+    const countInfo = new TextRenderable(renderer, {
+      id: "count-info",
+      content: `${sessionCount} session${sessionCount === 1 ? "" : "s"} will be deleted`,
+      fg: "#38bdf8",
+      marginBottom: 1,
+    });
+    content.add(countInfo);
+
+    const warning = new TextRenderable(renderer, {
+      id: "warning",
+      content: "This permanently deletes all sessions, history, and data.",
+      fg: "#f59e0b",
+      marginBottom: 1,
+    });
+    content.add(warning);
+
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "Are you sure you want to delete all sessions?",
+      fg: "#e2e8f0",
+    });
+    content.add(question);
+
+    const select = new SelectRenderable(renderer, {
+      id: "nuke-confirm-select",
+      width: 38,
+      height: 2,
+      options: [
+        { name: "Cancel", description: "", value: "cancel" },
+        { name: "Delete all sessions", description: "", value: "confirm" },
+      ],
+      showDescription: false,
+      backgroundColor: "transparent",
+      focusedBackgroundColor: "transparent",
+      selectedBackgroundColor: "#334155",
+      textColor: "#e2e8f0",
+      selectedTextColor: "#38bdf8",
+      marginTop: 1,
+    });
+    content.add(select);
+
+    select.focus();
+
+    const handleSelect = (_index: number, option: { value: string }) => {
+      cleanup();
+      resolve(option.value as NukeConfirmChoice);
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (isEscape(key)) {
+        cleanup();
+        resolve("cancel");
+      }
+    };
+
+    const cleanup = () => {
+      select.off(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+      renderer.keyInput.off("keypress", handleKeypress);
+      select.blur();
+      hideFooter(renderer);
+      clearLayout(renderer);
+    };
+
+    showFooter(renderer, content, {
+      navigate: true,
+      select: true,
+      back: true,
+    });
+
+    select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}

package/src/ui/list.ts

@@ -14,7 +14,7 @@ import { isEscape, isArrowUp, isArrowDown } from "./common/keyboard";
 export type ListAction =
   | { type: "resume"; session: Session }
   | { type: "delete"; session: Session }
-  | { type: "nuke-all" }
+  | { type: "nuke" }
   | { type: "quit" };
 
 export function showSessionList(renderer: CliRenderer, sessions: Session[]): Promise<ListAction> {
@@ -93,7 +93,7 @@ export function showSessionList(renderer: CliRenderer, sessions: Session[]): Pro
         }
       } else if (key.name === "a") {
         cleanup();
-        resolve({ type: "nuke-all" });
+        resolve({ type: "nuke" });
       } else if (key.name === "q" || isEscape(key)) {
         cleanup();
         resolve({ type: "quit" });
@@ -112,7 +112,7 @@ export function showSessionList(renderer: CliRenderer, sessions: Session[]): Pro
       navigate: true,
       select: false,
       back: false,
-      custom: ["Enter Resume", "d Delete", "a Nuke All", "q Quit"],
+      custom: ["Enter Resume", "d Delete", "a Nuke", "q Quit"],
     });
 
     select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);

package/src/ui/main-menu.ts

@@ -15,6 +15,7 @@ export type MainMenuAction =
   | { type: "new-session" }
   | { type: "resume"; session: Session }
   | { type: "delete"; session: Session }
+  | { type: "nuke" }
   | { type: "quit" };
 
 export function showMainMenu(renderer: CliRenderer, sessions: Session[]): Promise<MainMenuAction> {
@@ -94,6 +95,12 @@ export function showMainMenu(renderer: CliRenderer, sessions: Session[]): Promis
         return;
       }
 
+      if (key.name === "a" && sessions.length > 0) {
+        cleanup();
+        resolve({ type: "nuke" });
+        return;
+      }
+
       if (key.name === "q" || isEscape(key)) {
         cleanup();
         resolve({ type: "quit" });
@@ -113,7 +120,7 @@ export function showMainMenu(renderer: CliRenderer, sessions: Session[]): Promis
     // Show footer with context-aware actions
     const footerActions: string[] = [];
     if (sessions.length > 0) {
-      footerActions.push("Enter Open", "n New", "d Delete");
+      footerActions.push("Enter Open", "n New", "d Delete", "a Nuke");
     } else {
       footerActions.push("n New");
     }