letmecook 0.0.13 → 0.0.14

package/package.json

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

package/src/flows/add-repos.ts

@@ -1,10 +1,11 @@
+import { join } from "node:path";
 import type { CliRenderer } from "@opentui/core";
-import type { Session } from "../types";
+import type { Session, RepoSpec } from "../types";
 import { updateSessionRepos } from "../sessions";
-import { cloneAllRepos } from "../git";
 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";
 
 export interface AddReposParams {
   renderer: CliRenderer;
@@ -16,6 +17,33 @@ export interface AddReposResult {
   cancelled: boolean;
 }
 
+function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
+  return repos.map((repo) => {
+    const url = `https://github.com/${repo.owner}/${repo.name}.git`;
+    const targetDir = join(sessionPath, repo.dir);
+    const args = repo.branch
+      ? [
+          "git",
+          "clone",
+          "--depth",
+          "1",
+          "--single-branch",
+          "--branch",
+          repo.branch,
+          "--progress",
+          url,
+          targetDir,
+        ]
+      : ["git", "clone", "--depth", "1", "--single-branch", "--progress", url, targetDir];
+
+    return {
+      label: `Cloning ${repo.owner}/${repo.name}`,
+      command: args,
+      cwd: sessionPath,
+    };
+  });
+}
+
 export async function addReposFlow(params: AddReposParams): Promise<AddReposResult> {
   const { renderer, session } = params;
 
@@ -26,19 +54,30 @@ export async function addReposFlow(params: AddReposParams): Promise<AddReposResu
     const newRepos = addResult.repos.filter((r) => !existingSpecs.has(r.spec));
 
     if (newRepos.length > 0) {
-      console.log(`\nCloning ${newRepos.length} new repository(ies)...`);
-
-      await cloneAllRepos(newRepos, session.path, (repoIndex, status) => {
-        const repo = newRepos[repoIndex];
-        if (repo) {
-          if (status === "done") {
-            console.log(`  ✓ ${repo.owner}/${repo.name}`);
-          } else if (status === "error") {
-            console.log(`  ✗ ${repo.owner}/${repo.name} (failed)`);
-          }
-        }
+      const tasks = reposToCommandTasks(newRepos, session.path);
+
+      const results = await runCommands(renderer, {
+        title: "Adding repositories",
+        tasks,
+        showOutput: true,
+        outputLines: 5,
       });
 
+      // 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}`);
+          }
+        });
+      }
+
+      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;
@@ -46,11 +85,8 @@ export async function addReposFlow(params: AddReposParams): Promise<AddReposResu
       await recordRepoHistory(newRepos);
       await writeAgentsMd(nextSession);
 
-      console.log("\n✅ Repositories added.\n");
       return { session: nextSession, cancelled: false };
     }
-
-    console.log("\nNo new repositories to add (all already in session).\n");
   }
 
   return { session, cancelled: addResult.cancelled };

package/src/flows/edit-session.ts

@@ -1,10 +1,11 @@
+import { join } from "node:path";
 import type { Session, RepoSpec } from "../types";
 import { updateSessionRepos, updateSessionSkills, deleteSession } from "../sessions";
-import { cloneAllRepos } from "../git";
 import { writeAgentsMd } from "../agents-md";
 import { recordRepoHistory } from "../repo-history";
 import { removeSkillFromSession } from "../skills";
-import { addSkillToSession } from "../skills";
+import { createRenderer, destroyRenderer } from "../ui/renderer";
+import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
 
 export interface EditSessionParams {
   session: Session;
@@ -15,6 +16,41 @@ export interface EditSessionParams {
   };
 }
 
+function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
+  return repos.map((repo) => {
+    const url = `https://github.com/${repo.owner}/${repo.name}.git`;
+    const targetDir = join(sessionPath, repo.dir);
+    const args = repo.branch
+      ? [
+          "git",
+          "clone",
+          "--depth",
+          "1",
+          "--single-branch",
+          "--branch",
+          repo.branch,
+          "--progress",
+          url,
+          targetDir,
+        ]
+      : ["git", "clone", "--depth", "1", "--single-branch", "--progress", url, targetDir];
+
+    return {
+      label: `Cloning ${repo.owner}/${repo.name}`,
+      command: args,
+      cwd: sessionPath,
+    };
+  });
+}
+
+function skillsToCommandTasks(skills: string[], sessionPath: string): CommandTask[] {
+  return skills.map((skill) => ({
+    label: `Installing ${skill}`,
+    command: ["bunx", "skills", "add", skill, "-y"],
+    cwd: sessionPath,
+  }));
+}
+
 export async function editSession(params: EditSessionParams): Promise<Session | null> {
   const { session, updates } = params;
 
@@ -23,66 +59,88 @@ export async function editSession(params: EditSessionParams): Promise<Session |
   }
 
   let currentSession = session;
+  const renderer = await createRenderer();
+
+  try {
+    if (updates.repos) {
+      const existingSpecs = new Set(session.repos.map((r) => r.spec));
+      const newRepos = updates.repos.filter((r) => !existingSpecs.has(r.spec));
+
+      if (newRepos.length > 0) {
+        const tasks = reposToCommandTasks(newRepos, currentSession.path);
 
-  if (updates.repos) {
-    const existingSpecs = new Set(session.repos.map((r) => r.spec));
-    const newRepos = updates.repos.filter((r) => !existingSpecs.has(r.spec));
-
-    if (newRepos.length > 0) {
-      console.log(`\nCloning ${newRepos.length} new repository(ies)...`);
-
-      await cloneAllRepos(newRepos, currentSession.path, (repoIndex, status) => {
-        const repo = newRepos[repoIndex];
-        if (repo) {
-          if (status === "done") {
-            console.log(`  ✓ ${repo.owner}/${repo.name}`);
-          } else if (status === "error") {
-            console.log(`  ✗ ${repo.owner}/${repo.name} (failed)`);
-          }
+        const results = await runCommands(renderer, {
+          title: "Adding repositories",
+          tasks,
+          showOutput: true,
+          outputLines: 5,
+        });
+
+        // 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}`);
+            }
+          });
         }
-      });
 
-      await recordRepoHistory(newRepos);
-      await writeAgentsMd(currentSession);
+        await new Promise((resolve) => setTimeout(resolve, 700));
+        hideCommandRunner(renderer);
 
-      console.log("\n✅ Repositories added.\n");
-    }
+        await recordRepoHistory(newRepos);
+        await writeAgentsMd(currentSession);
+      }
 
-    const updatedSession = await updateSessionRepos(session.name, updates.repos);
-    if (updatedSession) {
-      currentSession = updatedSession;
+      const updatedSession = await updateSessionRepos(session.name, updates.repos);
+      if (updatedSession) {
+        currentSession = updatedSession;
+      }
     }
-  }
 
-  if (updates.skills) {
-    const existingSkills = new Set(session.skills || []);
-    const newSkills = updates.skills.filter((s) => !existingSkills.has(s));
+    if (updates.skills) {
+      const existingSkills = new Set(session.skills || []);
+      const newSkills = updates.skills.filter((s) => !existingSkills.has(s));
 
-    if (newSkills.length > 0) {
-      console.log(`\nAdding ${newSkills.length} skill package(s)...`);
+      if (newSkills.length > 0) {
+        const tasks = skillsToCommandTasks(newSkills, currentSession.path);
 
-      for (const skill of newSkills) {
-        console.log(`  Adding ${skill}...`);
-        const { success } = await addSkillToSession(currentSession, skill, (output) => {
-          console.log(`    ${output}`);
+        const results = await runCommands(renderer, {
+          title: "Adding skills",
+          tasks,
+          showOutput: true,
+          outputLines: 5,
         });
 
-        if (success) {
-          console.log(`  ✓ ${skill}`);
-        } else {
-          console.log(`  ✗ ${skill} (addition failed)`);
+        // Check for errors
+        const errors = results.filter((r) => !r.success);
+        if (errors.length > 0) {
+          console.error(`\n⚠️  ${errors.length} skill(s) failed to install:`);
+          errors.forEach((err) => {
+            console.error(`  ✗ ${err.task.label}`);
+            if (err.error) {
+              console.error(`    ${err.error}`);
+            }
+          });
         }
-      }
 
-      const allSkills = [...(session.skills || []), ...newSkills];
-      const updatedSession = await updateSessionSkills(currentSession.name, allSkills);
+        await new Promise((resolve) => setTimeout(resolve, 700));
+        hideCommandRunner(renderer);
 
-      if (updatedSession) {
-        currentSession = updatedSession;
-        await writeAgentsMd(currentSession);
-        console.log("\n✅ Skills added.\n");
+        const allSkills = [...(session.skills || []), ...newSkills];
+        const updatedSession = await updateSessionSkills(currentSession.name, allSkills);
+
+        if (updatedSession) {
+          currentSession = updatedSession;
+          await writeAgentsMd(currentSession);
+        }
       }
     }
+  } finally {
+    destroyRenderer();
   }
 
   if (updates.goal !== undefined) {

package/src/flows/new-session.ts

@@ -1,14 +1,13 @@
+import { join } from "node:path";
 import type { CliRenderer } from "@opentui/core";
 import type { Session, RepoSpec } from "../types";
 import { findMatchingSession, createSession, deleteSession } from "../sessions";
-import { cloneAllRepos } from "../git";
 import { generateSessionName } from "../naming";
 import { writeAgentsMd, createClaudeMdSymlink } from "../agents-md";
-import { addSkillToSession } from "../skills";
 import { recordRepoHistory } from "../repo-history";
-import { showProgress, updateProgress, hideProgress } from "../ui/progress";
 import { showAgentProposal } from "../ui/agent-proposal";
 import { showConflictPrompt } from "../ui/conflict";
+import { runCommands, hideCommandRunner, type CommandTask } from "../ui/common/command-runner";
 
 export interface NewSessionParams {
   repos: RepoSpec[];
@@ -23,6 +22,41 @@ export interface NewSessionResult {
   skipped?: boolean;
 }
 
+function reposToCommandTasks(repos: RepoSpec[], sessionPath: string): CommandTask[] {
+  return repos.map((repo) => {
+    const url = `https://github.com/${repo.owner}/${repo.name}.git`;
+    const targetDir = join(sessionPath, repo.dir);
+    const args = repo.branch
+      ? [
+          "git",
+          "clone",
+          "--depth",
+          "1",
+          "--single-branch",
+          "--branch",
+          repo.branch,
+          "--progress",
+          url,
+          targetDir,
+        ]
+      : ["git", "clone", "--depth", "1", "--single-branch", "--progress", url, targetDir];
+
+    return {
+      label: `Cloning ${repo.owner}/${repo.name}`,
+      command: args,
+      cwd: sessionPath,
+    };
+  });
+}
+
+function skillsToCommandTasks(skills: string[], sessionPath: string): CommandTask[] {
+  return skills.map((skill) => ({
+    label: `Installing ${skill}`,
+    command: ["bunx", "skills", "add", skill, "-y"],
+    cwd: sessionPath,
+  }));
+}
+
 export async function createNewSession(
   renderer: CliRenderer,
   params: NewSessionParams,
@@ -53,20 +87,9 @@ export async function createNewSession(
       }
     }
 
-    const progressState = showProgress(renderer, repos);
-
-    progressState.phase = "naming";
-    updateProgress(renderer, progressState);
-
     const sessionName = await generateSessionName(repos, goal);
-    progressState.sessionName = sessionName;
-    progressState.phase = "cloning";
-    updateProgress(renderer, progressState);
 
     if (mode === "tui") {
-      progressState.phase = "proposal";
-      updateProgress(renderer, progressState);
-
       showAgentProposal(renderer, {
         sessionName,
         repos,
@@ -75,11 +98,6 @@ export async function createNewSession(
 
       await new Promise((resolve) => setTimeout(resolve, 3000));
 
-      const cloneProgressState = showProgress(renderer, repos);
-      cloneProgressState.sessionName = sessionName;
-      cloneProgressState.phase = "cloning";
-      updateProgress(renderer, cloneProgressState);
-
       const session = await createSession(
         sessionName,
         repos,
@@ -87,49 +105,42 @@ export async function createNewSession(
         skills?.length ? skills : undefined,
       );
 
-      await cloneAllRepos(repos, session.path, (repoIndex, status, outputLines) => {
-        const repoState = cloneProgressState.repos[repoIndex];
-        if (repoState) {
-          repoState.status = status;
-          if (outputLines) {
-            cloneProgressState.currentOutput = outputLines;
-          }
-          updateProgress(renderer, cloneProgressState);
-        }
+      // Build all tasks (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,
       });
 
-      if (skills && skills.length > 0) {
-        cloneProgressState.phase = "installing-skills";
-        updateProgress(renderer, cloneProgressState);
-
-        for (const skill of skills) {
-          console.log(`Installing skill: ${skill}...`);
-          const { success } = await addSkillToSession(session, skill, (output) => {
-            console.log(`  ${output}`);
-          });
-
-          if (success) {
-            console.log(`✓ ${skill}`);
-          } else {
-            console.log(`✗ ${skill} (installation failed)`);
+      // 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}`);
           }
-        }
+        });
       }
 
       await recordRepoHistory(repos);
 
-      cloneProgressState.phase = "done";
-      updateProgress(renderer, cloneProgressState);
-
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-
-      hideProgress(renderer);
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      hideCommandRunner(renderer);
 
       await writeAgentsMd(session);
       await createClaudeMdSymlink(session.path);
 
       return { session };
     } else {
+      // CLI mode - simpler output
       const session = await createSession(
         sessionName,
         repos,
@@ -137,46 +148,40 @@ export async function createNewSession(
         skills?.length ? skills : undefined,
       );
 
-      await cloneAllRepos(repos, session.path, (repoIndex, status) => {
-        const repoState = progressState.repos[repoIndex];
-        if (repoState) {
-          repoState.status = status;
-          updateProgress(renderer, progressState);
-        }
-      });
+      console.log(`\nCloning ${repos.length} repository(ies)...`);
 
-      if (skills && skills.length > 0) {
-        progressState.phase = "installing-skills";
-        updateProgress(renderer, progressState);
+      const tasks: CommandTask[] = [
+        ...reposToCommandTasks(repos, session.path),
+        ...(skills && skills.length > 0 ? skillsToCommandTasks(skills, session.path) : []),
+      ];
 
-        for (const skill of skills) {
-          console.log(`Installing skill: ${skill}...`);
-          const { success } = await addSkillToSession(session, skill, (output) => {
-            console.log(`  ${output}`);
-          });
+      const results = await runCommands(renderer, {
+        title: "Setting up session",
+        tasks,
+        showOutput: false, // CLI mode doesn't need visual output
+      });
 
-          if (success) {
-            console.log(`✓ ${skill}`);
-          } else {
-            console.log(`✗ ${skill} (installation failed)`);
+      // 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);
 
-      progressState.phase = "done";
-      updateProgress(renderer, progressState);
-
-      await new Promise((resolve) => setTimeout(resolve, 500));
-
-      hideProgress(renderer);
+      hideCommandRunner(renderer);
 
       return { session };
     }
   } catch (error) {
-    hideProgress(renderer);
+    hideCommandRunner(renderer);
     throw error;
   }
 }