letmecook 0.0.15 → 0.0.17

package/src/ui/new-session.ts

@@ -27,11 +27,10 @@ export function showNewSessionPrompt(
 
     repos.forEach((repo, i) => {
       const branch = repo.branch ? ` (${repo.branch})` : " (default)";
-      const roMarker = repo.readOnly ? " [RO]" : "";
-      const latestMarker = repo.latest ? " [Latest]" : "";
+      const refMarker = repo.reference ? " [Ref]" : "";
       const repoText = new TextRenderable(renderer, {
         id: `repo-${i}`,
-        content: `  - ${repo.owner}/${repo.name}${branch}${roMarker}${latestMarker}`,
+        content: `  - ${repo.owner}/${repo.name}${branch}${refMarker}`,
         fg: "#94a3b8",
       });
       content.add(repoText);

package/src/ui/progress.ts

@@ -52,7 +52,7 @@ function getPhasePresentation(phase: ProgressPhase): { content: string; fg: stri
     case "installing-skills":
       return { content: "Installing skills...", fg: "#38bdf8" };
     case "refreshing":
-      return { content: "Refreshing latest repositories...", fg: "#38bdf8" };
+      return { content: "Refreshing reference repositories...", fg: "#38bdf8" };
     case "done":
       return { content: "Ready!", fg: "#22c55e" };
     default:

package/src/ui/session-settings.ts

@@ -208,7 +208,7 @@ export function showSessionSettings(
       if (selectedTarget === "goal") {
         customActions.push("Enter Edit");
       } else if (selectedTarget === "repo") {
-        customActions.push("r Toggle RO", "l Toggle Latest", "a Add repos");
+        customActions.push("r Toggle Ref", "a Add repos");
       } else if (selectedTarget === "skill") {
         customActions.push("x Remove", "a Add repos");
       }
@@ -342,22 +342,7 @@ export function showSessionSettings(
       if (key.name === "r" && selectedTarget === "repo") {
         const repo = updatedRepos[selectedRepoIndex];
         if (repo) {
-          repo.readOnly = !repo.readOnly;
-          if (!repo.readOnly) {
-            repo.latest = false;
-          }
-          updateReposList();
-        }
-        return;
-      }
-
-      if (key.name === "l" && selectedTarget === "repo") {
-        const repo = updatedRepos[selectedRepoIndex];
-        if (repo) {
-          repo.latest = !repo.latest;
-          if (repo.latest) {
-            repo.readOnly = true;
-          }
+          repo.reference = !repo.reference;
           updateReposList();
         }
         return;

package/src/utils/stream.ts

@@ -51,6 +51,12 @@ interface ReadProcessOutputWithBufferOptions {
   onBufferUpdate?: (buffer: string[]) => void;
 }
 
+export interface ReadWithControlOptions {
+  maxBufferLines?: number;
+  onBufferUpdate?: (buffer: string[]) => void;
+  shouldStop?: () => boolean; // Check if we should stop early
+}
+
 export async function readProcessOutputWithBuffer(
   proc: ReturnType<typeof Bun.spawn>,
   options?: ReadProcessOutputWithBufferOptions,
@@ -106,3 +112,86 @@ export async function readProcessOutputWithBuffer(
     fullOutput: fullOutputParts.join(""),
   };
 }
+
+export async function readProcessOutputWithControl(
+  proc: ReturnType<typeof Bun.spawn>,
+  options?: ReadWithControlOptions,
+): Promise<{ success: boolean; output: string[]; fullOutput: string; wasInterrupted: boolean }> {
+  const { maxBufferLines, onBufferUpdate, shouldStop } = options || {};
+  const outputBuffer: string[] = [];
+  let wasInterrupted = false;
+
+  const addLine = (line: string) => {
+    const trimmed = line.trim();
+    if (trimmed) {
+      outputBuffer.push(trimmed);
+      if (maxBufferLines && outputBuffer.length > maxBufferLines) {
+        outputBuffer.shift();
+      }
+      onBufferUpdate?.([...outputBuffer]);
+    }
+  };
+
+  const fullOutputParts: string[] = [];
+
+  const readStream = async (stream: ReadableStream<Uint8Array> | number | undefined) => {
+    if (!stream || typeof stream === "number") return;
+
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    try {
+      while (true) {
+        // Check if we should stop before each read
+        if (shouldStop?.()) {
+          wasInterrupted = true;
+          reader.releaseLock();
+          return;
+        }
+
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        const chunk = decoder.decode(value, { stream: true });
+        fullOutputParts.push(chunk);
+        buffer += chunk;
+
+        const lines = buffer.split(/[\r\n]+/);
+        buffer = lines.pop() || "";
+
+        for (const line of lines) {
+          addLine(line);
+        }
+
+        // Check again after processing
+        if (shouldStop?.()) {
+          wasInterrupted = true;
+          reader.releaseLock();
+          return;
+        }
+      }
+
+      if (buffer.trim()) {
+        addLine(buffer);
+      }
+    } catch {
+      // Stream may have been cancelled, that's ok
+    }
+  };
+
+  await Promise.all([readStream(proc.stdout), readStream(proc.stderr)]);
+
+  // Only wait for exit if not interrupted
+  let exitCode = 1;
+  if (!wasInterrupted) {
+    exitCode = await proc.exited;
+  }
+
+  return {
+    success: !wasInterrupted && exitCode === 0,
+    output: outputBuffer,
+    fullOutput: fullOutputParts.join(""),
+    wasInterrupted,
+  };
+}