letmecook 0.0.21 → 0.0.22

package/src/cli-mode.ts

@@ -0,0 +1,266 @@
+import { parseRepoSpec, type RepoSpec } from "./types";
+import {
+  listSessions,
+  getSession,
+  updateLastAccessed,
+  deleteAllSessions,
+  deleteSession,
+} from "./sessions";
+import { createRenderer, destroyRenderer } from "./ui/renderer";
+import { showNewSessionPrompt } from "./ui/new-session";
+import { showSessionList } from "./ui/list";
+import { showNukeConfirm } from "./ui/confirm-nuke";
+import { createNewSession, resumeSession } from "./flows";
+
+export function printCLIUsage(): void {
+  console.log(`
+letmecook CLI mode
+
+Usage:
+  letmecook --cli <owner/repo> [owner/repo:branch...] Create or resume a session
+  letmecook --cli --list                              List all sessions
+  letmecook --cli --resume <session-name>             Resume a session
+  letmecook --cli --delete <session-name>             Delete a session
+  letmecook --cli --nuke [--yes]                      Nuke everything
+
+Examples:
+  letmecook --cli microsoft/playwright
+  letmecook --cli facebook/react openai/agents
+  letmecook --cli --resume playwright-agent-tests
+  `);
+}
+
+export async function handleNewSessionCLI(repos: RepoSpec[]): Promise<void> {
+  const renderer = await createRenderer();
+
+  try {
+    const { goal, cancelled } = await showNewSessionPrompt(renderer, repos);
+
+    if (cancelled) {
+      destroyRenderer();
+      console.log("\nCancelled.");
+      return;
+    }
+
+    const result = await createNewSession(renderer, {
+      repos,
+      goal,
+      mode: "cli",
+    });
+
+    if (!result) {
+      destroyRenderer();
+      console.log("\nCancelled.");
+      return;
+    }
+
+    const { session, skipped } = result;
+
+    if (skipped) {
+      destroyRenderer();
+      console.log(`\nResuming existing session: ${session.name}\n`);
+      await resumeSession(renderer, {
+        session,
+        mode: "cli",
+        initialRefresh: true,
+      });
+      return;
+    }
+
+    destroyRenderer();
+    console.log(`\nSession created: ${session.name}`);
+    console.log(`Path: ${session.path}\n`);
+
+    await resumeSession(renderer, {
+      session,
+      mode: "cli",
+      initialRefresh: false,
+    });
+  } catch (error) {
+    destroyRenderer();
+    console.error("\nError:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+export async function handleList(): Promise<void> {
+  const renderer = await createRenderer();
+
+  try {
+    while (true) {
+      const sessions = await listSessions();
+      const action = await showSessionList(renderer, sessions);
+
+      switch (action.type) {
+        case "resume":
+          destroyRenderer();
+          await updateLastAccessed(action.session.name);
+          console.log(`\nResuming session: ${action.session.name}\n`);
+          await resumeSession(renderer, {
+            session: action.session,
+            mode: "cli",
+            initialRefresh: true,
+          });
+          return;
+
+        case "delete":
+          console.log("[TODO] Delete session flow");
+          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":
+          destroyRenderer();
+          return;
+      }
+    }
+  } catch (error) {
+    destroyRenderer();
+    console.error("\nError:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+export async function handleResume(sessionName: string): Promise<void> {
+  const session = await getSession(sessionName);
+
+  if (!session) {
+    console.error(`Session not found: ${sessionName}`);
+    console.log("\nAvailable sessions:");
+    const sessions = await listSessions();
+    if (sessions.length === 0) {
+      console.log("  (none)");
+    } else {
+      sessions.forEach((s) => console.log(`  - ${s.name}`));
+    }
+    process.exit(1);
+  }
+
+  await updateLastAccessed(session.name);
+  console.log(`\nResuming session: ${session.name}\n`);
+
+  const renderer = await createRenderer();
+  await resumeSession(renderer, {
+    session,
+    mode: "cli",
+    initialRefresh: true,
+  });
+}
+
+export 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);
+  }
+}
+
+export 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.");
+  }
+}
+
+export function parseRepos(args: string[]): RepoSpec[] {
+  const repos: RepoSpec[] = [];
+
+  for (const arg of args) {
+    if (!arg || arg.startsWith("-")) continue;
+
+    if (!arg.includes("/")) {
+      throw new Error(`Invalid repo format: ${arg} (expected owner/repo)`);
+    }
+
+    const repo = parseRepoSpec(arg);
+    repos.push(repo);
+  }
+
+  return repos;
+}
+
+export async function handleCLIMode(args: string[]): Promise<void> {
+  const firstArg = args[0];
+
+  if (firstArg === "--list" || firstArg === "-l") {
+    await handleList();
+  } else if (firstArg === "--resume" || firstArg === "-r") {
+    const sessionName = args[1];
+    if (!sessionName) {
+      console.error("Missing session name. Usage: letmecook --cli --resume <session-name>");
+      process.exit(1);
+    }
+    await handleResume(sessionName);
+  } else if (firstArg === "--delete" || firstArg === "-d") {
+    const sessionName = args[1];
+    if (!sessionName) {
+      console.error("Missing session name. Usage: letmecook --cli --delete <session-name>");
+      process.exit(1);
+    }
+    await handleDelete(sessionName);
+  } else if (firstArg === "--nuke") {
+    const hasYes = args.includes("--yes") || args.includes("-y");
+    await handleNuke(hasYes);
+  } else if (!firstArg || firstArg.startsWith("-")) {
+    // No args or unknown flag after --cli
+    if (firstArg?.startsWith("-")) {
+      console.error(`Unknown CLI option: ${firstArg}`);
+    }
+    printCLIUsage();
+    process.exit(firstArg ? 1 : 0);
+  } else {
+    try {
+      const repos = parseRepos(args);
+      if (repos.length === 0) {
+        printCLIUsage();
+        process.exit(1);
+      }
+      await handleNewSessionCLI(repos);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  }
+}

package/src/flows/add-repos.ts

@@ -6,7 +6,6 @@ import { writeAgentsMd } from "../agents-md";
 import { recordRepoHistory } from "../repo-history";
 import { showAddReposPrompt } from "../ui/add-repos";
 import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
-import { ensureReferenceRepo, linkReferenceRepo, ensureReferencesDir } from "../reference-repo";
 import { rm } from "node:fs/promises";
 
 export interface AddReposParams {
@@ -20,10 +19,7 @@ export interface AddReposResult {
 }
 
 function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
-  // Only create command tasks for non-reference repos
-  const regularRepos = repos.filter((repo) => !repo.reference);
-
-  return regularRepos.map((repo) => {
+  return repos.map((repo) => {
     const url = `https://github.com/${repo.owner}/${repo.name}.git`;
     const targetDir = join(sessionPath, repo.dir);
     const args = repo.branch
@@ -49,34 +45,6 @@ function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTas
   });
 }
 
-async function setupReferenceRepos(
-  repos: RepoSpec[],
-  sessionPath: string,
-): Promise<{ successful: RepoSpec[]; failed: Array<{ repo: RepoSpec; error: string }> }> {
-  const referenceRepos = repos.filter((repo) => repo.reference);
-  const successful: RepoSpec[] = [];
-  const failed: Array<{ repo: RepoSpec; error: string }> = [];
-
-  if (referenceRepos.length === 0) {
-    return { successful, failed };
-  }
-
-  await ensureReferencesDir();
-
-  for (const repo of referenceRepos) {
-    try {
-      await ensureReferenceRepo(repo);
-      await linkReferenceRepo(repo, sessionPath);
-      successful.push(repo);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      failed.push({ repo, error: errorMsg });
-    }
-  }
-
-  return { successful, failed };
-}
-
 export async function addReposFlow(params: AddReposParams): Promise<AddReposResult> {
   const { renderer, session } = params;
 
@@ -87,102 +55,70 @@ export async function addReposFlow(params: AddReposParams): Promise<AddReposResu
     const newRepos = addResult.repos.filter((r) => !existingSpecs.has(r.spec));
 
     if (newRepos.length > 0) {
-      // Setup reference repos first (symlinks from cache)
-      const { successful: successfulRefs, failed: failedRefs } = await setupReferenceRepos(
-        newRepos,
-        session.path,
-      );
-
-      // Report reference repo failures
-      if (failedRefs.length > 0) {
-        console.error(`\n⚠️  ${failedRefs.length} reference repo(s) failed:`);
-        failedRefs.forEach(({ repo, error }) => {
-          console.error(`  ✗ ${repo.owner}/${repo.name}: ${error}`);
-        });
-      }
-
-      // Clone regular repos
       const tasks = reposToCommandTasks(newRepos, session.path);
-      let results: Awaited<ReturnType<typeof runCommands>> = [];
-
-      if (tasks.length > 0) {
-        results = await runCommands(renderer, {
-          title: "Adding repositories",
-          tasks,
-          showOutput: true,
-          outputLines: 5,
-          allowAbort: true,
-          allowSkip: tasks.length > 1,
-          allowBackground: true,
-          sessionName: session.name,
-        });
 
-        // Handle aborted operation - return without changes
-        const wasAborted = results.some((r) => r.outcome === "aborted");
-        if (wasAborted) {
-          hideCommandRunner(renderer);
-          // Clean up any partially cloned repos (non-reference only)
-          const regularRepos = newRepos.filter((r) => !r.reference);
-          for (const repo of regularRepos) {
-            const repoPath = join(session.path, repo.dir);
-            try {
-              await rm(repoPath, { recursive: true, force: true });
-            } catch {
-              // Ignore cleanup errors
-            }
-          }
-          // Also clean up reference symlinks
-          for (const repo of successfulRefs) {
-            const repoPath = join(session.path, repo.dir);
-            try {
-              await rm(repoPath, { recursive: true, force: true });
-            } catch {
-              // Ignore cleanup errors
-            }
-          }
-          return { session, cancelled: true };
-        }
+      const results = await runCommands(renderer, {
+        title: "Adding repositories",
+        tasks,
+        showOutput: true,
+        outputLines: 5,
+        allowAbort: true,
+        allowSkip: tasks.length > 1,
+        allowBackground: true,
+        sessionName: session.name,
+      });
 
-        // Clean up skipped repo directories
-        const skippedResults = results.filter((r) => r.outcome === "skipped");
-        for (const skipped of skippedResults) {
-          const repoSpec = skipped.task.label.replace("Cloning ", "");
-          const repo = newRepos.find((r) => `${r.owner}/${r.name}` === repoSpec);
-          if (repo) {
-            const repoPath = join(session.path, repo.dir);
-            try {
-              await rm(repoPath, { recursive: true, force: true });
-            } catch {
-              // Ignore cleanup errors
-            }
+      // Handle aborted operation - return without changes
+      const wasAborted = results.some((r) => r.outcome === "aborted");
+      if (wasAborted) {
+        hideCommandRunner(renderer);
+        // Clean up any partially cloned repos
+        for (const repo of newRepos) {
+          const repoPath = join(session.path, repo.dir);
+          try {
+            await rm(repoPath, { recursive: true, force: true });
+          } catch {
+            // Ignore cleanup errors
           }
         }
+        return { session, cancelled: true };
+      }
 
-        // Check for errors (not skipped/aborted)
-        const errors = results.filter((r) => r.outcome === "error");
-        if (errors.length > 0) {
-          console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
-          errors.forEach((err) => {
-            console.error(`  ✗ ${err.task.label}`);
-            if (err.error) {
-              console.error(`    ${err.error}`);
-            }
-          });
+      // Clean up skipped repo directories
+      const skippedResults = results.filter((r) => r.outcome === "skipped");
+      for (const skipped of skippedResults) {
+        const repoSpec = skipped.task.label.replace("Cloning ", "");
+        const repo = newRepos.find((r) => `${r.owner}/${r.name}` === repoSpec);
+        if (repo) {
+          const repoPath = join(session.path, repo.dir);
+          try {
+            await rm(repoPath, { recursive: true, force: true });
+          } catch {
+            // Ignore cleanup errors
+          }
         }
       }
 
-      await new Promise((resolve) => setTimeout(resolve, 700));
-      hideCommandRunner(renderer);
-
       // Filter to only successfully cloned repos
-      const successfulCloned = newRepos.filter((repo) => {
-        if (repo.reference) return false; // Reference repos handled separately
+      const successfulRepos = newRepos.filter((repo) => {
         const result = results.find((r) => r.task.label === `Cloning ${repo.owner}/${repo.name}`);
         return result?.outcome === "completed";
       });
 
-      // Combine successful reference and cloned repos
-      const successfulRepos = [...successfulRefs, ...successfulCloned];
+      // Check for errors (not skipped/aborted)
+      const errors = results.filter((r) => r.outcome === "error");
+      if (errors.length > 0) {
+        console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
+        errors.forEach((err) => {
+          console.error(`  ✗ ${err.task.label}`);
+          if (err.error) {
+            console.error(`    ${err.error}`);
+          }
+        });
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      hideCommandRunner(renderer);
 
       if (successfulRepos.length > 0) {
         const allRepos = [...session.repos, ...successfulRepos];