letmecook 0.0.1 → 0.0.2

package/src/ui/agent-proposal.ts

@@ -0,0 +1,80 @@
+import { type CliRenderer, TextRenderable } from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import type { RepoSpec } from "../types";
+
+export interface AgentProposal {
+  sessionName: string;
+  repos: RepoSpec[];
+  goal?: string;
+}
+
+export function showAgentProposal(renderer: CliRenderer, proposal: AgentProposal): void {
+  clearLayout(renderer);
+
+  const { content } = createBaseLayout(renderer, "Agent Proposal");
+
+  // Session name
+  const sessionNameText = new TextRenderable(renderer, {
+    id: "session-name",
+    content: `Session: ${proposal.sessionName}`,
+    fg: "#38bdf8",
+    marginBottom: 2,
+  });
+  content.add(sessionNameText);
+
+  // Goal if provided
+  if (proposal.goal) {
+    const goalLabel = new TextRenderable(renderer, {
+      id: "goal-label",
+      content: "Goal:",
+      fg: "#e2e8f0",
+      marginBottom: 0,
+    });
+    content.add(goalLabel);
+
+    const goalText = new TextRenderable(renderer, {
+      id: "goal-text",
+      content: proposal.goal,
+      fg: "#94a3b8",
+      marginBottom: 2,
+    });
+    content.add(goalText);
+  }
+
+  // Repository plan
+  const planLabel = new TextRenderable(renderer, {
+    id: "plan-label",
+    content: "Repositories to clone:",
+    fg: "#e2e8f0",
+    marginBottom: 1,
+  });
+  content.add(planLabel);
+
+  proposal.repos.forEach((repo) => {
+    const repoText = new TextRenderable(renderer, {
+      id: `repo-${repo.owner}-${repo.name}`,
+      content: `  📦 ${repo.owner}/${repo.name}`,
+      fg: "#10b981",
+      marginBottom: 0,
+    });
+    content.add(repoText);
+  });
+
+  // Summary
+  const summaryText = new TextRenderable(renderer, {
+    id: "summary",
+    content: `\nThis will clone ${proposal.repos.length} repositories.`,
+    fg: "#64748b",
+    marginTop: 2,
+  });
+  content.add(summaryText);
+
+  // Continue prompt
+  const continueText = new TextRenderable(renderer, {
+    id: "continue",
+    content: "Continuing...",
+    fg: "#64748b",
+    marginTop: 1,
+  });
+  content.add(continueText);
+}

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

@@ -0,0 +1,45 @@
+import type { RepoSpec } from "../../types";
+
+export interface RepoFormatterOptions {
+  showMarkers?: boolean;
+  prefix?: string;
+}
+
+export function formatRepoList(repos: RepoSpec[], options: RepoFormatterOptions = {}): string {
+  const { showMarkers = true, prefix = "" } = options;
+
+  if (repos.length === 0) return "(none)";
+
+  return repos
+    .map((repo) => {
+      let text = `${prefix}${repo.owner}/${repo.name}`;
+
+      if (showMarkers) {
+        const branchMarker = repo.branch ? ` (${repo.branch})` : "";
+        const roMarker = repo.readOnly ? " [RO]" : "";
+        const latestMarker = repo.latest ? " [Latest]" : "";
+        text += `${branchMarker}${roMarker}${latestMarker}`;
+      }
+
+      return text;
+    })
+    .join("\n");
+}
+
+export function formatRepoString(repo: RepoSpec): string {
+  const parts = [`${repo.owner}/${repo.name}`];
+
+  if (repo.branch) {
+    parts.push(`(${repo.branch})`);
+  }
+
+  if (repo.readOnly) {
+    parts.push("[RO]");
+  }
+
+  if (repo.latest) {
+    parts.push("[Latest]");
+  }
+
+  return parts.join(" ");
+}

package/src/ui/confirm-delete.ts

@@ -0,0 +1,95 @@
+import {
+  type CliRenderer,
+  TextRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type KeyEvent,
+} from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import type { Session } from "../types";
+
+export type DeleteConfirmChoice = "confirm" | "cancel";
+
+export function showDeleteConfirm(
+  renderer: CliRenderer,
+  session: Session,
+): Promise<DeleteConfirmChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Delete session");
+
+    const sessionInfo = new TextRenderable(renderer, {
+      id: "session-info",
+      content: `Session: ${session.name}`,
+      fg: "#38bdf8",
+      marginBottom: 1,
+    });
+    content.add(sessionInfo);
+
+    const warning = new TextRenderable(renderer, {
+      id: "warning",
+      content: "This permanently deletes the session and its files.",
+      fg: "#f59e0b",
+      marginBottom: 1,
+    });
+    content.add(warning);
+
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "Are you sure you want to delete this session?",
+      fg: "#e2e8f0",
+    });
+    content.add(question);
+
+    const select = new SelectRenderable(renderer, {
+      id: "delete-confirm-select",
+      width: 38,
+      height: 2,
+      options: [
+        { name: "Cancel", description: "", value: "cancel" },
+        { name: "Delete session", description: "", value: "confirm" },
+      ],
+      showDescription: false,
+      backgroundColor: "transparent",
+      focusedBackgroundColor: "transparent",
+      selectedBackgroundColor: "#334155",
+      textColor: "#e2e8f0",
+      selectedTextColor: "#38bdf8",
+      marginTop: 1,
+    });
+    content.add(select);
+
+    const instructions = new TextRenderable(renderer, {
+      id: "instructions",
+      content: "\n[Enter] Select   [Esc] Cancel",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(instructions);
+
+    select.focus();
+
+    const handleSelect = (_index: number, option: { value: string }) => {
+      cleanup();
+      resolve(option.value as DeleteConfirmChoice);
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (key.name === "escape") {
+        cleanup();
+        resolve("cancel");
+      }
+    };
+
+    const cleanup = () => {
+      select.off(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+      renderer.keyInput.off("keypress", handleKeypress);
+      select.blur();
+      clearLayout(renderer);
+    };
+
+    select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}

package/src/ui/conflict.ts

@@ -0,0 +1,121 @@
+import {
+  type CliRenderer,
+  TextRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type KeyEvent,
+} from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import type { Session, ConflictChoice } from "../types";
+
+function formatTimeAgo(date: string): string {
+  const now = new Date();
+  const then = new Date(date);
+  const diffMs = now.getTime() - then.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMins / 60);
+  const diffDays = Math.floor(diffHours / 24);
+
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins} minute${diffMins === 1 ? "" : "s"} ago`;
+  if (diffHours < 24) return `${diffHours} hour${diffHours === 1 ? "" : "s"} ago`;
+  if (diffDays < 7) return `${diffDays} day${diffDays === 1 ? "" : "s"} ago`;
+  return then.toLocaleDateString();
+}
+
+export function showConflictPrompt(
+  renderer: CliRenderer,
+  existingSession: Session,
+): Promise<ConflictChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Existing session found");
+
+    // Session info
+    const sessionInfo = new TextRenderable(renderer, {
+      id: "session-info",
+      content: `Session: ${existingSession.name}`,
+      fg: "#38bdf8",
+    });
+    content.add(sessionInfo);
+
+    const timeInfo = new TextRenderable(renderer, {
+      id: "time-info",
+      content: `Created: ${formatTimeAgo(existingSession.created)}`,
+      fg: "#94a3b8",
+    });
+    content.add(timeInfo);
+
+    const reposInfo = new TextRenderable(renderer, {
+      id: "repos-info",
+      content: `Repos: ${existingSession.repos.map((r) => `${r.owner}/${r.name}`).join(", ")}`,
+      fg: "#94a3b8",
+    });
+    content.add(reposInfo);
+
+    if (existingSession.goal) {
+      const goalInfo = new TextRenderable(renderer, {
+        id: "goal-info",
+        content: `Goal: ${existingSession.goal}`,
+        fg: "#94a3b8",
+        marginBottom: 1,
+      });
+      content.add(goalInfo);
+    }
+
+    // Question
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "\nWhat would you like to do?",
+      fg: "#e2e8f0",
+      marginTop: 1,
+    });
+    content.add(question);
+
+    // Options
+    const select = new SelectRenderable(renderer, {
+      id: "conflict-select",
+      width: 40,
+      height: 4,
+      options: [
+        { name: "Resume existing session", description: "", value: "resume" },
+        { name: "Nuke it and start fresh", description: "", value: "nuke" },
+        { name: "Create new session (keep old)", description: "", value: "new" },
+        { name: "Cancel", description: "", value: "cancel" },
+      ],
+      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 ConflictChoice);
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (key.name === "escape") {
+        cleanup();
+        resolve("cancel");
+      }
+    };
+
+    const cleanup = () => {
+      select.off(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+      renderer.keyInput.off("keypress", handleKeypress);
+      select.blur();
+      clearLayout(renderer);
+    };
+
+    select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}

package/src/ui/exit.ts

@@ -0,0 +1,175 @@
+import { type CliRenderer, TextRenderable, type KeyEvent } from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import type { Session, ExitChoice, RepoSpec } from "../types";
+import { sessionHasUncommittedChanges } from "../git";
+
+export function showExitPrompt(renderer: CliRenderer, session: Session): Promise<ExitChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Session complete");
+
+    // Session info
+    const sessionInfo = new TextRenderable(renderer, {
+      id: "session-info",
+      content: `Session: ${session.name}`,
+      fg: "#38bdf8",
+      marginBottom: 1,
+    });
+    content.add(sessionInfo);
+
+    // Question
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "What would you like to do?",
+      fg: "#e2e8f0",
+    });
+    content.add(question);
+
+    const instructions = new TextRenderable(renderer, {
+      id: "instructions",
+      content: "\n[Enter] Resume   [e] Edit session   [d] Delete session   [Esc] Back to home",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(instructions);
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+        resolve("resume");
+        return;
+      }
+
+      if (key.name === "e") {
+        cleanup();
+        resolve("edit");
+        return;
+      }
+
+      if (key.name === "d") {
+        cleanup();
+        resolve("delete");
+        return;
+      }
+
+      if (key.name === "escape") {
+        cleanup();
+        resolve("home");
+      }
+    };
+
+    const cleanup = () => {
+      renderer.keyInput.off("keypress", handleKeypress);
+      clearLayout(renderer);
+    };
+
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}
+
+export function showExitPromptWithChanges(
+  renderer: CliRenderer,
+  session: Session,
+  reposWithChanges: RepoSpec[],
+): Promise<ExitChoice> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Session complete");
+
+    // Session info
+    const sessionInfo = new TextRenderable(renderer, {
+      id: "session-info",
+      content: `Session: ${session.name}`,
+      fg: "#38bdf8",
+      marginBottom: 1,
+    });
+    content.add(sessionInfo);
+
+    // Warning about uncommitted changes
+    const warning = new TextRenderable(renderer, {
+      id: "warning",
+      content: "⚠️  Uncommitted changes detected:",
+      fg: "#f59e0b",
+      marginBottom: 0,
+    });
+    content.add(warning);
+
+    const changedReposList = new TextRenderable(renderer, {
+      id: "changed-repos",
+      content: reposWithChanges.map((r) => `   - ${r.dir}/`).join("\n"),
+      fg: "#fbbf24",
+      marginBottom: 1,
+    });
+    content.add(changedReposList);
+
+    // Question
+    const question = new TextRenderable(renderer, {
+      id: "question",
+      content: "What would you like to do?",
+      fg: "#e2e8f0",
+    });
+    content.add(question);
+
+    const instructions = new TextRenderable(renderer, {
+      id: "instructions",
+      content: "\n[Enter] Resume   [e] Edit session   [d] Delete session   [Esc] Back to home",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(instructions);
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+        resolve("resume");
+        return;
+      }
+
+      if (key.name === "e") {
+        cleanup();
+        resolve("edit");
+        return;
+      }
+
+      if (key.name === "d") {
+        cleanup();
+        resolve("delete");
+        return;
+      }
+
+      if (key.name === "escape") {
+        cleanup();
+        resolve("home");
+      }
+    };
+
+    const cleanup = () => {
+      renderer.keyInput.off("keypress", handleKeypress);
+      clearLayout(renderer);
+    };
+
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}
+
+export async function handleSmartExit(
+  renderer: CliRenderer,
+  session: Session,
+): Promise<{ action: ExitChoice }> {
+  const { hasChanges, reposWithChanges } = await sessionHasUncommittedChanges(
+    session.repos,
+    session.path,
+  );
+
+  // Always prompt - if there are uncommitted changes, show warning
+  if (hasChanges) {
+    const choice = await showExitPromptWithChanges(renderer, session, reposWithChanges);
+    return { action: choice };
+  }
+
+  // No uncommitted changes - show simple exit prompt
+  const choice = await showExitPrompt(renderer, session);
+  return { action: choice };
+}

package/src/ui/list.ts

@@ -0,0 +1,112 @@
+import {
+  type CliRenderer,
+  TextRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type KeyEvent,
+} from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import { buildSessionOptions } from "./session-options";
+import type { Session } from "../types";
+
+export type ListAction =
+  | { type: "resume"; session: Session }
+  | { type: "delete"; session: Session }
+  | { type: "nuke-all" }
+  | { type: "quit" };
+
+export function showSessionList(renderer: CliRenderer, sessions: Session[]): Promise<ListAction> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Sessions");
+
+    if (sessions.length === 0) {
+      const emptyText = new TextRenderable(renderer, {
+        id: "empty",
+        content: "No sessions found.\n\nCreate one with: letmecook owner/repo",
+        fg: "#94a3b8",
+      });
+      content.add(emptyText);
+
+      const handleKeypress = (key: KeyEvent) => {
+        if (key.name === "escape") {
+          renderer.keyInput.off("keypress", handleKeypress);
+          clearLayout(renderer);
+          resolve({ type: "quit" });
+        }
+      };
+
+      renderer.keyInput.on("keypress", handleKeypress);
+      return;
+    }
+
+    // Build options from sessions
+    const options = buildSessionOptions(sessions);
+
+    const select = new SelectRenderable(renderer, {
+      id: "session-list",
+      width: 65,
+      height: Math.min(sessions.length * 2, 12),
+      options,
+      showDescription: true,
+      backgroundColor: "transparent",
+      focusedBackgroundColor: "transparent",
+      selectedBackgroundColor: "#334155",
+      textColor: "#e2e8f0",
+      selectedTextColor: "#38bdf8",
+      descriptionColor: "#64748b",
+      selectedDescriptionColor: "#94a3b8",
+    });
+    content.add(select);
+
+    // Instructions
+    const instructions = new TextRenderable(renderer, {
+      id: "instructions",
+      content: "\n[Enter] Resume   [d] Delete   [a] Nuke All   [Esc] Quit",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(instructions);
+
+    select.focus();
+
+    let selectedIndex = 0;
+
+    const handleSelect = (_index: number, option: { value: Session }) => {
+      cleanup();
+      resolve({ type: "resume", session: option.value });
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      // Track selection for delete
+      if (key.name === "up" || key.name === "k") {
+        selectedIndex = Math.max(0, selectedIndex - 1);
+      } else if (key.name === "down" || key.name === "j") {
+        selectedIndex = Math.min(sessions.length - 1, selectedIndex + 1);
+      } else if (key.name === "d") {
+        const session = sessions[selectedIndex];
+        if (session) {
+          cleanup();
+          resolve({ type: "delete", session });
+        }
+      } else if (key.name === "a") {
+        cleanup();
+        resolve({ type: "nuke-all" });
+      } else if (key.name === "escape") {
+        cleanup();
+        resolve({ type: "quit" });
+      }
+    };
+
+    const cleanup = () => {
+      select.off(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+      renderer.keyInput.off("keypress", handleKeypress);
+      select.blur();
+      clearLayout(renderer);
+    };
+
+    select.on(SelectRenderableEvents.ITEM_SELECTED, handleSelect);
+    renderer.keyInput.on("keypress", handleKeypress);
+  });
+}