letmecook 0.0.21 → 0.0.23

package/src/cli-mode.ts

@@ -0,0 +1,366 @@
+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";
+import { ChatLogger } from "./chat-logger";
+
+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
+  letmecook --cli --logs                              List chat logs
+  letmecook --cli --logs --view <log-id>              View chat log
+  letmecook --cli --logs --delete <log-id>            Delete chat log
+  letmecook --cli --logs --nuke [--yes]               Delete all chat logs
+
+Examples:
+  letmecook --cli microsoft/playwright
+  letmecook --cli facebook/react openai/agents
+  letmecook --cli --resume playwright-agent-tests
+  letmecook --cli --logs
+  letmecook --cli --logs --view 1700000000000-abc123
+  `);
+}
+
+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 async function handleChatLogsList(): Promise<void> {
+  const logs = await ChatLogger.listLogs();
+  if (logs.length === 0) {
+    console.log("No chat logs found.");
+    return;
+  }
+
+  console.log("Chat Logs:");
+  for (const log of logs) {
+    console.log(`  ID: ${log.id}`);
+    console.log(`  Created: ${log.createdAt}`);
+    console.log("");
+  }
+}
+
+export async function handleChatLogView(logId: string): Promise<void> {
+  const log = await ChatLogger.getLog(logId);
+  if (!log) {
+    console.error(`Chat log not found: ${logId}`);
+    process.exit(1);
+  }
+
+  console.log(JSON.stringify(log, null, 2));
+}
+
+export async function handleChatLogDelete(logId: string): Promise<void> {
+  const log = await ChatLogger.getLog(logId);
+  if (!log) {
+    console.error(`Chat log not found: ${logId}`);
+    process.exit(1);
+  }
+
+  const deleted = await ChatLogger.deleteLog(logId);
+  if (deleted) {
+    console.log(`Deleted chat log: ${logId}`);
+  } else {
+    console.error(`Failed to delete chat log: ${logId}`);
+    process.exit(1);
+  }
+}
+
+export async function handleChatLogsNuke(skipConfirm = false): Promise<void> {
+  const logs = await ChatLogger.listLogs();
+  if (logs.length === 0) {
+    console.log("No chat logs to delete.");
+    return;
+  }
+
+  // Skip confirmation if --yes flag or non-interactive (piped input)
+  if (skipConfirm || !process.stdin.isTTY) {
+    const count = await ChatLogger.deleteAllLogs();
+    console.log(`Deleted ${count} chat log(s).`);
+    return;
+  }
+
+  // Prompt for confirmation
+  process.stdout.write(`Delete all ${logs.length} chat logs? [y/N] `);
+  const response = await new Promise<string>((resolve) => {
+    process.stdin.once("data", (data) => {
+      resolve(data.toString().trim().toLowerCase());
+    });
+  });
+
+  if (response === "y" || response === "yes") {
+    const count = await ChatLogger.deleteAllLogs();
+    console.log(`\nDeleted ${count} chat log(s).`);
+  } 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 === "--logs") {
+    const secondArg = args[1];
+    if (secondArg === "--view") {
+      const logId = args[2];
+      if (!logId) {
+        console.error("Missing log ID. Usage: letmecook --cli --logs --view <log-id>");
+        process.exit(1);
+      }
+      await handleChatLogView(logId);
+    } else if (secondArg === "--delete") {
+      const logId = args[2];
+      if (!logId) {
+        console.error("Missing log ID. Usage: letmecook --cli --logs --delete <log-id>");
+        process.exit(1);
+      }
+      await handleChatLogDelete(logId);
+    } else if (secondArg === "--nuke") {
+      const hasYes = args.includes("--yes") || args.includes("-y");
+      await handleChatLogsNuke(hasYes);
+    } else {
+      await handleChatLogsList();
+    }
+  } 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/config-builder.ts

@@ -0,0 +1,147 @@
+import { EventEmitter } from "events";
+import type { ChatConfig } from "./flows/chat-to-config";
+
+export interface PartialConfig {
+  repos: string[];
+  skills: string[];
+  goal: string | null;
+}
+
+export interface ConfigBuilderEvents {
+  "config-changed": (config: PartialConfig) => void;
+  "repo-added": (repo: string) => void;
+  "repo-removed": (repo: string) => void;
+  "skill-added": (skill: string) => void;
+  "goal-set": (goal: string) => void;
+}
+
+export class ConfigBuilder extends EventEmitter {
+  private _config: PartialConfig;
+
+  constructor() {
+    super();
+    this._config = {
+      repos: [],
+      skills: [],
+      goal: null,
+    };
+  }
+
+  get config(): PartialConfig {
+    return { ...this._config };
+  }
+
+  /**
+   * Add a repository to the config
+   * @returns true if added, false if already exists
+   */
+  addRepo(repo: string): boolean {
+    const normalized = repo.trim();
+    if (!normalized) return false;
+
+    // Check if already exists
+    if (this._config.repos.includes(normalized)) {
+      return false;
+    }
+
+    this._config.repos.push(normalized);
+    this.emit("repo-added", normalized);
+    this.emit("config-changed", this.config);
+    return true;
+  }
+
+  /**
+   * Remove a repository from the config
+   * @returns true if removed, false if not found
+   */
+  removeRepo(repo: string): boolean {
+    const normalized = repo.trim();
+    const index = this._config.repos.indexOf(normalized);
+
+    if (index === -1) {
+      return false;
+    }
+
+    this._config.repos.splice(index, 1);
+    this.emit("repo-removed", normalized);
+    this.emit("config-changed", this.config);
+    return true;
+  }
+
+  /**
+   * Add a skill to the config
+   * @returns true if added, false if already exists
+   */
+  addSkill(skill: string): boolean {
+    const normalized = skill.trim();
+    if (!normalized) return false;
+
+    // Check if already exists
+    if (this._config.skills.includes(normalized)) {
+      return false;
+    }
+
+    this._config.skills.push(normalized);
+    this.emit("skill-added", normalized);
+    this.emit("config-changed", this.config);
+    return true;
+  }
+
+  /**
+   * Remove a skill from the config
+   * @returns true if removed, false if not found
+   */
+  removeSkill(skill: string): boolean {
+    const normalized = skill.trim();
+    const index = this._config.skills.indexOf(normalized);
+
+    if (index === -1) {
+      return false;
+    }
+
+    this._config.skills.splice(index, 1);
+    this.emit("config-changed", this.config);
+    return true;
+  }
+
+  /**
+   * Set the goal for the config
+   */
+  setGoal(goal: string): void {
+    const normalized = goal.trim();
+    this._config.goal = normalized || null;
+    this.emit("goal-set", normalized);
+    this.emit("config-changed", this.config);
+  }
+
+  /**
+   * Check if the config has minimum requirements to proceed
+   * Currently requires at least one repo
+   */
+  isReady(): boolean {
+    return this._config.repos.length > 0;
+  }
+
+  /**
+   * Convert to final ChatConfig format
+   */
+  toFinalConfig(): ChatConfig {
+    return {
+      repos: [...this._config.repos],
+      skills: [...this._config.skills],
+      goal: this._config.goal || "",
+    };
+  }
+
+  /**
+   * Reset the config to initial state
+   */
+  reset(): void {
+    this._config = {
+      repos: [],
+      skills: [],
+      goal: null,
+    };
+    this.emit("config-changed", this.config);
+  }
+}

package/src/env.ts

@@ -0,0 +1,76 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const LETMECOOK_DIR = join(homedir(), ".letmecook");
+
+export async function loadEnvAsync(): Promise<void> {
+  // Check if AI_GATEWAY_API_KEY is already set
+  if (process.env.AI_GATEWAY_API_KEY) {
+    return;
+  }
+
+  // Try loading from ~/.letmecook/.env
+  const globalEnvPath = join(LETMECOOK_DIR, ".env");
+  const globalEnvFile = Bun.file(globalEnvPath);
+
+  // Try loading from ./.env (current directory)
+  const localEnvPath = join(process.cwd(), ".env");
+  const localEnvFile = Bun.file(localEnvPath);
+
+  // Load global first, then local (local overrides)
+  try {
+    if (await globalEnvFile.exists()) {
+      const content = await globalEnvFile.text();
+      parseAndSetEnv(content);
+    }
+  } catch {
+    // Ignore errors
+  }
+
+  try {
+    if (await localEnvFile.exists()) {
+      const content = await localEnvFile.text();
+      parseAndSetEnv(content);
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+export function loadEnv(): void {
+  // Synchronous version - fire and forget
+  loadEnvAsync().catch(() => {
+    // Ignore errors
+  });
+}
+
+function parseAndSetEnv(content: string): void {
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+
+    // Skip comments and empty lines
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const equalIndex = trimmed.indexOf("=");
+    if (equalIndex === -1) {
+      continue;
+    }
+
+    const key = trimmed.slice(0, equalIndex).trim();
+    let value = trimmed.slice(equalIndex + 1).trim();
+
+    // Remove quotes if present
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+
+    if (key) {
+      process.env[key] = value;
+    }
+  }
+}