letmecook 0.0.1 → 0.0.4

package/src/tui-mode.ts

@@ -0,0 +1,184 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import type { CliRenderer } from "@opentui/core";
+import { createRenderer, destroyRenderer } from "./ui/renderer";
+import { showAddReposPrompt } from "./ui/add-repos";
+import { showNewSessionPrompt } from "./ui/new-session";
+import { showSkillsPrompt } from "./ui/skills";
+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 type { Session } from "./types";
+import { createNewSession, resumeSession } from "./flows";
+import { listSessions, deleteSession, updateLastAccessed, updateSessionSettings } from "./sessions";
+
+export async function handleTUIMode(): Promise<void> {
+  let renderer = await createRenderer();
+
+  try {
+    while (true) {
+      renderer = await createRenderer();
+      const sessions = await listSessions();
+      const action = await showMainMenu(renderer, sessions);
+
+      switch (action.type) {
+        case "new-session":
+          await handleNewSessionFlow(renderer);
+          break;
+
+        case "resume":
+          await handleSessionDetailsFlow(renderer, action.session);
+          break;
+
+        case "delete": {
+          const choice = await showDeleteConfirm(renderer, action.session);
+          if (choice === "confirm") {
+            await deleteSession(action.session.name);
+          }
+          break;
+        }
+
+        case "quit":
+          destroyRenderer();
+          console.log("\nGoodbye!");
+          return;
+      }
+    }
+  } catch (error) {
+    destroyRenderer();
+    console.error("\nError:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+async function handleNewSessionFlow(renderer: CliRenderer): Promise<void> {
+  const addReposResult = await showAddReposPrompt(renderer);
+
+  if (addReposResult.cancelled || addReposResult.repos.length === 0) {
+    return;
+  }
+
+  const repos = addReposResult.repos;
+
+  const { skills, cancelled: skillsCancelled } = await showSkillsPrompt(renderer);
+
+  if (skillsCancelled) {
+    return;
+  }
+
+  const goalResult = await showNewSessionPrompt(renderer, repos);
+
+  if (goalResult.cancelled) {
+    return;
+  }
+
+  const result = await createNewSession(renderer, {
+    repos,
+    goal: goalResult.goal,
+    skills: skills.length > 0 ? skills : undefined,
+    mode: "tui",
+  });
+
+  if (!result) {
+    return;
+  }
+
+  const { session, skipped } = result;
+
+  if (skipped) {
+    await handleSessionDetailsFlow(renderer, session);
+    return;
+  }
+
+  // Destroy renderer before runManualSetup to release stdin for readline
+  destroyRenderer();
+
+  await runManualSetup(session);
+  await resumeSession(renderer, {
+    session,
+    mode: "tui",
+    initialRefresh: false,
+  });
+}
+
+async function runManualSetup(session: Session): Promise<void> {
+  const rl = createInterface({ input, output });
+
+  console.log("\n⚡️ Would you like to run any setup commands before launching claude?");
+  console.log("   Examples: npm install, bun install, make build");
+  console.log("   Press Enter to skip and launch claude immediately.\n");
+
+  while (true) {
+    const answer = await rl.question("> ");
+    const cmd = answer.trim();
+
+    if (!cmd) {
+      console.log("\n🚀 Launching claude...\n");
+      break;
+    }
+
+    console.log(`\nRunning: ${cmd}...`);
+    const proc = Bun.spawn(["bash", "-c", cmd], {
+      cwd: session.path,
+      stdio: ["inherit", "inherit", "inherit"],
+    });
+
+    await proc.exited;
+
+    if (proc.exitCode !== 0) {
+      console.log(`❌ Command failed with exit code ${proc.exitCode}`);
+    } else {
+      console.log("✅ Command completed");
+    }
+
+    console.log("\nEnter another command or press Enter to launch claude.");
+  }
+
+  rl.close();
+}
+
+async function handleSessionDetailsFlow(renderer: CliRenderer, session: Session): Promise<void> {
+  let currentSession = session;
+
+  while (true) {
+    const detailsAction = await showSessionDetails(renderer, currentSession);
+
+    if (detailsAction === "resume") {
+      await updateLastAccessed(currentSession.name);
+      await resumeSession(renderer, {
+        session: currentSession,
+        mode: "tui",
+        initialRefresh: true,
+      });
+      return;
+    }
+
+    if (detailsAction === "edit") {
+      const editResult = await showSessionSettings(renderer, currentSession);
+      if (editResult.action === "saved") {
+        const saved = await updateSessionSettings(editResult.session.name, {
+          repos: editResult.session.repos,
+          goal: editResult.session.goal,
+        });
+        if (saved) {
+          currentSession = saved;
+        }
+      } else if (editResult.action === "add-repos") {
+        const saved = await updateSessionSettings(editResult.session.name, {
+          repos: editResult.session.repos,
+          goal: editResult.session.goal,
+        });
+        if (saved) {
+          currentSession = saved;
+        }
+        console.log("[TODO] Add repos flow - needs to be implemented");
+      }
+      continue;
+    }
+
+    if (detailsAction === "back") {
+      return;
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,80 @@
+export interface RepoSpec {
+  /** Original spec string, e.g., "owner/repo:branch" */
+  spec: string;
+  /** Repository owner */
+  owner: string;
+  /** Repository name */
+  name: string;
+  /** Branch to checkout (defaults to default branch if not specified) */
+  branch?: string;
+  /** Directory name in the session workspace */
+  dir: string;
+  /** Whether this repo is read-only (reference only, no modifications allowed) */
+  readOnly?: boolean;
+  /** Whether this repo should be refreshed to latest before resuming */
+  latest?: boolean;
+}
+
+export interface SessionManifest {
+  /** Session name (AI-generated) */
+  name: string;
+  /** Repositories in this session */
+  repos: RepoSpec[];
+  /** User-provided goal/context */
+  goal?: string;
+  /** Installed skill packages (e.g., "vercel-labs/agent-skills") */
+  skills?: string[];
+  /** ISO timestamp when session was created */
+  created: string;
+  /** ISO timestamp when session was last accessed */
+  lastAccessed: string;
+}
+
+export interface Session extends SessionManifest {
+  /** Full path to session directory */
+  path: string;
+}
+
+export type ConflictChoice = "resume" | "nuke" | "new" | "cancel";
+
+export type ExitChoice = "resume" | "edit" | "home" | "delete";
+
+export function parseRepoSpec(spec: string): RepoSpec {
+  // Format: owner/repo or owner/repo:branch
+  const colonIndex = spec.indexOf(":");
+  const repoPath = colonIndex === -1 ? spec : spec.slice(0, colonIndex);
+  const branch = colonIndex === -1 ? undefined : spec.slice(colonIndex + 1);
+
+  const slashIndex = repoPath.indexOf("/");
+  if (slashIndex === -1) {
+    throw new Error(`Invalid repo format: ${spec} (expected owner/repo or owner/repo:branch)`);
+  }
+
+  const owner = repoPath.slice(0, slashIndex);
+  const name = repoPath.slice(slashIndex + 1);
+
+  if (!owner || !name) {
+    throw new Error(`Invalid repo format: ${spec} (expected owner/repo or owner/repo:branch)`);
+  }
+
+  return {
+    spec,
+    owner,
+    name,
+    branch,
+    dir: name,
+  };
+}
+
+export function repoSpecsMatch(a: RepoSpec[], b: RepoSpec[]): boolean {
+  if (a.length !== b.length) return false;
+
+  const aSpecs = new Set(a.map((r) => `${r.owner}/${r.name}`));
+  const bSpecs = new Set(b.map((r) => `${r.owner}/${r.name}`));
+
+  for (const spec of aSpecs) {
+    if (!bSpecs.has(spec)) return false;
+  }
+
+  return true;
+}

package/src/ui/add-repos.ts

@@ -0,0 +1,396 @@
+import { type CliRenderer, TextRenderable, InputRenderable, type KeyEvent } from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+import { parseRepoSpec, type RepoSpec } from "../types";
+import { listRepoHistory } from "../repo-history";
+
+export interface AddReposResult {
+  repos: RepoSpec[];
+  cancelled: boolean;
+}
+
+export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddReposResult> {
+  const history = await listRepoHistory();
+  const historySpecs = history.map((item) => item.spec);
+  let historyIndex = historySpecs.length;
+  const maxMatches = 6;
+
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Add repositories");
+
+    const repos: RepoSpec[] = [];
+    let currentInput = "";
+    let lastMatchIndex = -1;
+    let lastMatchQuery = "";
+    let mode: "spec" | "details" = "spec";
+    let pendingRepo: RepoSpec | null = null;
+    let pendingReadOnly = false;
+    let pendingLatest = false;
+
+    // Repository input
+    const repoLabel = new TextRenderable(renderer, {
+      id: "repo-label",
+      content: "Repository (owner/repo format):",
+      fg: "#e2e8f0",
+      marginBottom: 0,
+    });
+    content.add(repoLabel);
+
+    const repoInput = new InputRenderable(renderer, {
+      id: "repo-input",
+      width: 50,
+      height: 1,
+      placeholder: "e.g., microsoft/playwright",
+      placeholderColor: "#64748b",
+      backgroundColor: "#334155",
+      textColor: "#f8fafc",
+      cursorColor: "#38bdf8",
+      marginTop: 1,
+    });
+    content.add(repoInput);
+
+    // Matches display
+    const matchesLabel = new TextRenderable(renderer, {
+      id: "matches-label",
+      content: "Matches:",
+      fg: "#94a3b8",
+      marginTop: 1,
+    });
+    content.add(matchesLabel);
+
+    const matchesList = new TextRenderable(renderer, {
+      id: "matches-list",
+      content: "(no matches)",
+      fg: "#64748b",
+      marginTop: 0,
+    });
+    content.add(matchesList);
+
+    // Details form
+    const detailsLabel = new TextRenderable(renderer, {
+      id: "details-label",
+      content: "\nRepository details:",
+      fg: "#e2e8f0",
+      marginTop: 1,
+    });
+    content.add(detailsLabel);
+
+    const detailsReadOnly = new TextRenderable(renderer, {
+      id: "details-readonly",
+      content: "  Read-only: No",
+      fg: "#94a3b8",
+      marginTop: 0,
+    });
+    content.add(detailsReadOnly);
+
+    const detailsLatest = new TextRenderable(renderer, {
+      id: "details-latest",
+      content: "  Latest: No",
+      fg: "#94a3b8",
+      marginTop: 0,
+    });
+    content.add(detailsLatest);
+
+    repoInput.onPaste = (event) => {
+      const text = event.text.replace(/[\r\n]+/g, "");
+      if (!text) return;
+      repoInput.insertText(text);
+      currentInput = repoInput.value;
+      if (currentInput.trim()) {
+        validateAndAddRepo(currentInput.trim());
+      } else {
+        statusText.content = "";
+      }
+      event.preventDefault();
+    };
+
+    // Status display
+    const statusText = new TextRenderable(renderer, {
+      id: "status",
+      content: "",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(statusText);
+
+    // Repos list
+    const reposLabel = new TextRenderable(renderer, {
+      id: "repos-label",
+      content: "\nAdded repositories:",
+      fg: "#e2e8f0",
+      marginTop: 1,
+    });
+    content.add(reposLabel);
+
+    const reposList = new TextRenderable(renderer, {
+      id: "repos-list",
+      content: "(none)",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(reposList);
+
+    // Instructions
+    const instructions = new TextRenderable(renderer, {
+      id: "instructions",
+      content: "\n[Enter] Next   [Ctrl+D] Continue   [↑/↓] History   [Tab] Complete   [Esc] Exit",
+      fg: "#64748b",
+      marginTop: 2,
+    });
+    content.add(instructions);
+
+    repoInput.focus();
+
+    function updateReposList() {
+      if (repos.length === 0) {
+        reposList.content = "(none)";
+        reposList.fg = "#64748b";
+      } else {
+        reposList.content = repos
+          .map((repo, i) => {
+            const roMarker = repo.readOnly ? " [RO]" : "";
+            const latestMarker = repo.latest ? " [Latest]" : "";
+            return `  ${i + 1}. ${repo.spec}${roMarker}${latestMarker}`;
+          })
+          .join("\n");
+        reposList.fg = "#94a3b8";
+      }
+    }
+
+    function updateDetails() {
+      if (mode === "details" && pendingRepo) {
+        detailsLabel.content = "\nRepository details:";
+        detailsLabel.fg = "#e2e8f0";
+        detailsReadOnly.content = `  Read-only: ${pendingReadOnly ? "Yes" : "No"}`;
+        detailsReadOnly.fg = pendingReadOnly ? "#f59e0b" : "#94a3b8";
+        detailsLatest.content = `  Latest: ${pendingLatest ? "Yes" : "No"}`;
+        detailsLatest.fg = pendingLatest ? "#22d3ee" : "#94a3b8";
+        instructions.content =
+          "\n[Enter] Add   [r] Toggle read-only   [l] Toggle latest   [Esc] Back";
+      } else {
+        detailsLabel.content = "\nRepository details:";
+        detailsLabel.fg = "#475569";
+        detailsReadOnly.content = "  Read-only: No";
+        detailsReadOnly.fg = "#475569";
+        detailsLatest.content = "  Latest: No";
+        detailsLatest.fg = "#475569";
+        instructions.content =
+          "\n[Enter] Next   [Ctrl+D] Continue   [↑/↓] History   [Tab] Complete   [Esc] Cancel";
+      }
+    }
+
+    function updateMatches(value: string, selectedSpec?: string) {
+      const query = value.trim();
+      if (!query) {
+        matchesList.content = "(no matches)";
+        matchesList.fg = "#64748b";
+        return;
+      }
+
+      const lowerQuery = query.toLowerCase();
+      const matches = historySpecs
+        .filter((spec) => spec.toLowerCase().startsWith(lowerQuery))
+        .toSorted((a, b) => {
+          if (a.length !== b.length) return a.length - b.length;
+          return a.localeCompare(b);
+        })
+        .slice(0, maxMatches);
+
+      if (matches.length === 0) {
+        matchesList.content = "(no matches)";
+        matchesList.fg = "#64748b";
+        return;
+      }
+
+      matchesList.content = matches
+        .map((spec, index) => {
+          const isSelected = selectedSpec ? spec === selectedSpec : index === 0;
+          return `${isSelected ? "▶" : " "} ${spec}`;
+        })
+        .join("\n");
+      matchesList.fg = "#94a3b8";
+    }
+
+    function getMatches(value: string): string[] {
+      const query = value.trim();
+      if (!query) return [];
+      const lowerQuery = query.toLowerCase();
+      return historySpecs
+        .filter((spec) => spec.toLowerCase().startsWith(lowerQuery))
+        .toSorted((a, b) => {
+          if (a.length !== b.length) return a.length - b.length;
+          return a.localeCompare(b);
+        })
+        .slice(0, maxMatches);
+    }
+
+    function validateAndAddRepo(spec: string): boolean {
+      try {
+        parseRepoSpec(spec);
+        statusText.content = "✓ Valid format";
+        statusText.fg = "#10b981";
+        return true;
+      } catch (error) {
+        statusText.content = `✗ ${error instanceof Error ? error.message : "Invalid format"}`;
+        statusText.fg = "#ef4444";
+        return false;
+      }
+    }
+
+    function applyHistorySpec(spec: string) {
+      repoInput.value = spec;
+      currentInput = spec;
+      if (spec.trim()) {
+        validateAndAddRepo(spec.trim());
+      } else {
+        statusText.content = "";
+      }
+      updateMatches(currentInput);
+    }
+
+    function startRepoDetails() {
+      const spec = currentInput.trim();
+      if (!spec) return;
+
+      if (validateAndAddRepo(spec)) {
+        // Check if already added
+        if (repos.some((r) => r.spec === spec)) {
+          statusText.content = "⚠️ Repository already added";
+          statusText.fg = "#f59e0b";
+          return;
+        }
+
+        pendingRepo = parseRepoSpec(spec);
+        pendingReadOnly = false;
+        pendingLatest = false;
+        mode = "details";
+        repoInput.blur();
+        updateDetails();
+      }
+    }
+
+    function confirmAddRepo() {
+      if (!pendingRepo) return;
+      pendingRepo.readOnly = pendingReadOnly;
+      pendingRepo.latest = pendingLatest;
+      repos.push(pendingRepo);
+
+      pendingRepo = null;
+      pendingReadOnly = false;
+      pendingLatest = false;
+      mode = "spec";
+      currentInput = "";
+      repoInput.value = "";
+      repoInput.focus();
+      updateReposList();
+      updateMatches("");
+      updateDetails();
+      lastMatchIndex = -1;
+      lastMatchQuery = "";
+
+      statusText.content = "✓ Added successfully";
+      statusText.fg = "#10b981";
+
+      setTimeout(() => {
+        if (statusText.content?.toString() === "✓ Added successfully") {
+          statusText.content = "";
+        }
+      }, 2000);
+    }
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (mode === "details") {
+        if (key.name === "r") {
+          pendingReadOnly = !pendingReadOnly;
+          if (!pendingReadOnly) {
+            pendingLatest = false;
+          }
+          updateDetails();
+        } else if (key.name === "l") {
+          pendingLatest = !pendingLatest;
+          if (pendingLatest) {
+            pendingReadOnly = true;
+          }
+          updateDetails();
+        } else if (key.name === "escape" || key.name === "backspace") {
+          mode = "spec";
+          pendingRepo = null;
+          pendingReadOnly = false;
+          pendingLatest = false;
+          repoInput.focus();
+          updateDetails();
+        } else if (key.name === "return" || key.name === "enter") {
+          confirmAddRepo();
+        }
+      } else {
+        // Spec input mode
+        if (key.name === "escape") {
+          cleanup();
+          resolve({ repos, cancelled: true });
+        } else if (key.name === "return" || key.name === "enter") {
+          startRepoDetails();
+        } else if (key.name === "tab") {
+          const query = currentInput.trim();
+          const matches = getMatches(query);
+          if (matches.length === 0) return;
+
+          const currentIndex = matches.findIndex((spec) => spec === currentInput);
+          let nextIndex = 0;
+
+          if (currentIndex !== -1) {
+            nextIndex = (currentIndex + 1) % matches.length;
+          } else if (lastMatchQuery === query.toLowerCase() && lastMatchIndex >= 0) {
+            nextIndex = (lastMatchIndex + 1) % matches.length;
+          }
+
+          const match = matches[nextIndex];
+          if (!match) return;
+          repoInput.value = match;
+          repoInput.cursorPosition = match.length;
+          currentInput = match;
+          lastMatchIndex = nextIndex;
+          lastMatchQuery = query.toLowerCase();
+          validateAndAddRepo(match.trim());
+          updateMatches(currentInput, match);
+        } else if (key.name === "up") {
+          if (historySpecs.length === 0) return;
+          historyIndex = Math.max(0, historyIndex - 1);
+          const spec = historySpecs[historyIndex];
+          if (spec) applyHistorySpec(spec);
+        } else if (key.name === "down") {
+          if (historySpecs.length === 0) return;
+          historyIndex = Math.min(historySpecs.length - 1, historyIndex + 1);
+          const spec = historySpecs[historyIndex];
+          if (spec) applyHistorySpec(spec);
+        } else if (key.name === "d" && key.ctrl) {
+          // Ctrl+D to finish
+          cleanup();
+          resolve({ repos, cancelled: false });
+        }
+      }
+    };
+
+    repoInput.on("input", (value: string) => {
+      currentInput = value;
+      historyIndex = historySpecs.length;
+      lastMatchIndex = -1;
+      lastMatchQuery = value.trim().toLowerCase();
+      if (value.trim()) {
+        validateAndAddRepo(value.trim());
+      } else {
+        statusText.content = "";
+      }
+      updateMatches(value);
+    });
+
+    const cleanup = () => {
+      renderer.keyInput.off("keypress", handleKeypress);
+      repoInput.blur();
+      clearLayout(renderer);
+    };
+
+    renderer.keyInput.on("keypress", handleKeypress);
+    updateDetails();
+  });
+}