letmecook 0.0.14 → 0.0.16

package/src/ui/common/command-runner.ts

@@ -1,6 +1,9 @@
-import { type CliRenderer, TextRenderable } from "@opentui/core";
+import { type CliRenderer, TextRenderable, type Renderable, type KeyEvent } from "@opentui/core";
 import { createBaseLayout, clearLayout } from "../renderer";
-import { readProcessOutputWithBuffer } from "../../utils/stream";
+import { readProcessOutputWithControl } from "../../utils/stream";
+import { showFooter, hideFooter } from "./footer";
+import { isAbort, isSkip, isBackground } from "./keyboard";
+import { registerBackgroundProcess } from "../../process-registry";
 
 export interface CommandTask {
   label: string; // "Cloning microsoft/playwright"
@@ -13,14 +16,21 @@ export interface CommandRunnerOptions {
   tasks: CommandTask[]; // Array of commands to run
   showOutput?: boolean; // Show last N lines (default: true)
   outputLines?: number; // How many lines to show (default: 5)
+  allowAbort?: boolean; // Show 'a' Abort
+  allowSkip?: boolean; // Show 's' Skip (multi-task only)
+  allowBackground?: boolean; // Show 'b' Background
+  sessionName?: string; // Session name for tracking backgrounded processes
 }
 
+export type TaskOutcome = "completed" | "error" | "aborted" | "skipped" | "backgrounded";
+
 export interface CommandResult {
   task: CommandTask;
   success: boolean;
   exitCode: number;
   output: string[];
   error?: string;
+  outcome: TaskOutcome;
 }
 
 let taskTexts: TextRenderable[] = [];
@@ -28,7 +38,16 @@ let currentCommandText: TextRenderable | null = null;
 let outputText: TextRenderable | null = null;
 let tasksLabel: TextRenderable | null = null;
 
-function getStatusIcon(status: "pending" | "running" | "done" | "error"): {
+export type TaskStatus =
+  | "pending"
+  | "running"
+  | "done"
+  | "error"
+  | "aborted"
+  | "skipped"
+  | "backgrounded";
+
+function getStatusIcon(status: TaskStatus): {
   icon: string;
   color: string;
 } {
@@ -39,6 +58,12 @@ function getStatusIcon(status: "pending" | "running" | "done" | "error"): {
       return { icon: "[~]", color: "#fbbf24" };
     case "error":
       return { icon: "[✗]", color: "#ef4444" };
+    case "aborted":
+      return { icon: "[X]", color: "#ef4444" };
+    case "skipped":
+      return { icon: "[>]", color: "#f59e0b" };
+    case "backgrounded":
+      return { icon: "[~]", color: "#38bdf8" };
     case "pending":
     default:
       return { icon: "[ ]", color: "#94a3b8" };
@@ -49,7 +74,8 @@ export function showCommandRunner(
   renderer: CliRenderer,
   options: CommandRunnerOptions,
 ): {
-  taskStatuses: Array<{ task: CommandTask; status: "pending" | "running" | "done" | "error" }>;
+  taskStatuses: Array<{ task: CommandTask; status: TaskStatus }>;
+  content: Renderable;
 } {
   clearLayout(renderer);
   taskTexts = [];
@@ -106,12 +132,12 @@ export function showCommandRunner(
     content.add(outputText);
   }
 
-  return { taskStatuses };
+  return { taskStatuses, content };
 }
 
 export function updateCommandRunner(
   renderer: CliRenderer,
-  taskStatuses: Array<{ task: CommandTask; status: "pending" | "running" | "done" | "error" }>,
+  taskStatuses: Array<{ task: CommandTask; status: TaskStatus }>,
   currentTaskIndex?: number,
   outputLines?: string[],
 ): void {
@@ -143,6 +169,7 @@ export function updateCommandRunner(
 }
 
 export function hideCommandRunner(renderer: CliRenderer): void {
+  hideFooter(renderer);
   clearLayout(renderer);
   taskTexts = [];
   currentCommandText = null;
@@ -150,94 +177,265 @@ export function hideCommandRunner(renderer: CliRenderer): void {
   tasksLabel = null;
 }
 
+type ControlAction = "abort" | "skip" | "background" | null;
+
 export async function runCommands(
   renderer: CliRenderer,
   options: CommandRunnerOptions,
 ): Promise<CommandResult[]> {
-  const { tasks, showOutput = true, outputLines = 5 } = options;
-
-  const { taskStatuses } = showCommandRunner(renderer, options);
+  const {
+    tasks,
+    showOutput = true,
+    outputLines = 5,
+    allowAbort = false,
+    allowSkip = false,
+    allowBackground = false,
+    sessionName,
+  } = options;
+
+  const { taskStatuses, content } = showCommandRunner(renderer, options);
   const results: CommandResult[] = [];
 
-  for (let i = 0; i < tasks.length; i++) {
-    const task = tasks[i];
-    const taskState = taskStatuses[i];
+  // Track control state
+  let controlAction: ControlAction = null;
+  let abortAll = false;
+  let currentProc: ReturnType<typeof Bun.spawn> | null = null;
+  let backgroundResolve: (() => void) | null = null;
 
-    if (!task || !taskState) continue;
+  // Build footer hints
+  const footerHints: string[] = [];
+  if (allowAbort) {
+    footerHints.push(tasks.length > 1 ? "a Abort All" : "a Abort");
+  }
+  if (allowSkip && tasks.length > 1) {
+    footerHints.push("s Skip");
+  }
+  if (allowBackground) {
+    footerHints.push("b Background");
+  }
 
-    // Update status to running
-    taskState.status = "running";
-    updateCommandRunner(renderer, taskStatuses, i, []);
+  // Show footer with control options
+  if (footerHints.length > 0) {
+    showFooter(renderer, content, {
+      navigate: false,
+      select: false,
+      back: false,
+      custom: footerHints,
+    });
+    renderer.requestRender();
+  }
 
-    try {
-      const proc = Bun.spawn(task.command, {
-        cwd: task.cwd,
-        stdout: "pipe",
-        stderr: "pipe",
-      });
+  // Set up keyboard listener
+  const keyHandler = (key: KeyEvent) => {
+    if (allowAbort && isAbort(key)) {
+      controlAction = "abort";
+      abortAll = true;
+      if (currentProc) {
+        currentProc.kill("SIGTERM");
+      }
+    } else if (allowSkip && tasks.length > 1 && isSkip(key)) {
+      controlAction = "skip";
+      if (currentProc) {
+        currentProc.kill("SIGTERM");
+      }
+    } else if (allowBackground && isBackground(key)) {
+      controlAction = "background";
+      // Don't kill - just detach, but signal to move on
+      if (backgroundResolve) {
+        backgroundResolve();
+        backgroundResolve = null;
+      }
+    }
+  };
 
-      let outputBuffer: string[] = [];
+  // Subscribe to keyboard events via renderer's keyInput
+  if (footerHints.length > 0) {
+    renderer.keyInput.on("keypress", keyHandler);
+  }
 
-      const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
-        maxBufferLines: outputLines,
-        onBufferUpdate: (buffer) => {
-          outputBuffer = buffer;
-          if (showOutput) {
-            updateCommandRunner(renderer, taskStatuses, i, buffer);
-          }
-        },
-      });
+  try {
+    for (let i = 0; i < tasks.length; i++) {
+      const task = tasks[i];
+      const taskState = taskStatuses[i];
 
-      const exitCode = await proc.exited;
+      if (!task || !taskState) continue;
 
-      if (success && exitCode === 0) {
-        taskState.status = "done";
+      // If abort all was triggered, mark remaining tasks as aborted
+      if (abortAll) {
+        taskState.status = "aborted";
         results.push({
           task,
-          success: true,
-          exitCode: 0,
-          output: outputBuffer.length > 0 ? outputBuffer : output,
+          success: false,
+          exitCode: -1,
+          output: [],
+          outcome: "aborted",
+        });
+        updateCommandRunner(renderer, taskStatuses, i, []);
+        continue;
+      }
+
+      // Reset control action for this task
+      controlAction = null;
+
+      // Update status to running
+      taskState.status = "running";
+      updateCommandRunner(renderer, taskStatuses, i, []);
+
+      try {
+        const proc = Bun.spawn(task.command, {
+          cwd: task.cwd,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        currentProc = proc;
+
+        let outputBuffer: string[] = [];
+
+        // Create a promise that resolves when background is requested
+        const backgroundPromise = new Promise<"background">((resolve) => {
+          backgroundResolve = () => resolve("background");
+        });
+
+        // Race between normal completion and background request
+        const streamPromise = readProcessOutputWithControl(proc, {
+          maxBufferLines: outputLines,
+          onBufferUpdate: (buffer) => {
+            outputBuffer = buffer;
+            if (showOutput) {
+              updateCommandRunner(renderer, taskStatuses, i, buffer);
+            }
+          },
+          shouldStop: () => controlAction !== null && controlAction !== "background",
         });
-      } else {
+
+        const raceResult = await Promise.race([
+          streamPromise.then((r) => ({ type: "stream" as const, ...r })),
+          backgroundPromise.then(() => ({ type: "background" as const })),
+        ]);
+
+        backgroundResolve = null;
+        currentProc = null;
+
+        // Extract stream result or create default for background
+        const { success, output, fullOutput, wasInterrupted } =
+          raceResult.type === "stream"
+            ? raceResult
+            : { success: true, output: outputBuffer, fullOutput: "", wasInterrupted: false };
+
+        // Handle control actions
+        if (controlAction === "abort" || abortAll) {
+          taskState.status = "aborted";
+          results.push({
+            task,
+            success: false,
+            exitCode: -1,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            outcome: "aborted",
+          });
+          // abortAll is already set, remaining tasks will be marked as aborted
+        } else if (controlAction === "skip") {
+          taskState.status = "skipped";
+          results.push({
+            task,
+            success: false,
+            exitCode: -1,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            outcome: "skipped",
+          });
+        } else if (controlAction === "background") {
+          taskState.status = "backgrounded";
+
+          // Register the background process for tracking
+          if (proc.pid && sessionName) {
+            await registerBackgroundProcess(
+              proc.pid,
+              task.command.join(" "),
+              task.label,
+              sessionName,
+            );
+          }
+
+          results.push({
+            task,
+            success: true, // Consider backgrounded as success for flow purposes
+            exitCode: 0,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            outcome: "backgrounded",
+          });
+        } else if (wasInterrupted) {
+          // Was interrupted but no specific action (shouldn't happen)
+          taskState.status = "error";
+          results.push({
+            task,
+            success: false,
+            exitCode: -1,
+            output: outputBuffer.length > 0 ? outputBuffer : output,
+            error: "Command was interrupted",
+            outcome: "error",
+          });
+        } else {
+          // Normal completion
+          const exitCode = await proc.exited;
+
+          if (success && exitCode === 0) {
+            taskState.status = "done";
+            results.push({
+              task,
+              success: true,
+              exitCode: 0,
+              output: outputBuffer.length > 0 ? outputBuffer : output,
+              outcome: "completed",
+            });
+          } else {
+            taskState.status = "error";
+            const errorMsg = fullOutput.trim() || `Command exited with code ${exitCode}`;
+            results.push({
+              task,
+              success: false,
+              exitCode,
+              output: outputBuffer.length > 0 ? outputBuffer : output,
+              error: errorMsg,
+              outcome: "error",
+            });
+          }
+        }
+
+        // Final update with last output
+        if (showOutput) {
+          updateCommandRunner(
+            renderer,
+            taskStatuses,
+            i,
+            outputBuffer.length > 0 ? outputBuffer : output,
+          );
+        } else {
+          updateCommandRunner(renderer, taskStatuses, i);
+        }
+      } catch (error) {
+        currentProc = null;
         taskState.status = "error";
-        const errorMsg = fullOutput.trim() || `Command exited with code ${exitCode}`;
+        const errorMsg = error instanceof Error ? error.message : String(error);
         results.push({
           task,
           success: false,
-          exitCode,
-          output: outputBuffer.length > 0 ? outputBuffer : output,
+          exitCode: 1,
+          output: [],
           error: errorMsg,
+          outcome: "error",
         });
-      }
 
-      // Final update with last output
-      if (showOutput) {
-        updateCommandRunner(
-          renderer,
-          taskStatuses,
-          i,
-          outputBuffer.length > 0 ? outputBuffer : output,
-        );
-      } else {
-        updateCommandRunner(renderer, taskStatuses, i);
-      }
-    } catch (error) {
-      taskState.status = "error";
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      results.push({
-        task,
-        success: false,
-        exitCode: 1,
-        output: [],
-        error: errorMsg,
-      });
-
-      if (showOutput) {
-        updateCommandRunner(renderer, taskStatuses, i, [errorMsg]);
-      } else {
-        updateCommandRunner(renderer, taskStatuses, i);
+        if (showOutput) {
+          updateCommandRunner(renderer, taskStatuses, i, [errorMsg]);
+        } else {
+          updateCommandRunner(renderer, taskStatuses, i);
+        }
       }
     }
+  } finally {
+    // Clean up keyboard listener
+    if (footerHints.length > 0) {
+      renderer.keyInput.off("keypress", keyHandler);
+    }
   }
 
   // Clear current command indicator when done
@@ -245,5 +443,8 @@ export async function runCommands(
     currentCommandText.content = "";
   }
 
+  // Hide footer
+  hideFooter(renderer);
+
   return results;
 }

package/src/ui/common/keyboard.ts

@@ -31,6 +31,11 @@ export const KEYBOARD = {
   // Text input shortcuts
   BACKSPACE: "backspace",
   CTRL_D: "d", // Ctrl+D (handled via ctrl modifier)
+
+  // Command control shortcuts
+  ABORT: "a",
+  SKIP: "s",
+  BACKGROUND: "b",
 } as const;
 
 /**
@@ -93,3 +98,24 @@ export function isNavigation(key: KeyEvent): boolean {
     key.name === KEYBOARD.RIGHT
   );
 }
+
+/**
+ * Check if a key event is Abort (a)
+ */
+export function isAbort(key: Pick<KeyEvent, "name">): boolean {
+  return key.name === KEYBOARD.ABORT;
+}
+
+/**
+ * Check if a key event is Skip (s)
+ */
+export function isSkip(key: Pick<KeyEvent, "name">): boolean {
+  return key.name === KEYBOARD.SKIP;
+}
+
+/**
+ * Check if a key event is Background (b)
+ */
+export function isBackground(key: Pick<KeyEvent, "name">): boolean {
+  return key.name === KEYBOARD.BACKGROUND;
+}

package/src/ui/common/repo-formatter.ts

@@ -16,9 +16,8 @@ export function formatRepoList(repos: RepoSpec[], options: RepoFormatterOptions
 
       if (showMarkers) {
         const branchMarker = repo.branch ? ` (${repo.branch})` : "";
-        const roMarker = repo.readOnly ? " [RO]" : "";
-        const latestMarker = repo.latest ? " [Latest]" : "";
-        text += `${branchMarker}${roMarker}${latestMarker}`;
+        const refMarker = repo.reference ? " [Ref]" : "";
+        text += `${branchMarker}${refMarker}`;
       }
 
       return text;
@@ -33,12 +32,8 @@ export function formatRepoString(repo: RepoSpec): string {
     parts.push(`(${repo.branch})`);
   }
 
-  if (repo.readOnly) {
-    parts.push("[RO]");
-  }
-
-  if (repo.latest) {
-    parts.push("[Latest]");
+  if (repo.reference) {
+    parts.push("[Ref]");
   }
 
   return parts.join(" ");

package/src/ui/new-session.ts

@@ -27,11 +27,10 @@ export function showNewSessionPrompt(
 
     repos.forEach((repo, i) => {
       const branch = repo.branch ? ` (${repo.branch})` : " (default)";
-      const roMarker = repo.readOnly ? " [RO]" : "";
-      const latestMarker = repo.latest ? " [Latest]" : "";
+      const refMarker = repo.reference ? " [Ref]" : "";
       const repoText = new TextRenderable(renderer, {
         id: `repo-${i}`,
-        content: `  - ${repo.owner}/${repo.name}${branch}${roMarker}${latestMarker}`,
+        content: `  - ${repo.owner}/${repo.name}${branch}${refMarker}`,
         fg: "#94a3b8",
       });
       content.add(repoText);

package/src/ui/progress.ts

@@ -52,7 +52,7 @@ function getPhasePresentation(phase: ProgressPhase): { content: string; fg: stri
     case "installing-skills":
       return { content: "Installing skills...", fg: "#38bdf8" };
     case "refreshing":
-      return { content: "Refreshing latest repositories...", fg: "#38bdf8" };
+      return { content: "Refreshing reference repositories...", fg: "#38bdf8" };
     case "done":
       return { content: "Ready!", fg: "#22c55e" };
     default:

package/src/ui/session-settings.ts

@@ -208,7 +208,7 @@ export function showSessionSettings(
       if (selectedTarget === "goal") {
         customActions.push("Enter Edit");
       } else if (selectedTarget === "repo") {
-        customActions.push("r Toggle RO", "l Toggle Latest", "a Add repos");
+        customActions.push("r Toggle Ref", "a Add repos");
       } else if (selectedTarget === "skill") {
         customActions.push("x Remove", "a Add repos");
       }
@@ -342,22 +342,7 @@ export function showSessionSettings(
       if (key.name === "r" && selectedTarget === "repo") {
         const repo = updatedRepos[selectedRepoIndex];
         if (repo) {
-          repo.readOnly = !repo.readOnly;
-          if (!repo.readOnly) {
-            repo.latest = false;
-          }
-          updateReposList();
-        }
-        return;
-      }
-
-      if (key.name === "l" && selectedTarget === "repo") {
-        const repo = updatedRepos[selectedRepoIndex];
-        if (repo) {
-          repo.latest = !repo.latest;
-          if (repo.latest) {
-            repo.readOnly = true;
-          }
+          repo.reference = !repo.reference;
           updateReposList();
         }
         return;

package/src/utils/stream.ts

@@ -51,6 +51,12 @@ interface ReadProcessOutputWithBufferOptions {
   onBufferUpdate?: (buffer: string[]) => void;
 }
 
+export interface ReadWithControlOptions {
+  maxBufferLines?: number;
+  onBufferUpdate?: (buffer: string[]) => void;
+  shouldStop?: () => boolean; // Check if we should stop early
+}
+
 export async function readProcessOutputWithBuffer(
   proc: ReturnType<typeof Bun.spawn>,
   options?: ReadProcessOutputWithBufferOptions,
@@ -106,3 +112,86 @@ export async function readProcessOutputWithBuffer(
     fullOutput: fullOutputParts.join(""),
   };
 }
+
+export async function readProcessOutputWithControl(
+  proc: ReturnType<typeof Bun.spawn>,
+  options?: ReadWithControlOptions,
+): Promise<{ success: boolean; output: string[]; fullOutput: string; wasInterrupted: boolean }> {
+  const { maxBufferLines, onBufferUpdate, shouldStop } = options || {};
+  const outputBuffer: string[] = [];
+  let wasInterrupted = false;
+
+  const addLine = (line: string) => {
+    const trimmed = line.trim();
+    if (trimmed) {
+      outputBuffer.push(trimmed);
+      if (maxBufferLines && outputBuffer.length > maxBufferLines) {
+        outputBuffer.shift();
+      }
+      onBufferUpdate?.([...outputBuffer]);
+    }
+  };
+
+  const fullOutputParts: string[] = [];
+
+  const readStream = async (stream: ReadableStream<Uint8Array> | number | undefined) => {
+    if (!stream || typeof stream === "number") return;
+
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    try {
+      while (true) {
+        // Check if we should stop before each read
+        if (shouldStop?.()) {
+          wasInterrupted = true;
+          reader.releaseLock();
+          return;
+        }
+
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        const chunk = decoder.decode(value, { stream: true });
+        fullOutputParts.push(chunk);
+        buffer += chunk;
+
+        const lines = buffer.split(/[\r\n]+/);
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          addLine(line);
+        }
+
+        // Check again after processing
+        if (shouldStop?.()) {
+          wasInterrupted = true;
+          reader.releaseLock();
+          return;
+        }
+      }
+
+      if (buffer.trim()) {
+        addLine(buffer);
+      }
+    } catch {
+      // Stream may have been cancelled, that's ok
+    }
+  };
+
+  await Promise.all([readStream(proc.stdout), readStream(proc.stderr)]);
+
+  // Only wait for exit if not interrupted
+  let exitCode = 1;
+  if (!wasInterrupted) {
+    exitCode = await proc.exited;
+  }
+
+  return {
+    success: !wasInterrupted && exitCode === 0,
+    output: outputBuffer,
+    fullOutput: fullOutputParts.join(""),
+    wasInterrupted,
+  };
+}