letmecook 0.0.15 → 0.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "letmecook",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "repository": {
     "type": "git",
     "url": "https://github.com/rustydotwtf/letmecook.git"

package/src/agents-md.ts

@@ -11,22 +11,19 @@ export function generateAgentsMd(session: Session): string {
     minute: "2-digit",
   });
 
-  const hasReadOnlyRepos = session.repos.some((repo) => repo.readOnly);
-  const hasLatestRepos = session.repos.some((repo) => repo.latest);
+  const hasReferenceRepos = session.repos.some((repo) => repo.reference);
   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} |`;
+      const referenceStatus = repo.reference ? "**YES**" : "no";
+      return `| \`${repo.dir}/\` | [${repo.owner}/${repo.name}](${url}) | ${branch} | ${referenceStatus} |`;
     })
     .join("\n");
 
-  const readOnlyRepos = session.repos.filter((repo) => repo.readOnly);
-  const latestRepos = session.repos.filter((repo) => repo.latest);
+  const referenceRepos = session.repos.filter((repo) => repo.reference);
 
   const skillsSection = hasSkills
     ? `
@@ -40,31 +37,24 @@ These skills are available for use in this session and are automatically updated
 `
     : "";
 
-  const readOnlyWarning = hasReadOnlyRepos
+  const referenceWarning = hasReferenceRepos
     ? `
-## ⚠️ Read-Only Repositories
+## ⚠️ Reference Repositories
 
-**WARNING: The following repositories are marked as READ-ONLY:**
+**WARNING: The following repositories are REFERENCES (symlinked from shared cache):**
 
-${readOnlyRepos.map((repo) => `- \`${repo.dir}/\` (${repo.owner}/${repo.name})`).join("\n")}
+${referenceRepos.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")}
+**Why are these references?**
+- These directories are **symlinks** to a shared cache (~/.letmecook/references/)
+- Any modifications would affect ALL sessions using this repository
+- They are automatically refreshed to latest before each session resume
+- They are included for reference only - the user wants to read and understand the code without risk of accidental modifications
 `
     : "";
 
@@ -76,11 +66,10 @@ ${session.goal ? `> ${session.goal}\n` : ""}
 
 ## Repositories
 
-| Directory | Repository | Branch | Read-Only | Latest |
-|-----------|------------|--------|-----------|--------|
+| Directory | Repository | Branch | Reference |
+|-----------|------------|--------|-----------|
 ${repoRows}
-${readOnlyWarning}
-${latestNotice}
+${referenceWarning}
 ${skillsSection}
 ## Important Notes
 

package/src/flows/add-repos.ts

@@ -6,6 +6,8 @@ import { writeAgentsMd } from "../agents-md";
 import { recordRepoHistory } from "../repo-history";
 import { showAddReposPrompt } from "../ui/add-repos";
 import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
+import { ensureReferenceRepo, linkReferenceRepo, ensureReferencesDir } from "../reference-repo";
+import { rm } from "node:fs/promises";
 
 export interface AddReposParams {
   renderer: CliRenderer;
@@ -18,7 +20,10 @@ export interface AddReposResult {
 }
 
 function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
-  return repos.map((repo) => {
+  // Only create command tasks for non-reference repos
+  const regularRepos = repos.filter((repo) => !repo.reference);
+
+  return regularRepos.map((repo) => {
     const url = `https://github.com/${repo.owner}/${repo.name}.git`;
     const targetDir = join(sessionPath, repo.dir);
     const args = repo.branch
@@ -44,6 +49,34 @@ function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTas
   });
 }
 
+async function setupReferenceRepos(
+  repos: RepoSpec[],
+  sessionPath: string,
+): Promise<{ successful: RepoSpec[]; failed: Array<{ repo: RepoSpec; error: string }> }> {
+  const referenceRepos = repos.filter((repo) => repo.reference);
+  const successful: RepoSpec[] = [];
+  const failed: Array<{ repo: RepoSpec; error: string }> = [];
+
+  if (referenceRepos.length === 0) {
+    return { successful, failed };
+  }
+
+  await ensureReferencesDir();
+
+  for (const repo of referenceRepos) {
+    try {
+      await ensureReferenceRepo(repo);
+      await linkReferenceRepo(repo, sessionPath);
+      successful.push(repo);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      failed.push({ repo, error: errorMsg });
+    }
+  }
+
+  return { successful, failed };
+}
+
 export async function addReposFlow(params: AddReposParams): Promise<AddReposResult> {
   const { renderer, session } = params;
 
@@ -54,38 +87,115 @@ export async function addReposFlow(params: AddReposParams): Promise<AddReposResu
     const newRepos = addResult.repos.filter((r) => !existingSpecs.has(r.spec));
 
     if (newRepos.length > 0) {
+      // Setup reference repos first (symlinks from cache)
+      const { successful: successfulRefs, failed: failedRefs } = await setupReferenceRepos(
+        newRepos,
+        session.path,
+      );
+
+      // Report reference repo failures
+      if (failedRefs.length > 0) {
+        console.error(`\n⚠️  ${failedRefs.length} reference repo(s) failed:`);
+        failedRefs.forEach(({ repo, error }) => {
+          console.error(`  ✗ ${repo.owner}/${repo.name}: ${error}`);
+        });
+      }
+
+      // Clone regular repos
       const tasks = reposToCommandTasks(newRepos, session.path);
+      let results: Awaited<ReturnType<typeof runCommands>> = [];
 
-      const results = await runCommands(renderer, {
-        title: "Adding repositories",
-        tasks,
-        showOutput: true,
-        outputLines: 5,
-      });
+      if (tasks.length > 0) {
+        results = await runCommands(renderer, {
+          title: "Adding repositories",
+          tasks,
+          showOutput: true,
+          outputLines: 5,
+          allowAbort: true,
+          allowSkip: tasks.length > 1,
+          allowBackground: true,
+          sessionName: session.name,
+        });
 
-      // Check for errors
-      const errors = results.filter((r) => !r.success);
-      if (errors.length > 0) {
-        console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
-        errors.forEach((err) => {
-          console.error(`  ✗ ${err.task.label}`);
-          if (err.error) {
-            console.error(`    ${err.error}`);
+        // Handle aborted operation - return without changes
+        const wasAborted = results.some((r) => r.outcome === "aborted");
+        if (wasAborted) {
+          hideCommandRunner(renderer);
+          // Clean up any partially cloned repos (non-reference only)
+          const regularRepos = newRepos.filter((r) => !r.reference);
+          for (const repo of regularRepos) {
+            const repoPath = join(session.path, repo.dir);
+            try {
+              await rm(repoPath, { recursive: true, force: true });
+            } catch {
+              // Ignore cleanup errors
+            }
           }
-        });
+          // Also clean up reference symlinks
+          for (const repo of successfulRefs) {
+            const repoPath = join(session.path, repo.dir);
+            try {
+              await rm(repoPath, { recursive: true, force: true });
+            } catch {
+              // Ignore cleanup errors
+            }
+          }
+          return { session, cancelled: true };
+        }
+
+        // Clean up skipped repo directories
+        const skippedResults = results.filter((r) => r.outcome === "skipped");
+        for (const skipped of skippedResults) {
+          const repoSpec = skipped.task.label.replace("Cloning ", "");
+          const repo = newRepos.find((r) => `${r.owner}/${r.name}` === repoSpec);
+          if (repo) {
+            const repoPath = join(session.path, repo.dir);
+            try {
+              await rm(repoPath, { recursive: true, force: true });
+            } catch {
+              // Ignore cleanup errors
+            }
+          }
+        }
+
+        // Check for errors (not skipped/aborted)
+        const errors = results.filter((r) => r.outcome === "error");
+        if (errors.length > 0) {
+          console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
+          errors.forEach((err) => {
+            console.error(`  ✗ ${err.task.label}`);
+            if (err.error) {
+              console.error(`    ${err.error}`);
+            }
+          });
+        }
       }
 
       await new Promise((resolve) => setTimeout(resolve, 700));
       hideCommandRunner(renderer);
 
-      const allRepos = [...session.repos, ...newRepos];
-      const updatedSession = await updateSessionRepos(session.name, allRepos);
-      const nextSession = updatedSession ?? session;
+      // Filter to only successfully cloned repos
+      const successfulCloned = newRepos.filter((repo) => {
+        if (repo.reference) return false; // Reference repos handled separately
+        const result = results.find((r) => r.task.label === `Cloning ${repo.owner}/${repo.name}`);
+        return result?.outcome === "completed";
+      });
+
+      // Combine successful reference and cloned repos
+      const successfulRepos = [...successfulRefs, ...successfulCloned];
 
-      await recordRepoHistory(newRepos);
-      await writeAgentsMd(nextSession);
+      if (successfulRepos.length > 0) {
+        const allRepos = [...session.repos, ...successfulRepos];
+        const updatedSession = await updateSessionRepos(session.name, allRepos);
+        const nextSession = updatedSession ?? session;
+
+        await recordRepoHistory(successfulRepos);
+        await writeAgentsMd(nextSession);
+
+        return { session: nextSession, cancelled: false };
+      }
 
-      return { session: nextSession, cancelled: false };
+      return { session, cancelled: false };
     }
   }
 

package/src/flows/edit-session.ts

@@ -6,6 +6,7 @@ import { recordRepoHistory } from "../repo-history";
 import { removeSkillFromSession } from "../skills";
 import { createRenderer, destroyRenderer } from "../ui/renderer";
 import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
+import { rm } from "node:fs/promises";
 
 export interface EditSessionParams {
   session: Session;
@@ -74,10 +75,51 @@ export async function editSession(params: EditSessionParams): Promise<Session |
           tasks,
           showOutput: true,
           outputLines: 5,
+          allowAbort: true,
+          allowSkip: tasks.length > 1,
+          allowBackground: true,
         });
 
-        // Check for errors
-        const errors = results.filter((r) => !r.success);
+        // Handle aborted operation
+        const wasAborted = results.some((r) => r.outcome === "aborted");
+        if (wasAborted) {
+          hideCommandRunner(renderer);
+          // Clean up any partially cloned repos
+          for (const repo of newRepos) {
+            const repoPath = join(currentSession.path, repo.dir);
+            try {
+              await rm(repoPath, { recursive: true, force: true });
+            } catch {
+              // Ignore cleanup errors
+            }
+          }
+          destroyRenderer();
+          return session; // Return unchanged session
+        }
+
+        // Clean up skipped repo directories
+        const skippedResults = results.filter((r) => r.outcome === "skipped");
+        for (const skipped of skippedResults) {
+          const repoSpec = skipped.task.label.replace("Cloning ", "");
+          const repo = newRepos.find((r) => `${r.owner}/${r.name}` === repoSpec);
+          if (repo) {
+            const repoPath = join(currentSession.path, repo.dir);
+            try {
+              await rm(repoPath, { recursive: true, force: true });
+            } catch {
+              // Ignore cleanup errors
+            }
+          }
+        }
+
+        // Filter to only successfully cloned repos
+        const successfulRepos = newRepos.filter((repo) => {
+          const result = results.find((r) => r.task.label === `Cloning ${repo.owner}/${repo.name}`);
+          return result?.outcome === "completed";
+        });
+
+        // Check for errors (not skipped/aborted)
+        const errors = results.filter((r) => r.outcome === "error");
         if (errors.length > 0) {
           console.error(`\n⚠️  ${errors.length} repository(ies) failed to clone:`);
           errors.forEach((err) => {
@@ -91,13 +133,23 @@ export async function editSession(params: EditSessionParams): Promise<Session |
         await new Promise((resolve) => setTimeout(resolve, 700));
         hideCommandRunner(renderer);
 
-        await recordRepoHistory(newRepos);
-        await writeAgentsMd(currentSession);
-      }
+        if (successfulRepos.length > 0) {
+          await recordRepoHistory(successfulRepos);
+          await writeAgentsMd(currentSession);
+        }
 
-      const updatedSession = await updateSessionRepos(session.name, updates.repos);
-      if (updatedSession) {
-        currentSession = updatedSession;
+        // Update session with existing + successful repos only
+        const allRepos = [...session.repos, ...successfulRepos];
+        const updatedSession = await updateSessionRepos(session.name, allRepos);
+        if (updatedSession) {
+          currentSession = updatedSession;
+        }
+      } else {
+        // No new repos, just update with the provided list
+        const updatedSession = await updateSessionRepos(session.name, updates.repos);
+        if (updatedSession) {
+          currentSession = updatedSession;
+        }
       }
     }
 
@@ -113,10 +165,27 @@ export async function editSession(params: EditSessionParams): Promise<Session |
           tasks,
           showOutput: true,
           outputLines: 5,
+          allowAbort: true,
+          allowSkip: tasks.length > 1,
+          allowBackground: true,
+        });
+
+        // Handle aborted operation
+        const wasAborted = results.some((r) => r.outcome === "aborted");
+        if (wasAborted) {
+          hideCommandRunner(renderer);
+          destroyRenderer();
+          return currentSession; // Return current session state
+        }
+
+        // Filter to only successfully installed skills
+        const successfulSkills = newSkills.filter((skill) => {
+          const result = results.find((r) => r.task.label === `Installing ${skill}`);
+          return result?.outcome === "completed";
         });
 
-        // Check for errors
-        const errors = results.filter((r) => !r.success);
+        // Check for errors (not skipped/aborted)
+        const errors = results.filter((r) => r.outcome === "error");
         if (errors.length > 0) {
           console.error(`\n⚠️  ${errors.length} skill(s) failed to install:`);
           errors.forEach((err) => {
@@ -130,12 +199,14 @@ export async function editSession(params: EditSessionParams): Promise<Session |
         await new Promise((resolve) => setTimeout(resolve, 700));
         hideCommandRunner(renderer);
 
-        const allSkills = [...(session.skills || []), ...newSkills];
-        const updatedSession = await updateSessionSkills(currentSession.name, allSkills);
+        if (successfulSkills.length > 0) {
+          const allSkills = [...(currentSession.skills || []), ...successfulSkills];
+          const updatedSession = await updateSessionSkills(currentSession.name, allSkills);
 
-        if (updatedSession) {
-          currentSession = updatedSession;
-          await writeAgentsMd(currentSession);
+          if (updatedSession) {
+            currentSession = updatedSession;
+            await writeAgentsMd(currentSession);
+          }
         }
       }
     }

package/src/flows/new-session.ts

@@ -8,6 +8,8 @@ import { recordRepoHistory } from "../repo-history";
 import { showAgentProposal } from "../ui/agent-proposal";
 import { showConflictPrompt } from "../ui/conflict";
 import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
+import { ensureReferenceRepo, linkReferenceRepo, ensureReferencesDir } from "../reference-repo";
+import { rm } from "node:fs/promises";
 
 export interface NewSessionParams {
   repos: RepoSpec[];
@@ -23,7 +25,11 @@ export interface NewSessionResult {
 }
 
 function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
-  return repos.map((repo) => {
+  // Only create command tasks for non-reference repos
+  // Reference repos are handled separately with ensureReferenceRepo + symlink
+  const regularRepos = repos.filter((repo) => !repo.reference);
+
+  return regularRepos.map((repo) => {
     const url = `https://github.com/${repo.owner}/${repo.name}.git`;
     const targetDir = join(sessionPath, repo.dir);
     const args = repo.branch
@@ -49,6 +55,41 @@ function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTas
   });
 }
 
+async function setupReferenceRepos(
+  repos: RepoSpec[],
+  sessionPath: string,
+  onProgress?: (repo: RepoSpec, status: "caching" | "linking" | "done" | "error") => void,
+): Promise<{ successful: RepoSpec[]; failed: Array<{ repo: RepoSpec; error: string }> }> {
+  const referenceRepos = repos.filter((repo) => repo.reference);
+  const successful: RepoSpec[] = [];
+  const failed: Array<{ repo: RepoSpec; error: string }> = [];
+
+  if (referenceRepos.length === 0) {
+    return { successful, failed };
+  }
+
+  await ensureReferencesDir();
+
+  for (const repo of referenceRepos) {
+    try {
+      onProgress?.(repo, "caching");
+      await ensureReferenceRepo(repo);
+
+      onProgress?.(repo, "linking");
+      await linkReferenceRepo(repo, sessionPath);
+
+      onProgress?.(repo, "done");
+      successful.push(repo);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      onProgress?.(repo, "error");
+      failed.push({ repo, error: errorMsg });
+    }
+  }
+
+  return { successful, failed };
+}
+
 function skillsToCommandTasks(skills: string[], sessionPath: string): CommandTask[] {
   return skills.map((skill) => ({
     label: `Installing ${skill}`,
@@ -105,32 +146,94 @@ export async function createNewSession(
         skills?.length ? skills : undefined,
       );
 
-      // Build all tasks (repos + skills)
+      // Setup reference repos first (symlinks from cache)
+      const { successful: successfulRefs, failed: failedRefs } = await setupReferenceRepos(
+        repos,
+        session.path,
+      );
+
+      // Report reference repo failures
+      if (failedRefs.length > 0) {
+        console.error(`\n⚠️  ${failedRefs.length} reference repo(s) failed:`);
+        failedRefs.forEach(({ repo, error }) => {
+          console.error(`  ✗ ${repo.owner}/${repo.name}: ${error}`);
+        });
+      }
+
+      // Build tasks for regular repos + skills
       const tasks: CommandTask[] = [
         ...reposToCommandTasks(repos, session.path),
         ...(skills && skills.length > 0 ? skillsToCommandTasks(skills, session.path) : []),
       ];
 
-      const results = await runCommands(renderer, {
-        title: "Setting up session",
-        tasks,
-        showOutput: true,
-        outputLines: 5,
-      });
+      let results: Awaited<ReturnType<typeof runCommands>> = [];
 
-      // Check for errors
-      const errors = results.filter((r) => !r.success);
-      if (errors.length > 0) {
-        console.error(`\n⚠️  ${errors.length} task(s) failed:`);
-        errors.forEach((err) => {
-          console.error(`  ✗ ${err.task.label}`);
-          if (err.error) {
-            console.error(`    ${err.error}`);
-          }
+      if (tasks.length > 0) {
+        results = await runCommands(renderer, {
+          title: "Setting up session",
+          tasks,
+          showOutput: true,
+          outputLines: 5,
+          allowAbort: true,
+          allowSkip: tasks.length > 1,
+          allowBackground: true,
+          sessionName,
         });
+
+        // Handle aborted operation - clean up and return null
+        const wasAborted = results.some((r) => r.outcome === "aborted");
+        if (wasAborted) {
+          hideCommandRunner(renderer);
+          // Clean up the partial session
+          await deleteSession(session.name);
+          return null;
+        }
+
+        // Clean up skipped repo directories
+        const skippedResults = results.filter((r) => r.outcome === "skipped");
+        for (const skipped of skippedResults) {
+          const repoName = skipped.task.label.replace("Cloning ", "").split("/")[1];
+          if (repoName) {
+            const repoPath = join(session.path, repoName);
+            try {
+              await rm(repoPath, { recursive: true, force: true });
+            } catch {
+              // Ignore cleanup errors
+            }
+          }
+        }
+
+        // Check for errors (not skipped/aborted)
+        const errors = results.filter((r) => r.outcome === "error");
+        if (errors.length > 0) {
+          console.error(`\n⚠️  ${errors.length} task(s) failed:`);
+          errors.forEach((err) => {
+            console.error(`  ✗ ${err.task.label}`);
+            if (err.error) {
+              console.error(`    ${err.error}`);
+            }
+          });
+        }
       }
 
-      await recordRepoHistory(repos);
+      // Filter out skipped repos from the session
+      const successfulRepoResults = results.filter(
+        (r) => r.outcome === "completed" && r.task.label.startsWith("Cloning "),
+      );
+      const successfulClonedSpecs = successfulRepoResults
+        .map((r) => {
+          const repoSpec = r.task.label.replace("Cloning ", "");
+          return repos.find((repo) => `${repo.owner}/${repo.name}` === repoSpec);
+        })
+        .filter((r): r is RepoSpec => r !== undefined);
+
+      // Combine successful reference repos and cloned repos
+      const successfulRepoSpecs = [...successfulRefs, ...successfulClonedSpecs];
+
+      // Record only successful repos
+      if (successfulRepoSpecs.length > 0) {
+        await recordRepoHistory(successfulRepoSpecs);
+      }
 
       await new Promise((resolve) => setTimeout(resolve, 700));
       hideCommandRunner(renderer);
@@ -148,30 +251,52 @@ export async function createNewSession(
         skills?.length ? skills : undefined,
       );
 
-      console.log(`\nCloning ${repos.length} repository(ies)...`);
+      // Setup reference repos first (symlinks from cache)
+      const referenceRepos = repos.filter((r) => r.reference);
+      if (referenceRepos.length > 0) {
+        console.log(`\nSetting up ${referenceRepos.length} reference repo(s)...`);
+        const { successful: successfulRefs, failed: failedRefs } = await setupReferenceRepos(
+          repos,
+          session.path,
+        );
+        successfulRefs.forEach((repo) => {
+          console.log(`  ✓ ${repo.owner}/${repo.name} (linked)`);
+        });
+        failedRefs.forEach(({ repo, error }) => {
+          console.log(`  ✗ ${repo.owner}/${repo.name}: ${error}`);
+        });
+      }
+
+      // Clone regular repos
+      const regularRepos = repos.filter((r) => !r.reference);
+      if (regularRepos.length > 0) {
+        console.log(`\nCloning ${regularRepos.length} repository(ies)...`);
+      }
 
       const tasks: CommandTask[] = [
         ...reposToCommandTasks(repos, session.path),
         ...(skills && skills.length > 0 ? skillsToCommandTasks(skills, session.path) : []),
       ];
 
-      const results = await runCommands(renderer, {
-        title: "Setting up session",
-        tasks,
-        showOutput: false, // CLI mode doesn't need visual output
-      });
+      if (tasks.length > 0) {
+        const results = await runCommands(renderer, {
+          title: "Setting up session",
+          tasks,
+          showOutput: false, // CLI mode doesn't need visual output
+        });
 
-      // Print results
-      results.forEach((result) => {
-        if (result.success) {
-          console.log(`  ✓ ${result.task.label}`);
-        } else {
-          console.log(`  ✗ ${result.task.label}`);
-          if (result.error) {
-            console.log(`    ${result.error}`);
+        // Print results
+        results.forEach((result) => {
+          if (result.success) {
+            console.log(`  ✓ ${result.task.label}`);
+          } else {
+            console.log(`  ✗ ${result.task.label}`);
+            if (result.error) {
+              console.log(`    ${result.error}`);
+            }
           }
-        }
-      });
+        });
+      }
 
       await writeAgentsMd(session);
       await createClaudeMdSymlink(session.path);