letmecook 0.0.1 → 0.0.2

package/src/flows/edit-session.ts

@@ -0,0 +1,107 @@
+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";
+
+export interface EditSessionParams {
+  session: Session;
+  updates: {
+    repos?: RepoSpec[];
+    goal?: string;
+    skills?: string[];
+  };
+}
+
+export async function editSession(params: EditSessionParams): Promise<Session | null> {
+  const { session, updates } = params;
+
+  if (!updates.repos && !updates.goal && !updates.skills) {
+    return session;
+  }
+
+  let currentSession = session;
+
+  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)`);
+          }
+        }
+      });
+
+      await recordRepoHistory(newRepos);
+      await writeAgentsMd(currentSession);
+
+      console.log("\n✅ Repositories added.\n");
+    }
+
+    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 (newSkills.length > 0) {
+      console.log(`\nAdding ${newSkills.length} skill package(s)...`);
+
+      for (const skill of newSkills) {
+        console.log(`  Adding ${skill}...`);
+        const { success } = await addSkillToSession(currentSession, skill, (output) => {
+          console.log(`    ${output}`);
+        });
+
+        if (success) {
+          console.log(`  ✓ ${skill}`);
+        } else {
+          console.log(`  ✗ ${skill} (addition failed)`);
+        }
+      }
+
+      const allSkills = [...(session.skills || []), ...newSkills];
+      const updatedSession = await updateSessionSkills(currentSession.name, allSkills);
+
+      if (updatedSession) {
+        currentSession = updatedSession;
+        await writeAgentsMd(currentSession);
+        console.log("\n✅ Skills added.\n");
+      }
+    }
+  }
+
+  if (updates.goal !== undefined) {
+    const sessionGoal = updates.goal || undefined;
+    const updatedSession = { ...currentSession, goal: sessionGoal };
+
+    await writeAgentsMd(updatedSession);
+    currentSession = updatedSession as Session;
+  }
+
+  return currentSession;
+}
+
+export async function nukeSession(session: Session): Promise<boolean> {
+  const success = await deleteSession(session.name);
+  return success;
+}
+
+export async function removeSkill(session: Session, skillString: string): Promise<Session> {
+  const updatedSession = await removeSkillFromSession(session, skillString);
+  return updatedSession || session;
+}

package/src/flows/index.ts

@@ -0,0 +1,5 @@
+export { createNewSession, type NewSessionParams, type NewSessionResult } from "./new-session";
+export { resumeSession, type ResumeSessionParams, type ResumeResult } from "./resume-session";
+export { editSession, nukeSession, removeSkill, type EditSessionParams } from "./edit-session";
+export { addSkillsFlow, type AddSkillsParams, type AddSkillsResult } from "./add-skills";
+export { addReposFlow, type AddReposParams, type AddReposResult } from "./add-repos";

package/src/flows/new-session.ts

@@ -0,0 +1,182 @@
+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";
+
+export interface NewSessionParams {
+  repos: RepoSpec[];
+  goal?: string;
+  skills?: string[];
+  mode: "cli" | "tui";
+  skipConflictCheck?: boolean;
+}
+
+export interface NewSessionResult {
+  session: Session;
+  skipped?: boolean;
+}
+
+export async function createNewSession(
+  renderer: CliRenderer,
+  params: NewSessionParams,
+): Promise<NewSessionResult | null> {
+  const { repos, goal, skills, mode, skipConflictCheck = false } = params;
+
+  try {
+    if (!skipConflictCheck) {
+      const existingSession = await findMatchingSession(repos);
+
+      if (existingSession) {
+        const choice = await showConflictPrompt(renderer, existingSession);
+
+        switch (choice) {
+          case "resume":
+            return { session: existingSession, skipped: true };
+
+          case "nuke":
+            await deleteSession(existingSession.name);
+            break;
+
+          case "new":
+            break;
+
+          case "cancel":
+            return null;
+        }
+      }
+    }
+
+    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,
+        goal,
+      });
+
+      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,
+        goal,
+        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);
+        }
+      });
+
+      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)`);
+          }
+        }
+      }
+
+      await recordRepoHistory(repos);
+
+      cloneProgressState.phase = "done";
+      updateProgress(renderer, cloneProgressState);
+
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+
+      hideProgress(renderer);
+
+      await writeAgentsMd(session);
+      await createClaudeMdSymlink(session.path);
+
+      return { session };
+    } else {
+      const session = await createSession(
+        sessionName,
+        repos,
+        goal,
+        skills?.length ? skills : undefined,
+      );
+
+      await cloneAllRepos(repos, session.path, (repoIndex, status) => {
+        const repoState = progressState.repos[repoIndex];
+        if (repoState) {
+          repoState.status = status;
+          updateProgress(renderer, progressState);
+        }
+      });
+
+      if (skills && skills.length > 0) {
+        progressState.phase = "installing-skills";
+        updateProgress(renderer, progressState);
+
+        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)`);
+          }
+        }
+      }
+
+      await writeAgentsMd(session);
+      await createClaudeMdSymlink(session.path);
+
+      progressState.phase = "done";
+      updateProgress(renderer, progressState);
+
+      await new Promise((resolve) => setTimeout(resolve, 500));
+
+      hideProgress(renderer);
+
+      return { session };
+    }
+  } catch (error) {
+    hideProgress(renderer);
+    throw error;
+  }
+}

package/src/flows/resume-session.ts

@@ -0,0 +1,231 @@
+import type { CliRenderer } from "@opentui/core";
+import type { Session } from "../types";
+import { updateSessionSettings } from "../sessions";
+import { refreshLatestRepos } from "../git";
+import { updateSkills } from "../skills";
+import { handleSmartExit } from "../ui/exit";
+import { showSessionSettings } from "../ui/session-settings";
+import { showDeleteConfirm } from "../ui/confirm-delete";
+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";
+
+export interface ResumeSessionParams {
+  session: Session;
+  mode: "cli" | "tui";
+  initialRefresh?: boolean;
+}
+
+export type ResumeResult = "resume" | "home";
+
+export async function resumeSession(
+  renderer: CliRenderer,
+  params: ResumeSessionParams,
+): Promise<ResumeResult> {
+  const { session, mode, initialRefresh = true } = params;
+
+  let currentSession = session;
+  let shouldRefresh = initialRefresh;
+
+  while (true) {
+    if (mode === "tui" && shouldRefresh) {
+      renderer = await createRenderer();
+      await refreshLatestBeforeResume(renderer, currentSession);
+      destroyRenderer();
+    } else if (shouldRefresh) {
+      await refreshLatestBeforeResumeSimple(currentSession);
+    }
+
+    await runOpencodeMode(mode, currentSession.path);
+    shouldRefresh = true;
+
+    if (mode === "tui") {
+      renderer = await createRenderer();
+    }
+
+    while (true) {
+      const exitResult = await handleSmartExit(renderer, currentSession);
+
+      if (exitResult.action === "resume") {
+        break;
+      }
+
+      if (exitResult.action === "home") {
+        destroyRenderer();
+        return "home";
+      }
+
+      if (exitResult.action === "delete") {
+        const choice = await showDeleteConfirm(renderer, currentSession);
+        if (choice === "confirm") {
+          await deleteSession(currentSession.name);
+        }
+        destroyRenderer();
+        return "home";
+      }
+
+      if (exitResult.action === "edit") {
+        const editResult = await showSessionSettings(renderer, currentSession);
+
+        if (
+          editResult.action === "saved" ||
+          editResult.action === "add-repos" ||
+          editResult.action === "add-skills"
+        ) {
+          const saved = await updateSessionSettings(editResult.session.name, {
+            repos: editResult.session.repos,
+            goal: editResult.session.goal,
+            skills: editResult.session.skills,
+          });
+
+          if (saved) {
+            currentSession = saved;
+            await writeAgentsMd(currentSession);
+          }
+        }
+
+        if (editResult.action === "add-repos") {
+          console.log("[TODO] Add repos flow - needs to be implemented");
+        }
+
+        if (editResult.action === "add-skills") {
+          console.log("[TODO] Add skills flow - needs to be implemented");
+        }
+      }
+    }
+
+    destroyRenderer();
+  }
+}
+
+async function refreshLatestBeforeResume(renderer: CliRenderer, session: Session): Promise<void> {
+  const latestRepos = session.repos.filter((repo) => repo.latest);
+  if (latestRepos.length === 0) return;
+
+  const refreshProgressState = showProgress(renderer, latestRepos, {
+    title: "Refreshing repositories",
+    label: "Refreshing latest repositories:",
+    initialPhase: "refreshing",
+  });
+  refreshProgressState.sessionName = session.name;
+  updateProgress(renderer, refreshProgressState);
+
+  const refreshResults = await refreshLatestRepos(
+    latestRepos,
+    session.path,
+    (repoIndex, status, outputLines) => {
+      const repoState = refreshProgressState.repos[repoIndex];
+      if (repoState) {
+        repoState.status = status;
+        if (outputLines) {
+          refreshProgressState.currentOutput = outputLines;
+        }
+        updateProgress(renderer, refreshProgressState);
+      }
+    },
+  );
+
+  refreshProgressState.phase = "done";
+  updateProgress(renderer, refreshProgressState);
+
+  await new Promise((resolve) => setTimeout(resolve, 700));
+  hideProgress(renderer);
+
+  const recloneTargets = refreshResults.filter(
+    (result) => result.status === "error" && result.repo.readOnly,
+  );
+
+  for (const result of recloneTargets) {
+    const choice = await showReclonePrompt(renderer, result.repo);
+
+    if (choice === "reclone") {
+      const recloneProgressState = showProgress(renderer, [result.repo], {
+        title: "Recloning repository",
+        label: "Recloning:",
+        initialPhase: "cloning",
+      });
+      recloneProgressState.sessionName = session.name;
+      updateProgress(renderer, recloneProgressState);
+
+      try {
+        await recloneRepo(result.repo, session.path, (status, outputLines) => {
+          const repoState = recloneProgressState.repos[0];
+          if (repoState) {
+            repoState.status = status;
+            if (outputLines) {
+              recloneProgressState.currentOutput = outputLines;
+            }
+            updateProgress(renderer, recloneProgressState);
+          }
+        });
+      } catch (error) {
+        const repoState = recloneProgressState.repos[0];
+        if (repoState) {
+          repoState.status = "error";
+        }
+        recloneProgressState.currentOutput = [
+          error instanceof Error ? error.message : String(error),
+        ];
+        updateProgress(renderer, recloneProgressState);
+      }
+
+      recloneProgressState.phase = "done";
+      updateProgress(renderer, recloneProgressState);
+      await new Promise((resolve) => setTimeout(resolve, 700));
+      hideProgress(renderer);
+    }
+  }
+}
+
+async function refreshLatestBeforeResumeSimple(session: Session): Promise<void> {
+  const latestRepos = session.repos.filter((repo) => repo.latest);
+  if (latestRepos.length === 0) return;
+
+  console.log("\nRefreshing latest repositories...");
+
+  const results = await refreshLatestRepos(latestRepos, session.path);
+
+  if (results.length === 0) return;
+
+  results.forEach((result) => {
+    const icon =
+      result.status === "updated"
+        ? "✓"
+        : result.status === "up-to-date"
+          ? "•"
+          : result.status === "skipped"
+            ? "↷"
+            : "✗";
+    const reason = result.reason ? ` (${result.reason})` : "";
+    console.log(`  ${icon} ${result.repo.owner}/${result.repo.name}${reason}`);
+  });
+
+  await updateSkillsSimple(session);
+}
+
+async function updateSkillsSimple(session: Session): Promise<void> {
+  if (!session.skills || session.skills.length === 0) return;
+
+  console.log("\nUpdating skills...");
+  const { success } = await updateSkills(session, (output) => {
+    console.log(`  ${output}`);
+  });
+
+  if (!success) {
+    console.log("  ⚠️ Skills update failed (continuing anyway)");
+  }
+}
+
+async function runOpencodeMode(mode: "cli" | "tui", sessionPath: string): Promise<void> {
+  const proc = Bun.spawn(["claude", "--dangerously-skip-permissions"], {
+    cwd: sessionPath,
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+    env: { ...process.env, IS_DEMO: mode === "tui" ? "1" : undefined },
+  });
+  await proc.exited;
+}