letmecook 0.0.21 → 0.0.23

package/src/flows/new-session.ts

@@ -8,7 +8,6 @@ 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 {
@@ -25,11 +24,7 @@ export interface NewSessionResult {
 }
 
 function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
-  // 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) => {
+  return repos.map((repo) => {
     const url = `https://github.com/${repo.owner}/${repo.name}.git`;
     const targetDir = join(sessionPath, repo.dir);
     const args = repo.branch
@@ -55,41 +50,6 @@ 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}`,
@@ -128,15 +88,22 @@ export async function createNewSession(
       }
     }
 
-    const sessionName = await generateSessionName(repos, goal);
-
+    // Generate session name (show UI feedback during generation in TUI mode)
+    let sessionName: string;
     if (mode === "tui") {
-      showAgentProposal(renderer, {
-        sessionName,
+      const proposal = showAgentProposal(renderer, {
+        sessionName: "generating...",
         repos,
         goal,
       });
+      sessionName = await generateSessionName(repos, goal);
+      proposal.sessionNameText.content = `Session: ${sessionName}`;
+      renderer.requestRender();
+    } else {
+      sessionName = await generateSessionName(repos, goal);
+    }
 
+    if (mode === "tui") {
       await new Promise((resolve) => setTimeout(resolve, 3000));
 
       const session = await createSession(
@@ -146,89 +113,68 @@ export async function createNewSession(
         skills?.length ? skills : undefined,
       );
 
-      // 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
+      // Build all tasks (repos + skills)
       const tasks: CommandTask[] = [
         ...reposToCommandTasks(repos, session.path),
         ...(skills && skills.length > 0 ? skillsToCommandTasks(skills, session.path) : []),
       ];
 
-      let results: Awaited<ReturnType<typeof runCommands>> = [];
-
-      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,
-        });
+      const 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;
-        }
+      // 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
-            }
+      // 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}`);
-            }
-          });
-        }
       }
 
       // Filter out skipped repos from the session
       const successfulRepoResults = results.filter(
         (r) => r.outcome === "completed" && r.task.label.startsWith("Cloning "),
       );
-      const successfulClonedSpecs = successfulRepoResults
+      const successfulRepoSpecs = 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];
+      // 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}`);
+          }
+        });
+      }
 
       // Record only successful repos
       if (successfulRepoSpecs.length > 0) {
@@ -251,52 +197,30 @@ export async function createNewSession(
         skills?.length ? skills : undefined,
       );
 
-      // 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)...`);
-      }
+      console.log(`\nCloning ${repos.length} repository(ies)...`);
 
       const tasks: CommandTask[] = [
         ...reposToCommandTasks(repos, session.path),
         ...(skills && skills.length > 0 ? skillsToCommandTasks(skills, session.path) : []),
       ];
 
-      if (tasks.length > 0) {
-        const results = await runCommands(renderer, {
-          title: "Setting up session",
-          tasks,
-          showOutput: false, // CLI mode doesn't need visual output
-        });
+      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);

package/src/flows/resume-session.ts

@@ -1,7 +1,7 @@
 import type { CliRenderer } from "@opentui/core";
 import type { Session } from "../types";
 import { updateSessionSettings } from "../sessions";
-import { refreshReferenceRepos } from "../git";
+import { refreshLatestRepos } from "../git";
 import { updateSkills } from "../skills";
 import { handleSmartExit } from "../ui/exit";
 import { showSessionSettings } from "../ui/session-settings";
@@ -10,10 +10,10 @@ import { showSessionStartWarning } from "../ui/background-warning";
 import { showProgress, updateProgress, hideProgress } from "../ui/progress";
 import { showReclonePrompt } from "../ui/reclone-prompt";
 import { deleteSession } from "../sessions";
+import { recloneRepo } from "../git";
 import { writeAgentsMd } from "../agents-md";
 import { createRenderer, destroyRenderer } from "../ui/renderer";
 import { getProcessesForSession } from "../process-registry";
-import { repairReferenceLink } from "../reference-repo";
 
 export interface ResumeSessionParams {
   session: Session;
@@ -49,10 +49,10 @@ export async function resumeSession(
   while (true) {
     if (mode === "tui" && shouldRefresh) {
       renderer = await createRenderer();
-      await refreshReferenceBeforeResume(renderer, currentSession);
+      await refreshLatestBeforeResume(renderer, currentSession);
       destroyRenderer();
     } else if (shouldRefresh) {
-      await refreshReferenceBeforeResumeSimple(currentSession);
+      await refreshLatestBeforeResumeSimple(currentSession);
     }
 
     await runOpencodeMode(mode, currentSession.path);
@@ -117,23 +117,20 @@ export async function resumeSession(
   }
 }
 
-async function refreshReferenceBeforeResume(
-  renderer: CliRenderer,
-  session: Session,
-): Promise<void> {
-  const referenceRepos = session.repos.filter((repo) => repo.reference);
-  if (referenceRepos.length === 0) return;
+async function refreshLatestBeforeResume(renderer: CliRenderer, session: Session): Promise<void> {
+  const readOnlyRepos = session.repos.filter((repo) => repo.readOnly);
+  if (readOnlyRepos.length === 0) return;
 
-  const refreshProgressState = showProgress(renderer, referenceRepos, {
+  const refreshProgressState = showProgress(renderer, readOnlyRepos, {
     title: "Refreshing repositories",
-    label: "Refreshing reference repositories:",
+    label: "Refreshing read-only repositories:",
     initialPhase: "refreshing",
   });
   refreshProgressState.sessionName = session.name;
   updateProgress(renderer, refreshProgressState);
 
-  const refreshResults = await refreshReferenceRepos(
-    referenceRepos,
+  const refreshResults = await refreshLatestRepos(
+    readOnlyRepos,
     session.path,
     (repoIndex, status, outputLines) => {
       const repoState = refreshProgressState.repos[repoIndex];
@@ -153,60 +150,59 @@ async function refreshReferenceBeforeResume(
   await new Promise((resolve) => setTimeout(resolve, 700));
   hideProgress(renderer);
 
-  // For reference repos that failed, offer to repair the link
-  const repairTargets = refreshResults.filter(
-    (result) => result.status === "error" && result.repo.reference,
+  const recloneTargets = refreshResults.filter(
+    (result) => result.status === "error" && result.repo.readOnly,
   );
 
-  for (const result of repairTargets) {
+  for (const result of recloneTargets) {
     const choice = await showReclonePrompt(renderer, result.repo);
 
     if (choice === "reclone") {
-      const repairProgressState = showProgress(renderer, [result.repo], {
-        title: "Repairing reference",
-        label: "Repairing:",
+      const recloneProgressState = showProgress(renderer, [result.repo], {
+        title: "Recloning repository",
+        label: "Recloning:",
         initialPhase: "cloning",
       });
-      repairProgressState.sessionName = session.name;
-      updateProgress(renderer, repairProgressState);
+      recloneProgressState.sessionName = session.name;
+      updateProgress(renderer, recloneProgressState);
 
       try {
-        await repairReferenceLink(result.repo, session.path, (status, outputLines) => {
-          const repoState = repairProgressState.repos[0];
+        await recloneRepo(result.repo, session.path, (status, outputLines) => {
+          const repoState = recloneProgressState.repos[0];
           if (repoState) {
             repoState.status = status;
             if (outputLines) {
-              repairProgressState.currentOutput = outputLines;
+              recloneProgressState.currentOutput = outputLines;
             }
-            updateProgress(renderer, repairProgressState);
+            updateProgress(renderer, recloneProgressState);
           }
         });
       } catch (error) {
-        const repoState = repairProgressState.repos[0];
+        const repoState = recloneProgressState.repos[0];
         if (repoState) {
           repoState.status = "error";
         }
-        repairProgressState.currentOutput = [
+        recloneProgressState.currentOutput = [
           error instanceof Error ? error.message : String(error),
         ];
-        updateProgress(renderer, repairProgressState);
+        updateProgress(renderer, recloneProgressState);
       }
 
-      repairProgressState.phase = "done";
-      updateProgress(renderer, repairProgressState);
+      recloneProgressState.phase = "done";
+      updateProgress(renderer, recloneProgressState);
       await new Promise((resolve) => setTimeout(resolve, 700));
       hideProgress(renderer);
     }
   }
 }
 
-async function refreshReferenceBeforeResumeSimple(session: Session): Promise<void> {
-  const referenceRepos = session.repos.filter((repo) => repo.reference);
-  if (referenceRepos.length === 0) return;
+async function refreshLatestBeforeResumeSimple(session: Session): Promise<void> {
+  const readOnlyRepos = session.repos.filter((repo) => repo.readOnly);
+  if (readOnlyRepos.length === 0) return;
 
-  console.log("\nRefreshing reference repositories...");
+  console.log("\nRefreshing read-only repositories...");
 
-  const results = await refreshReferenceRepos(referenceRepos, session.path);
+  const results = await refreshLatestRepos(readOnlyRepos, session.path);
 
   if (results.length === 0) return;
 

package/src/git.ts

@@ -193,101 +193,63 @@ export async function sessionHasUncommittedChanges(
   return { hasChanges: reposWithChanges.length > 0, reposWithChanges };
 }
 
-export async function refreshReferenceRepos(
+export async function refreshLatestRepos(
   repos: RepoSpec[],
   sessionPath: string,
   onProgress?: (repoIndex: number, status: RefreshProgressStatus, outputLines?: string[]) => void,
 ): Promise<RefreshResult[]> {
-  // Import reference-repo functions dynamically to avoid circular deps
-  const { refreshReferenceRepo, verifyReferenceLink, repairReferenceLink, isSymlink } =
-    await import("./reference-repo");
-
-  const referenceRepos = repos.filter((repo) => repo.reference);
-  if (referenceRepos.length === 0) return [];
+  const readOnlyRepos = repos.filter((repo) => repo.readOnly);
+  if (readOnlyRepos.length === 0) return [];
 
   const results: RefreshResult[] = [];
 
-  for (const [repoIndex, repo] of referenceRepos.entries()) {
+  for (const [repoIndex, repo] of readOnlyRepos.entries()) {
     const repoPath = join(sessionPath, repo.dir);
+    const dirty = await hasUncommittedChanges(repoPath);
 
-    // Check if this is a symlink (reference repo)
-    const isRef = await isSymlink(repoPath);
-
-    if (isRef) {
-      // Verify symlink is valid, repair if needed
-      const isValid = await verifyReferenceLink(repo, sessionPath);
-      if (!isValid) {
-        onProgress?.(repoIndex, "refreshing", [`Repairing link to ${repo.owner}/${repo.name}...`]);
-        try {
-          await repairReferenceLink(repo, sessionPath, (status, lines) => {
-            if (status === "cloning") onProgress?.(repoIndex, "refreshing", lines);
-          });
-        } catch (error) {
-          results.push({
-            repo,
-            status: "error",
-            reason: error instanceof Error ? error.message : String(error),
-          });
-          onProgress?.(repoIndex, "error", [
-            error instanceof Error ? error.message : String(error),
-          ]);
-          continue;
-        }
-      }
-
-      // Refresh the cached reference repo
-      const result = await refreshReferenceRepo(repo, (status, lines) => {
-        onProgress?.(repoIndex, status, lines);
+    if (dirty) {
+      results.push({
+        repo,
+        status: "skipped",
+        reason: "uncommitted changes",
       });
-      results.push(result);
-    } else {
-      // Non-symlink reference repo (legacy or converted) - use standard git pull
-      const dirty = await hasUncommittedChanges(repoPath);
-
-      if (dirty) {
-        results.push({
-          repo,
-          status: "skipped",
-          reason: "uncommitted changes",
-        });
-        onProgress?.(repoIndex, "skipped", ["Skipped: uncommitted changes"]);
-        continue;
-      }
+      onProgress?.(repoIndex, "skipped", ["Skipped: uncommitted changes"]);
+      continue;
+    }
 
-      onProgress?.(repoIndex, "refreshing", [`Pulling ${repo.owner}/${repo.name}...`]);
+    onProgress?.(repoIndex, "refreshing", [`Pulling ${repo.owner}/${repo.name}...`]);
 
-      const proc = Bun.spawn(["git", "-C", repoPath, "pull", "--ff-only", "--depth", "1"], {
-        stdout: "pipe",
-        stderr: "pipe",
-      });
-
-      const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
-        maxBufferLines: 5,
-        onBufferUpdate: (buffer) => onProgress?.(repoIndex, "refreshing", buffer),
-      });
-      const exitCode = success ? 0 : 1;
-
-      if (exitCode !== 0) {
-        const reason = fullOutput.trim() || `git pull exited with code ${exitCode}`;
-        results.push({
-          repo,
-          status: "error",
-          reason,
-        });
-        onProgress?.(repoIndex, "error", output.length > 0 ? [...output] : [reason]);
-        continue;
-      }
+    const proc = Bun.spawn(["git", "-C", repoPath, "pull", "--ff-only", "--depth", "1"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
 
-      const normalized = fullOutput.toLowerCase();
-      const upToDate =
-        normalized.includes("already up to date") || normalized.includes("already up-to-date");
+    const { success, output, fullOutput } = await readProcessOutputWithBuffer(proc, {
+      maxBufferLines: 5,
+      onBufferUpdate: (buffer) => onProgress?.(repoIndex, "refreshing", buffer),
+    });
+    const exitCode = success ? 0 : 1;
 
+    if (exitCode !== 0) {
+      const reason = fullOutput.trim() || `git pull exited with code ${exitCode}`;
       results.push({
         repo,
-        status: upToDate ? "up-to-date" : "updated",
+        status: "error",
+        reason,
       });
-      onProgress?.(repoIndex, upToDate ? "up-to-date" : "updated", [...output]);
+      onProgress?.(repoIndex, "error", output.length > 0 ? [...output] : [reason]);
+      continue;
     }
+
+    const normalized = fullOutput.toLowerCase();
+    const upToDate =
+      normalized.includes("already up to date") || normalized.includes("already up-to-date");
+
+    results.push({
+      repo,
+      status: upToDate ? "up-to-date" : "updated",
+    });
+    onProgress?.(repoIndex, upToDate ? "up-to-date" : "updated", [...output]);
   }
 
   return results;

package/src/naming.ts

@@ -7,7 +7,7 @@ export async function generateSessionName(repos: RepoSpec[], goal?: string): Pro
 
   try {
     const { text } = await generateText({
-      model: "xai/grok-4-fast-non-reasoning",
+      model: "xai/grok-3-mini-fast",
       temperature: 1.2, // Higher temperature for more creative/varied names
       prompt: `Generate a creative, memorable session name for a coding workspace.
 
@@ -49,7 +49,7 @@ Reply with ONLY the name, nothing else. No quotes, no explanation.`,
   }
 }
 
-function generateFallbackName(repos: RepoSpec[]): string {
+export function generateFallbackName(repos: RepoSpec[]): string {
   // Simple fallback: first repo name + short hash
   const base = repos[0]?.name || "session";
   const hash = Math.random().toString(36).slice(2, 6);