letmecook 0.0.21 → 0.0.23

package/src/ui/cooking-indicator.ts

@@ -0,0 +1,88 @@
+import { type CliRenderer, TextRenderable } from "@opentui/core";
+
+// [uncooked, cooked] emoji pairs
+const FOOD_PAIRS: [string, string][] = [
+  ["🦐", "🍤"], // shrimp
+  ["🥔", "🍟"], // potato
+  ["🐷", "🥓"], // bacon
+  ["🥚", "🍳"], // egg
+  ["🥩", "🍖"], // meat
+  ["🌽", "🍿"], // corn
+];
+
+const COUNT = 5;
+const FRAME_MS = 120;
+
+export interface CookingIndicator {
+  start: () => void;
+  stop: () => void;
+  isRunning: () => boolean;
+}
+
+export function createCookingIndicator(
+  renderer: CliRenderer,
+  parent: { add: (child: unknown) => void; remove: (id: string) => void },
+): CookingIndicator {
+  const pair = FOOD_PAIRS[Math.floor(Math.random() * FOOD_PAIRS.length)] || ["🦐", "🍤"];
+  const raw = pair[0];
+  const cooked = pair[1];
+
+  const indicator = new TextRenderable(renderer, {
+    id: "cooking-indicator",
+    content: "",
+    fg: "#f8fafc",
+  });
+  parent.add(indicator);
+
+  let frame = 1;
+  let direction = 1;
+  let interval: NodeJS.Timeout | null = null;
+
+  const render = () => {
+    let content = "";
+    for (let i = 0; i < COUNT; i++) {
+      if (i < frame) {
+        content += cooked;
+      } else {
+        content += raw;
+      }
+    }
+    indicator.content = content;
+  };
+
+  const tick = () => {
+    frame += direction;
+    if (frame > COUNT) {
+      frame = COUNT - 1;
+      direction = -1;
+    } else if (frame < 1) {
+      frame = 1;
+      direction = 1;
+    }
+    render();
+  };
+
+  const start = () => {
+    if (interval) return;
+    frame = 1;
+    direction = 1;
+    render();
+    interval = setInterval(tick, FRAME_MS);
+  };
+
+  const stop = () => {
+    if (interval) {
+      clearInterval(interval);
+      interval = null;
+    }
+    try {
+      parent.remove("cooking-indicator");
+    } catch {
+      // Already removed
+    }
+  };
+
+  const isRunning = () => interval !== null;
+
+  return { start, stop, isRunning };
+}

package/src/ui/main-menu.ts

@@ -12,6 +12,7 @@ import { showFooter, hideFooter } from "./common/footer";
 import { isEscape, isArrowUp, isArrowDown } from "./common/keyboard";
 
 export type MainMenuAction =
+  | { type: "chat" }
   | { type: "new-session" }
   | { type: "resume"; session: Session }
   | { type: "delete"; session: Session }
@@ -89,6 +90,12 @@ export function showMainMenu(renderer: CliRenderer, sessions: Session[]): Promis
         return;
       }
 
+      if (key.name === "c") {
+        cleanup();
+        resolve({ type: "chat" });
+        return;
+      }
+
       if (key.name === "n") {
         cleanup();
         resolve({ type: "new-session" });
@@ -119,6 +126,7 @@ export function showMainMenu(renderer: CliRenderer, sessions: Session[]): Promis
 
     // Show footer with context-aware actions
     const footerActions: string[] = [];
+    footerActions.push("c Chat");
     if (sessions.length > 0) {
       footerActions.push("Enter Open", "n New", "d Delete", "a Nuke");
     } else {

package/src/ui/new-session.ts

@@ -27,10 +27,10 @@ export function showNewSessionPrompt(
 
     repos.forEach((repo, i) => {
       const branch = repo.branch ? ` (${repo.branch})` : " (default)";
-      const refMarker = repo.reference ? " [Ref]" : "";
+      const roMarker = repo.readOnly ? " [Read-only]" : "";
       const repoText = new TextRenderable(renderer, {
         id: `repo-${i}`,
-        content: `  - ${repo.owner}/${repo.name}${branch}${refMarker}`,
+        content: `  - ${repo.owner}/${repo.name}${branch}${roMarker}`,
         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 reference repositories...", fg: "#38bdf8" };
+      return { content: "Refreshing read-only repositories...", fg: "#38bdf8" };
     case "done":
       return { content: "Ready!", fg: "#22c55e" };
     default:

package/src/ui/renderer.ts

@@ -102,19 +102,12 @@ export function createBaseLayout(r: CliRenderer, subtitle?: string): LayoutEleme
 
 export function clearLayout(r: CliRenderer): void {
   // Remove known elements (ignore if they don't exist)
-  try {
-    r.root.remove("main-container");
-  } catch {
-    // Element doesn't exist
-  }
-  try {
-    r.root.remove("title");
-  } catch {
-    // Element doesn't exist
-  }
-  try {
-    r.root.remove("content");
-  } catch {
-    // Element doesn't exist
+  const elements = ["main-container", "title", "content"];
+  for (const id of elements) {
+    try {
+      r.root.remove(id);
+    } catch {
+      // Element doesn't exist
+    }
   }
 }

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 Ref", "a Add repos");
+        customActions.push("l Toggle Read-only", "a Add repos");
       } else if (selectedTarget === "skill") {
         customActions.push("x Remove", "a Add repos");
       }
@@ -339,10 +339,11 @@ export function showSessionSettings(
         return;
       }
 
-      if (key.name === "r" && selectedTarget === "repo") {
+      if (key.name === "l" && selectedTarget === "repo") {
         const repo = updatedRepos[selectedRepoIndex];
         if (repo) {
-          repo.reference = !repo.reference;
+          repo.latest = !repo.latest;
+          repo.readOnly = repo.latest;
           updateReposList();
         }
         return;

package/src/validation.ts

@@ -0,0 +1,152 @@
+import {
+  RepoSpecSchema,
+  SessionManifestSchema,
+  NewSessionParamsSchema,
+  type RepoSpec,
+  type SessionManifest,
+  type NewSessionParams,
+} from "./schemas";
+
+export interface ValidationResult<T> {
+  success: boolean;
+  data?: T;
+  errors?: string[];
+}
+
+export function formatZodError(error: unknown): string[] {
+  if (
+    typeof error === "object" &&
+    error !== null &&
+    "issues" in error &&
+    Array.isArray((error as { issues: unknown[] }).issues)
+  ) {
+    const issues = (error as { issues: { path: PropertyKey[]; message: string }[] }).issues;
+    return issues.map((e) => {
+      const path = e.path.length > 0 ? String(e.path.join(".")) : "root";
+      return `${path}: ${e.message}`;
+    });
+  }
+  return ["Unknown validation error"];
+}
+
+export function validateRepoSpec(spec: string): RepoSpec {
+  const parsed = parseRepoSpec(spec);
+  const result = RepoSpecSchema.safeParse(parsed);
+
+  if (!result.success) {
+    const errors = formatZodError(result.error);
+    throw new Error(`Invalid repo spec: ${errors.join(", ")}`);
+  }
+
+  return result.data;
+}
+
+export function validateRepoSpecSafe(spec: string): ValidationResult<RepoSpec> {
+  try {
+    const parsed = parseRepoSpec(spec);
+    const result = RepoSpecSchema.safeParse(parsed);
+
+    if (!result.success) {
+      return {
+        success: false,
+        errors: formatZodError(result.error),
+      };
+    }
+
+    return {
+      success: true,
+      data: result.data,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      errors: [error instanceof Error ? error.message : "Unknown error"],
+    };
+  }
+}
+
+export function validateSessionManifest(manifest: unknown): SessionManifest {
+  const result = SessionManifestSchema.safeParse(manifest);
+
+  if (!result.success) {
+    const errors = formatZodError(result.error);
+    throw new Error(`Invalid session manifest: ${errors.join(", ")}`);
+  }
+
+  return result.data;
+}
+
+export function validateSessionManifestSafe(manifest: unknown): ValidationResult<SessionManifest> {
+  const result = SessionManifestSchema.safeParse(manifest);
+
+  if (!result.success) {
+    return {
+      success: false,
+      errors: formatZodError(result.error),
+    };
+  }
+
+  return {
+    success: true,
+    data: result.data,
+  };
+}
+
+export function validateNewSessionParams(params: unknown): NewSessionParams {
+  const result = NewSessionParamsSchema.safeParse(params);
+
+  if (!result.success) {
+    const errors = formatZodError(result.error);
+    throw new Error(`Invalid session params: ${errors.join(", ")}`);
+  }
+
+  return result.data;
+}
+
+export function validateNewSessionParamsSafe(params: unknown): ValidationResult<NewSessionParams> {
+  const result = NewSessionParamsSchema.safeParse(params);
+
+  if (!result.success) {
+    return {
+      success: false,
+      errors: formatZodError(result.error),
+    };
+  }
+
+  return {
+    success: true,
+    data: result.data,
+  };
+}
+
+function parseRepoSpec(spec: string): {
+  spec: string;
+  owner: string;
+  name: string;
+  branch?: string;
+  dir: string;
+} {
+  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,
+  };
+}

package/src/reference-repo.ts

@@ -1,288 +0,0 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { mkdir, symlink, readlink, lstat, readdir, rm } from "node:fs/promises";
-import type { RepoSpec } from "./types";
-import { readProcessOutputWithBuffer } from "./utils/stream";
-
-const LETMECOOK_DIR = join(homedir(), ".letmecook");
-export const REFERENCES_DIR = join(LETMECOOK_DIR, "references");
-
-export interface RefreshResult {
-  repo: RepoSpec;
-  status: "updated" | "up-to-date" | "skipped" | "error";
-  reason?: string;
-}
-
-export type RefreshProgressStatus = "refreshing" | "updated" | "up-to-date" | "skipped" | "error";
-
-/**
- * Get the path where a reference repo should be cached.
- * Format: ~/.letmecook/references/{owner}/{name}/{branch|HEAD}
- */
-export function getReferencePath(repo: RepoSpec): string {
-  const branchDir = repo.branch || "HEAD";
-  return join(REFERENCES_DIR, repo.owner, repo.name, branchDir);
-}
-
-/**
- * Ensure the references directory exists.
- */
-export async function ensureReferencesDir(): Promise<void> {
-  await mkdir(REFERENCES_DIR, { recursive: true });
-}
-
-/**
- * Check if a path is a symlink.
- */
-export async function isSymlink(path: string): Promise<boolean> {
-  try {
-    const stats = await lstat(path);
-    return stats.isSymbolicLink();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Clone a repo to the reference cache if not already present.
- * Returns the path to the cached repo.
- */
-export async function ensureReferenceRepo(
-  repo: RepoSpec,
-  onProgress?: (status: "cloning" | "done" | "error", outputLines?: string[]) => void,
-): Promise<string> {
-  const refPath = getReferencePath(repo);
-
-  // Check if already cached
-  const gitDir = join(refPath, ".git");
-  const gitDirFile = Bun.file(gitDir);
-  if (await gitDirFile.exists()) {
-    onProgress?.("done", ["Already cached"]);
-    return refPath;
-  }
-
-  // Ensure parent directories exist
-  await mkdir(join(REFERENCES_DIR, repo.owner, repo.name), { recursive: true });
-
-  onProgress?.("cloning");
-
-  const url = `https://github.com/${repo.owner}/${repo.name}.git`;
-  const args = repo.branch
-    ? [
-        "git",
-        "clone",
-        "--depth",
-        "1",
-        "--single-branch",
-        "--branch",
-        repo.branch,
-        "--progress",
-        url,
-        refPath,
-      ]
-    : ["git", "clone", "--depth", "1", "--single-branch", "--progress", url, refPath];
-
-  const proc = Bun.spawn(args, {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const { success, output } = await readProcessOutputWithBuffer(proc, {
-    maxBufferLines: 5,
-    onBufferUpdate: (buffer) => onProgress?.("cloning", buffer),
-  });
-
-  if (!success) {
-    onProgress?.("error", output);
-    throw new Error(`Failed to clone reference repo ${repo.owner}/${repo.name}`);
-  }
-
-  onProgress?.("done", output);
-  return refPath;
-}
-
-/**
- * Refresh a cached reference repo with git pull.
- */
-export async function refreshReferenceRepo(
-  repo: RepoSpec,
-  onProgress?: (status: RefreshProgressStatus, outputLines?: string[]) => void,
-): Promise<RefreshResult> {
-  const refPath = getReferencePath(repo);
-
-  // Check if cached repo exists
-  const gitDir = join(refPath, ".git");
-  const gitDirFile = Bun.file(gitDir);
-  if (!(await gitDirFile.exists())) {
-    // Try to clone it
-    try {
-      await ensureReferenceRepo(repo, (status, lines) => {
-        if (status === "cloning") onProgress?.("refreshing", lines);
-        else if (status === "done") onProgress?.("updated", lines);
-        else onProgress?.("error", lines);
-      });
-      return { repo, status: "updated", reason: "newly cloned" };
-    } catch (error) {
-      return {
-        repo,
-        status: "error",
-        reason: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-
-  onProgress?.("refreshing", [`Pulling ${repo.owner}/${repo.name}...`]);
-
-  const proc = Bun.spawn(["git", "-C", refPath, "pull", "--ff-only", "--depth", "1"], {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
-    maxBufferLines: 5,
-    onBufferUpdate: (buffer) => onProgress?.("refreshing", buffer),
-  });
-
-  if (!success) {
-    const reason = fullOutput.trim() || "git pull failed";
-    onProgress?.("error", output.length > 0 ? output : [reason]);
-    return { repo, status: "error", reason };
-  }
-
-  const normalized = fullOutput.toLowerCase();
-  const upToDate =
-    normalized.includes("already up to date") || normalized.includes("already up-to-date");
-
-  const status = upToDate ? "up-to-date" : "updated";
-  onProgress?.(status, output);
-  return { repo, status };
-}
-
-/**
- * Create a symlink from session directory to the cached reference repo.
- */
-export async function linkReferenceRepo(repo: RepoSpec, sessionPath: string): Promise<void> {
-  const refPath = getReferencePath(repo);
-  const linkPath = join(sessionPath, repo.dir);
-
-  // Check if link already exists and is valid
-  if (await isSymlink(linkPath)) {
-    try {
-      const target = await readlink(linkPath);
-      if (target === refPath) {
-        return; // Already correctly linked
-      }
-      // Remove incorrect symlink
-      await rm(linkPath);
-    } catch {
-      // Remove broken symlink
-      await rm(linkPath);
-    }
-  }
-
-  await symlink(refPath, linkPath);
-}
-
-/**
- * Verify that a symlink is valid and points to the correct reference.
- * Returns true if valid, false if needs repair.
- */
-export async function verifyReferenceLink(repo: RepoSpec, sessionPath: string): Promise<boolean> {
-  const refPath = getReferencePath(repo);
-  const linkPath = join(sessionPath, repo.dir);
-
-  if (!(await isSymlink(linkPath))) {
-    return false;
-  }
-
-  try {
-    const target = await readlink(linkPath);
-    // Check if target matches expected reference path
-    if (target !== refPath) {
-      return false;
-    }
-    // Check if target actually exists
-    const gitDir = Bun.file(join(refPath, ".git"));
-    return await gitDir.exists();
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Repair a broken reference link by re-ensuring the cache and re-linking.
- */
-export async function repairReferenceLink(
-  repo: RepoSpec,
-  sessionPath: string,
-  onProgress?: (status: "cloning" | "done" | "error", outputLines?: string[]) => void,
-): Promise<void> {
-  const linkPath = join(sessionPath, repo.dir);
-
-  // Remove existing link/directory
-  try {
-    await rm(linkPath, { recursive: true, force: true });
-  } catch {
-    // Ignore
-  }
-
-  // Ensure reference is cached
-  await ensureReferenceRepo(repo, onProgress);
-
-  // Create symlink
-  await linkReferenceRepo(repo, sessionPath);
-}
-
-/**
- * Clean up orphaned references that aren't used by any session.
- * Returns the number of references removed.
- */
-export async function cleanOrphanedReferences(): Promise<number> {
-  // This is a placeholder for future implementation
-  // Would need to:
-  // 1. List all sessions
-  // 2. Collect all reference paths in use
-  // 3. Walk references dir and remove unused entries
-  return 0;
-}
-
-/**
- * List all cached references.
- */
-export async function listCachedReferences(): Promise<
-  Array<{ owner: string; name: string; branch: string; path: string }>
-> {
-  const refs: Array<{ owner: string; name: string; branch: string; path: string }> = [];
-
-  try {
-    const owners = await readdir(REFERENCES_DIR);
-
-    for (const owner of owners) {
-      const ownerPath = join(REFERENCES_DIR, owner);
-      const ownerStat = await lstat(ownerPath);
-      if (!ownerStat.isDirectory()) continue;
-
-      const names = await readdir(ownerPath);
-
-      for (const name of names) {
-        const namePath = join(ownerPath, name);
-        const nameStat = await lstat(namePath);
-        if (!nameStat.isDirectory()) continue;
-
-        const branches = await readdir(namePath);
-
-        for (const branch of branches) {
-          const branchPath = join(namePath, branch);
-          const branchStat = await lstat(branchPath);
-          if (!branchStat.isDirectory()) continue;
-
-          refs.push({ owner, name, branch, path: branchPath });
-        }
-      }
-    }
-  } catch {
-    // References dir doesn't exist yet
-  }
-
-  return refs;
-}