letmecook 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,120 @@
+# letmecook
+
+Multi-repo workspace manager for AI coding sessions. Clone multiple GitHub repos into a persistent session and launch opencode with an interactive TUI.
+
+## Features
+
+- **Interactive TUI** - User-friendly guided experience built with [OpenTUI](https://github.com/sst/opentui)
+- **Agent transparency** - See exactly what the agent plans to do before execution
+- **Real-time progress** - Live updates showing cloning and preparation
+- **Manual Setup Prompt** - Run custom setup commands (e.g., `npm install`) before starting
+- **Session-based workflows** - Workspaces persist until you explicitly nuke them
+- **AI-generated session names** - Memorable names based on repos and your goal
+- **Multi-repo support** - Clone multiple repos with optional branch specification
+- **AGENTS.md generation** - Auto-generated context file for AI agents
+- **100% backward compatible** - All existing CLI commands continue to work
+
+## Installation
+
+```bash
+bun install
+bun link
+```
+
+## Setup
+
+Create a `.env` file with your AI Gateway API key (for session naming):
+
+```bash
+AI_GATEWAY_API_KEY=your-key-here
+```
+
+## Usage
+
+### Interactive Mode (Recommended)
+
+Launch the user-friendly TUI interface:
+
+```bash
+letmecook
+```
+
+The TUI guides you through:
+
+1. **Adding repositories** - Interactive repo collection
+2. **Session goal** - Describe what you want to work on
+3. **Agent proposal transparency** - See exactly what the agent plans to do
+4. **Real-time progress** - Live updates showing cloning progress
+5. **Manual Setup** - Option to run commands like `npm install` before launching
+6. **Interactive CLI** - Enter opencode with full context
+
+### CLI Mode (Backward Compatible)
+
+All existing commands continue to work exactly as before:
+
+```bash
+# Single repo
+letmecook microsoft/playwright
+
+# Multiple repos
+letmecook microsoft/playwright openai/agents
+
+# With specific branches
+letmecook facebook/react:experimental vercel/next.js:canary
+
+# Explicit TUI mode
+letmecook --tui
+```
+
+### Manage sessions
+
+```bash
+# List all sessions (interactive)
+letmecook --list
+
+# Resume a specific session
+letmecook --resume <session-name>
+
+# Delete a session
+letmecook --nuke <session-name>
+
+# Delete all sessions
+letmecook --nuke-all
+```
+
+### Session persistence
+
+When you exit opencode, you're prompted to keep or nuke the session. Sessions are kept by default - just press Enter.
+
+To resume later:
+
+```bash
+letmecook --resume <session-name>
+```
+
+## Session Structure
+
+```
+~/.letmecook/sessions/<session-name>/
+├── manifest.json     # Session metadata
+├── AGENTS.md         # Context for AI agents
+├── repo1/            # Cloned repository
+└── repo2/            # Another cloned repository
+```
+
+## Requirements
+
+- [Bun](https://bun.sh)
+- [opencode](https://opencode.ai) - must be in PATH
+- [Zig](https://ziglang.org) - required by OpenTUI
+- `AI_GATEWAY_API_KEY` environment variable (for AI naming)
+
+## Development
+
+```bash
+# Run directly
+bun run index.ts microsoft/playwright
+
+# Type check
+bun run tsc --noEmit
+```

package/index.ts

@@ -0,0 +1,234 @@
+#!/usr/bin/env bun
+
+import { parseRepoSpec, type RepoSpec } from "./src/types";
+import { listSessions, getSession, updateLastAccessed, deleteAllSessions } from "./src/sessions";
+import { createRenderer, destroyRenderer } from "./src/ui/renderer";
+import { showNewSessionPrompt } from "./src/ui/new-session";
+import { showSessionList } from "./src/ui/list";
+import { createNewSession, resumeSession } from "./src/flows";
+import { handleTUIMode } from "./src/tui-mode";
+
+function printUsage(): void {
+  console.log(`
+letmecook - Multi-repo workspace manager for AI coding sessions
+
+Usage:
+  letmecook                                    Launch interactive TUI (recommended)
+  letmecook --tui                              Launch interactive TUI explicitly
+  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 --help                             Show this help
+
+Examples:
+  # Interactive mode (new - recommended)
+  letmecook
+
+  # CLI mode
+  letmecook microsoft/playwright
+  letmecook facebook/react openai/agents
+  letmecook --resume playwright-agent-tests
+  `);
+}
+
+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);
+  }
+}
+
+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-all":
+          const count = await deleteAllSessions();
+          destroyRenderer();
+          console.log(`\nNuked ${count} session(s).`);
+          return;
+
+        case "quit":
+          destroyRenderer();
+          return;
+      }
+    }
+  } catch (error) {
+    destroyRenderer();
+    console.error("\nError:", error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+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,
+  });
+}
+
+async function handleNuke(_sessionName: string): Promise<void> {
+  console.log("[TODO] Nuke session flow");
+}
+
+async function handleNukeAll(): Promise<void> {
+  const count = await deleteAllSessions();
+  console.log(`Nuked ${count} session(s).`);
+}
+
+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 --resume <session-name>");
+      process.exit(1);
+    }
+    await handleResume(sessionName);
+  } else if (firstArg === "--nuke") {
+    const sessionName = args[1];
+    if (!sessionName) {
+      console.error("Missing session name. Usage: letmecook --nuke <session-name>");
+      process.exit(1);
+    }
+    await handleNuke(sessionName);
+  } else if (firstArg === "--nuke-all") {
+    await handleNukeAll();
+  } else if (firstArg?.startsWith("-")) {
+    console.error(`Unknown option: ${firstArg}`);
+    printUsage();
+    process.exit(1);
+  } else {
+    try {
+      const repos = parseRepos(args);
+      await handleNewSessionCLI(repos);
+    } catch (error) {
+      console.error("Error:", error instanceof Error ? error.message : error);
+      process.exit(1);
+    }
+  }
+}
+
+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;
+}
+
+console.clear();
+const args = process.argv.slice(2);
+const firstArg = args[0];
+
+if (args.length === 0 || firstArg === "--help" || firstArg === "-h") {
+  printUsage();
+  process.exit(0);
+}
+
+if (firstArg === "--tui") {
+  await handleTUIMode();
+} else if (args.length === 0) {
+  await handleTUIMode();
+} else {
+  await handleCLIMode(args);
+}

package/package.json

@@ -1,11 +1,47 @@
 {
   "name": "letmecook",
-  "version": "0.0.1",
-  "description": "Coming soon",
+  "version": "0.0.2",
+  "bin": {
+    "letmecook": "./index.ts"
+  },
+  "type": "module",
+  "module": "index.ts",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/rustydotwtf/letmecook.git"
+    "url": "https://github.com/rustydotwtf/letmecook.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
+  "files": [
+    "index.ts",
+    "src"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "scripts": {
+    "prepare": "husky",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "lint:ci": "oxlint --type-aware --deny-warnings --tsconfig ./tsconfig.json",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "check": "bun run lint && bun run format:check",
+    "fix": "bun run lint:fix && bun run format"
+  },
+  "dependencies": {
+    "@opentui/core": "^0.1.63",
+    "ai": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "husky": "^9.1.7",
+    "oxfmt": "^0.26.0",
+    "oxlint": "^1.41.0"
   },
-  "author": "",
-  "license": "MIT"
+  "peerDependencies": {
+    "typescript": "^5"
+  }
 }

package/src/agents-md.ts

@@ -0,0 +1,115 @@
+import { join } from "node:path";
+import { symlink } from "node:fs/promises";
+import type { Session } from "./types";
+
+export function generateAgentsMd(session: Session): string {
+  const createdDate = new Date(session.created).toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+
+  const hasReadOnlyRepos = session.repos.some((repo) => repo.readOnly);
+  const hasLatestRepos = session.repos.some((repo) => repo.latest);
+  const hasSkills = session.skills && session.skills.length > 0;
+
+  const repoRows = session.repos
+    .map((repo) => {
+      const branch = repo.branch || "default";
+      const url = `https://github.com/${repo.owner}/${repo.name}`;
+      const readOnlyStatus = repo.readOnly ? "**YES**" : "no";
+      const latestStatus = repo.latest ? "**YES**" : "no";
+      return `| \`${repo.dir}/\` | [${repo.owner}/${repo.name}](${url}) | ${branch} | ${readOnlyStatus} | ${latestStatus} |`;
+    })
+    .join("\n");
+
+  const readOnlyRepos = session.repos.filter((repo) => repo.readOnly);
+  const latestRepos = session.repos.filter((repo) => repo.latest);
+
+  const skillsSection = hasSkills
+    ? `
+## 🎯 Skills
+
+Installed skill packages (managed by bunx skills):
+
+${(session.skills || []).map((skill) => `- \`${skill}\``).join("\n")}
+
+These skills are available for use in this session and are automatically updated before launching.
+`
+    : "";
+
+  const readOnlyWarning = hasReadOnlyRepos
+    ? `
+## ⚠️ Read-Only Repositories
+
+**WARNING: The following repositories are marked as READ-ONLY:**
+
+${readOnlyRepos.map((repo) => `- \`${repo.dir}/\` (${repo.owner}/${repo.name})`).join("\n")}
+
+**AI agents must NOT:**
+- Create, modify, or delete any files in these directories
+- Make commits affecting these repositories
+- Use bash commands to circumvent file permissions
+
+**Why are these read-only?**
+These repositories are included for reference only. The user wants to read and understand the code without risk of accidental modifications.
+`
+    : "";
+
+  const latestNotice = hasLatestRepos
+    ? `
+## 🔄 Latest Repositories
+
+These repositories are pinned to **Latest** and will be refreshed before resuming the session (only if clean).
+
+${latestRepos.map((repo) => `- \`${repo.dir}/\` (${repo.owner}/${repo.name})`).join("\n")}
+`
+    : "";
+
+  return `# letmecook Session: ${session.name}
+
+${session.goal ? `> ${session.goal}\n` : ""}
+## Session Info
+- **Created**: ${createdDate}
+
+## Repositories
+
+| Directory | Repository | Branch | Read-Only | Latest |
+|-----------|------------|--------|-----------|--------|
+${repoRows}
+${readOnlyWarning}
+${latestNotice}
+${skillsSection}
+## Important Notes
+
+- This is a **multi-repo workspace** - each subdirectory is a separate git repository
+- Make commits within individual repo directories, not from the workspace root
+- This workspace root is NOT a git repository
+- Your changes persist until you explicitly nuke the session
+
+## Resume This Session
+
+\`\`\`bash
+letmecook --resume ${session.name}
+\`\`\`
+`;
+}
+
+export async function writeAgentsMd(session: Session): Promise<void> {
+  const content = generateAgentsMd(session);
+  const path = join(session.path, "AGENTS.md");
+  await Bun.write(path, content);
+}
+
+export async function createClaudeMdSymlink(sessionPath: string): Promise<void> {
+  const symlinkPath = join(sessionPath, "CLAUDE.md");
+  try {
+    await symlink("AGENTS.md", symlinkPath);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code !== "EEXIST") {
+      console.warn(`Could not create CLAUDE.md symlink: ${error}`);
+    }
+  }
+}

package/src/flows/add-repos.ts

@@ -0,0 +1,57 @@
+import type { CliRenderer } from "@opentui/core";
+import type { Session } from "../types";
+import { updateSessionRepos } from "../sessions";
+import { cloneAllRepos } from "../git";
+import { writeAgentsMd } from "../agents-md";
+import { recordRepoHistory } from "../repo-history";
+import { showAddReposPrompt } from "../ui/add-repos";
+
+export interface AddReposParams {
+  renderer: CliRenderer;
+  session: Session;
+}
+
+export interface AddReposResult {
+  session: Session;
+  cancelled: boolean;
+}
+
+export async function addReposFlow(params: AddReposParams): Promise<AddReposResult> {
+  const { renderer, session } = params;
+
+  const addResult = await showAddReposPrompt(renderer);
+
+  if (!addResult.cancelled && addResult.repos.length > 0) {
+    const existingSpecs = new Set(session.repos.map((r) => r.spec));
+    const newRepos = addResult.repos.filter((r) => !existingSpecs.has(r.spec));
+
+    if (newRepos.length > 0) {
+      console.log(`\nCloning ${newRepos.length} new repository(ies)...`);
+
+      await cloneAllRepos(newRepos, session.path, (repoIndex, status) => {
+        const repo = newRepos[repoIndex];
+        if (repo) {
+          if (status === "done") {
+            console.log(`  ✓ ${repo.owner}/${repo.name}`);
+          } else if (status === "error") {
+            console.log(`  ✗ ${repo.owner}/${repo.name} (failed)`);
+          }
+        }
+      });
+
+      const allRepos = [...session.repos, ...newRepos];
+      const updatedSession = await updateSessionRepos(session.name, allRepos);
+      const nextSession = updatedSession ?? session;
+
+      await recordRepoHistory(newRepos);
+      await writeAgentsMd(nextSession);
+
+      console.log("\n✅ Repositories added.\n");
+      return { session: nextSession, cancelled: false };
+    }
+
+    console.log("\nNo new repositories to add (all already in session).\n");
+  }
+
+  return { session, cancelled: addResult.cancelled };
+}

package/src/flows/add-skills.ts

@@ -0,0 +1,57 @@
+import type { CliRenderer } from "@opentui/core";
+import type { Session } from "../types";
+import { updateSessionSkills } from "../sessions";
+import { writeAgentsMd } from "../agents-md";
+import { addSkillToSession } from "../skills";
+import { showSkillsPrompt } from "../ui/skills";
+
+export interface AddSkillsParams {
+  renderer: CliRenderer;
+  session: Session;
+}
+
+export interface AddSkillsResult {
+  session: Session;
+  cancelled: boolean;
+}
+
+export async function addSkillsFlow(params: AddSkillsParams): Promise<AddSkillsResult> {
+  const { renderer, session } = params;
+
+  const { skills, cancelled } = await showSkillsPrompt(renderer, session.skills || []);
+
+  if (!cancelled && skills.length > 0) {
+    const existingSkills = new Set(session.skills || []);
+    const newSkills = skills.filter((s) => !existingSkills.has(s));
+
+    if (newSkills.length > 0) {
+      console.log(`\nAdding ${newSkills.length} skill package(s)...`);
+
+      for (const skill of newSkills) {
+        console.log(`  Adding ${skill}...`);
+        const { success } = await addSkillToSession(session, skill, (output) => {
+          console.log(`    ${output}`);
+        });
+
+        if (success) {
+          console.log(`  ✓ ${skill}`);
+        } else {
+          console.log(`  ✗ ${skill} (addition failed)`);
+        }
+      }
+
+      const allSkills = [...(session.skills || []), ...newSkills];
+      const updatedSession = await updateSessionSkills(session.name, allSkills);
+
+      if (updatedSession) {
+        await writeAgentsMd(updatedSession);
+        console.log("\n✅ Skills added.\n");
+        return { session: updatedSession, cancelled: false };
+      }
+    }
+
+    console.log("\nNo new skills to add (all already in session).\n");
+  }
+
+  return { session, cancelled };
+}