letmecook 0.0.14 → 0.0.16

package/src/reference-repo.ts

@@ -0,0 +1,288 @@
+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;
+}

package/src/tui-mode.ts

@@ -9,9 +9,11 @@ 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 { showQuitWarning } from "./ui/background-warning";
 import type { Session } from "./types";
 import { createNewSession, resumeSession } from "./flows";
 import { listSessions, deleteSession, updateLastAccessed, updateSessionSettings } from "./sessions";
+import { getRunningProcesses, killAllProcesses } from "./process-registry";
 
 export async function handleTUIMode(): Promise<void> {
   let renderer = await createRenderer();
@@ -39,10 +41,21 @@ export async function handleTUIMode(): Promise<void> {
           break;
         }
 
-        case "quit":
+        case "quit": {
+          const runningProcesses = await getRunningProcesses();
+          if (runningProcesses.length > 0) {
+            const choice = await showQuitWarning(renderer, runningProcesses);
+            if (choice === "cancel") {
+              break; // Stay in main loop
+            }
+            if (choice === "kill") {
+              await killAllProcesses();
+            }
+          }
           destroyRenderer();
           console.log("\nGoodbye!");
           return;
+        }
       }
     }
   } catch (error) {

package/src/types.ts

@@ -9,10 +9,8 @@ export interface RepoSpec {
   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;
+  /** Whether this resource is a reference (symlinked from shared cache, read-only, auto-refreshed) */
+  reference?: boolean;
 }
 
 export interface SessionManifest {

package/src/ui/add-repos.ts

@@ -22,12 +22,13 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
 
     const repos: RepoSpec[] = [];
     let currentInput = "";
-    let currentReadOnly = false;
-    let currentLatest = false;
+    let currentReference = false;
     let currentValidRepo: RepoSpec | null = null;
     let selectedMatchIndex = -1; // -1 means no match selected, user is typing freely
     let lastQuery = ""; // Track the query that generated current matches
     let isNavigating = false; // Flag to prevent input handler from resetting when navigating
+    let isConfirming = false; // Flag for confirmation mode (showing checkboxes)
+    let confirmOptionIndex = 0; // 0 = reference, 1 = confirm button
 
     // Repository input
     const repoLabel = new TextRenderable(renderer, {
@@ -77,21 +78,21 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
     });
     content.add(detailsLabel);
 
-    const detailsReadOnly = new TextRenderable(renderer, {
-      id: "details-readonly",
+    const detailsReference = new TextRenderable(renderer, {
+      id: "details-reference",
       content: "",
       fg: "#94a3b8",
       marginTop: 0,
     });
-    content.add(detailsReadOnly);
+    content.add(detailsReference);
 
-    const detailsLatest = new TextRenderable(renderer, {
-      id: "details-latest",
+    const confirmButton = new TextRenderable(renderer, {
+      id: "confirm-button",
       content: "",
-      fg: "#94a3b8",
-      marginTop: 0,
+      fg: "#10b981",
+      marginTop: 1,
     });
-    content.add(detailsLatest);
+    content.add(confirmButton);
 
     repoInput.onPaste = (event) => {
       const text = event.text.replace(/[\r\n]+/g, "");
@@ -102,8 +103,7 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
         const repo = validateRepo(currentInput.trim());
         currentValidRepo = repo;
         if (repo) {
-          currentReadOnly = false;
-          currentLatest = false;
+          currentReference = false;
         }
       } else {
         statusText.content = "";
@@ -151,9 +151,8 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
       } else {
         reposList.content = repos
           .map((repo, i) => {
-            const roMarker = repo.readOnly ? " [RO]" : "";
-            const latestMarker = repo.latest ? " [Latest]" : "";
-            return `  ${i + 1}. ${repo.spec}${roMarker}${latestMarker}`;
+            const refMarker = repo.reference ? " [Ref]" : "";
+            return `  ${i + 1}. ${repo.spec}${refMarker}`;
           })
           .join("\n");
         reposList.fg = "#94a3b8";
@@ -161,17 +160,28 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
     }
 
     function updateDetails() {
-      if (currentValidRepo) {
-        detailsLabel.content = "\nRepository details:";
-        detailsLabel.fg = "#e2e8f0";
-        detailsReadOnly.content = `  Read-only: ${currentReadOnly ? "Yes [r]" : "No [r]"}`;
-        detailsReadOnly.fg = currentReadOnly ? "#f59e0b" : "#94a3b8";
-        detailsLatest.content = `  Latest: ${currentLatest ? "Yes [l]" : "No [l]"}`;
-        detailsLatest.fg = currentLatest ? "#22d3ee" : "#94a3b8";
+      if (isConfirming && currentValidRepo) {
+        // Confirmation mode with interactive checkboxes
+        detailsLabel.content = `\nConfigure options for: ${currentInput.trim()}`;
+        detailsLabel.fg = "#38bdf8";
+
+        const refCheckbox = currentReference ? "[✓]" : "[ ]";
+        const refSelected = confirmOptionIndex === 0;
+        detailsReference.content = `  ${refSelected ? "▶" : " "} ${refCheckbox} Reference [r] (read-only, shared cache, auto-refresh)`;
+        detailsReference.fg = refSelected ? "#f8fafc" : currentReference ? "#22d3ee" : "#94a3b8";
+
+        const confirmSelected = confirmOptionIndex === 1;
+        confirmButton.content = `  ${confirmSelected ? "▶" : " "} [Add repository]`;
+        confirmButton.fg = confirmSelected ? "#10b981" : "#64748b";
+      } else if (currentValidRepo) {
+        detailsLabel.content = "\nPress Enter to configure options";
+        detailsLabel.fg = "#64748b";
+        detailsReference.content = "";
+        confirmButton.content = "";
       } else {
         detailsLabel.content = "";
-        detailsReadOnly.content = "";
-        detailsLatest.content = "";
+        detailsReference.content = "";
+        confirmButton.content = "";
       }
     }
 
@@ -240,8 +250,7 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
       const repo = validateRepo(selectedMatch.trim());
       currentValidRepo = repo;
       if (repo) {
-        currentReadOnly = false;
-        currentLatest = false;
+        currentReference = false;
       }
 
       updateMatches(); // Refresh display with new selection (matches stay the same, just highlight changes)
@@ -262,15 +271,13 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
       }
 
       const repoToAdd = { ...currentValidRepo };
-      repoToAdd.readOnly = currentReadOnly;
-      repoToAdd.latest = currentLatest;
+      repoToAdd.reference = currentReference;
       repos.push(repoToAdd);
 
       currentInput = "";
       repoInput.value = "";
       currentValidRepo = null;
-      currentReadOnly = false;
-      currentLatest = false;
+      currentReference = false;
       updateReposList();
       lastQuery = "";
       selectedMatchIndex = -1;
@@ -280,37 +287,109 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
       statusText.content = "";
     }
 
+    function enterConfirmMode() {
+      isConfirming = true;
+      confirmOptionIndex = 1; // Start on confirm button for quick add
+      repoInput.blur();
+      updateDetails();
+      updateFooter();
+    }
+
+    function exitConfirmMode() {
+      isConfirming = false;
+      confirmOptionIndex = 0;
+      repoInput.focus();
+      updateDetails();
+      updateFooter();
+    }
+
+    function toggleCurrentOption() {
+      if (confirmOptionIndex === 0) {
+        // Toggle reference
+        currentReference = !currentReference;
+      } else if (confirmOptionIndex === 1) {
+        // Confirm button - add the repo
+        addCurrentRepo();
+        exitConfirmMode();
+      }
+      updateDetails();
+    }
+
+    function updateFooter() {
+      if (isConfirming) {
+        showFooter(renderer, content, {
+          navigate: true,
+          select: false,
+          back: true,
+          custom: ["r Reference", "space Toggle", "enter Add"],
+        });
+      } else {
+        showFooter(renderer, content, {
+          navigate: true,
+          select: true,
+          back: true,
+          custom: repos.length > 0 ? ["enter (empty) Continue"] : [],
+        });
+      }
+    }
+
     const handleKeypress = (key: KeyEvent) => {
+      // Escape behavior differs based on mode
       if (isEscape(key)) {
+        if (isConfirming) {
+          // Exit confirmation mode, go back to input
+          exitConfirmMode();
+          return;
+        }
         cleanup();
         resolve({ repos, cancelled: true });
         return;
       }
 
-      // Toggle read-only
-      if (key.name === "r" && currentValidRepo) {
-        currentReadOnly = !currentReadOnly;
-        if (!currentReadOnly) {
-          currentLatest = false;
+      // Confirmation mode handling
+      if (isConfirming) {
+        // Toggle reference with 'r' hotkey
+        if (key.name === "r") {
+          currentReference = !currentReference;
+          updateDetails();
+          return;
+        }
+
+        // Space to toggle current option
+        if (key.name === "space") {
+          toggleCurrentOption();
+          return;
+        }
+
+        // Enter to confirm/add
+        if (isEnter(key)) {
+          addCurrentRepo();
+          exitConfirmMode();
+          return;
+        }
+
+        // Arrow keys to navigate options
+        if (isArrowUp(key)) {
+          confirmOptionIndex = Math.max(0, confirmOptionIndex - 1);
+          updateDetails();
+          return;
         }
-        updateDetails();
-        return;
-      }
 
-      // Toggle latest
-      if (key.name === "l" && currentValidRepo) {
-        currentLatest = !currentLatest;
-        if (currentLatest) {
-          currentReadOnly = true;
+        if (isArrowDown(key)) {
+          confirmOptionIndex = Math.min(1, confirmOptionIndex + 1);
+          updateDetails();
+          return;
         }
-        updateDetails();
+
         return;
       }
 
-      // Enter to add repo or continue
+      // Normal input mode handling
+
+      // Enter to enter confirmation mode or continue
       if (isEnter(key)) {
         if (currentInput.trim() && currentValidRepo) {
-          addCurrentRepo();
+          enterConfirmMode();
         } else if (!currentInput.trim() && repos.length > 0) {
           // Empty input + repos added = continue
           cleanup();
@@ -367,8 +446,7 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
         const repo = validateRepo(value.trim());
         currentValidRepo = repo;
         if (repo) {
-          currentReadOnly = false;
-          currentLatest = false;
+          currentReference = false;
         }
       } else {
         statusText.content = "";
@@ -385,16 +463,9 @@ export async function showAddReposPrompt(renderer: CliRenderer): Promise<AddRepo
       clearLayout(renderer);
     };
 
-    // Show footer with context-aware actions
-    showFooter(renderer, content, {
-      navigate: true,
-      select: true,
-      back: true,
-      custom: currentValidRepo ? ["r Toggle RO", "l Toggle Latest"] : ["↑↓ Navigate matches"],
-    });
-
     renderer.keyInput.on("keypress", handleKeypress);
     updateDetails();
     updateReposList();
+    updateFooter();
   });
 }