letmecook 0.0.1 → 0.0.2

package/src/ui/skills.ts

@@ -0,0 +1,185 @@
+import {
+  type CliRenderer,
+  TextRenderable,
+  InputRenderable,
+  SelectRenderable,
+  SelectRenderableEvents,
+  type KeyEvent,
+} from "@opentui/core";
+import { createBaseLayout, clearLayout } from "./renderer";
+
+export interface SkillsPromptResult {
+  skills: string[];
+  cancelled: boolean;
+}
+
+export async function showSkillsPrompt(
+  renderer: CliRenderer,
+  _existingSkills: string[] = [],
+): Promise<SkillsPromptResult> {
+  return new Promise((resolve) => {
+    clearLayout(renderer);
+
+    const { content } = createBaseLayout(renderer, "Add skills to session");
+
+    const description = new TextRenderable(renderer, {
+      id: "description",
+      content:
+        "Enter skill packages to install (e.g., vercel-labs/agent-skills).\nSkills will be installed in the session directory.",
+      fg: "#64748b",
+      marginBottom: 1,
+    });
+    content.add(description);
+
+    const input = new InputRenderable(renderer, {
+      id: "skill-input",
+      width: 60,
+      height: 1,
+      placeholder: "Enter skill package",
+      placeholderColor: "#64748b",
+      backgroundColor: "#334155",
+      textColor: "#f8fafc",
+      cursorColor: "#38bdf8",
+      marginTop: 1,
+    });
+    content.add(input);
+
+    const existingSkillsText = new TextRenderable(renderer, {
+      id: "existing-skills",
+      content: "",
+      fg: "#94a3b8",
+      marginTop: 1,
+      marginBottom: 0,
+    });
+    content.add(existingSkillsText);
+
+    const confirmation = new SelectRenderable(renderer, {
+      id: "confirmation-select",
+      width: 40,
+      height: 1,
+      options: [
+        { name: "Add another skill", description: "", value: "yes" },
+        { name: "Done adding skills", description: "", value: "no" },
+      ],
+      showDescription: false,
+      backgroundColor: "transparent",
+      focusedBackgroundColor: "transparent",
+      selectedBackgroundColor: "#334155",
+      textColor: "#e2e8f0",
+      selectedTextColor: "#38bdf8",
+      descriptionColor: "#64748b",
+      selectedDescriptionColor: "#94a3b8",
+      marginTop: 1,
+    });
+    content.add(confirmation);
+
+    const instructions = new TextRenderable(renderer, {
+      id: "instructions",
+      content: "\n[Enter] Add skill   [Ctrl+D] Done   [Esc] Cancel",
+      fg: "#64748b",
+      marginTop: 1,
+    });
+    content.add(instructions);
+
+    const skills: string[] = [];
+    let showingConfirmation = false;
+
+    const updateExistingSkills = () => {
+      if (skills.length === 0) {
+        existingSkillsText.content = "";
+      } else {
+        const text = skills.map((skill) => `  ✓ ${skill}`).join("\n");
+        existingSkillsText.content = `Added skills:\n${text}`;
+      }
+    };
+
+    const cleanup = () => {
+      renderer.keyInput.off("keypress", handleKeypress);
+      input.blur();
+      confirmation.off(SelectRenderableEvents.ITEM_SELECTED, handleConfirm);
+      confirmation.blur();
+      clearLayout(renderer);
+    };
+
+    const handleKeypress = (key: KeyEvent) => {
+      if (showingConfirmation) {
+        if (key.name === "return" || key.name === "enter") {
+          cleanup();
+          resolve({
+            skills,
+            cancelled: false,
+          });
+          return;
+        }
+        if (key.name === "escape") {
+          cleanup();
+          resolve({
+            skills,
+            cancelled: false,
+          });
+          return;
+        }
+        if (key.name === "d" && key.ctrl) {
+          cleanup();
+          resolve({
+            skills,
+            cancelled: false,
+          });
+          return;
+        }
+        return;
+      }
+
+      if (key.name === "escape") {
+        cleanup();
+        resolve({
+          skills: [],
+          cancelled: true,
+        });
+        return;
+      }
+
+      if (key.name === "d" && key.ctrl) {
+        cleanup();
+        resolve({
+          skills,
+          cancelled: false,
+        });
+        return;
+      }
+
+      if (key.name === "return" || key.name === "enter") {
+        const skill = input.value.trim();
+        if (skill) {
+          skills.push(skill);
+          updateExistingSkills();
+          input.value = "";
+          showingConfirmation = true;
+          confirmation.focus();
+          instructions.content = "\n[Enter] Add another   [Ctrl+D] Done   [Esc] Cancel";
+        }
+      }
+    };
+
+    const handleConfirm = (_index: number, option: { value: string }) => {
+      if (option.value === "yes") {
+        showingConfirmation = false;
+        input.focus();
+        instructions.content = "\n[Enter] Add skill   [Esc] Cancel";
+        return;
+      }
+
+      cleanup();
+      resolve({
+        skills,
+        cancelled: false,
+      });
+    };
+
+    input.focus();
+    confirmation.off(SelectRenderableEvents.ITEM_SELECTED, handleConfirm);
+    renderer.keyInput.off("keypress", handleKeypress);
+    renderer.keyInput.on("keypress", handleKeypress);
+    confirmation.on(SelectRenderableEvents.ITEM_SELECTED, handleConfirm);
+  });
+}

package/src/utils/stream.ts

@@ -0,0 +1,108 @@
+export async function readProcessOutput(
+  proc: ReturnType<typeof Bun.spawn>,
+  onOutput?: (line: string) => void,
+): Promise<{ success: boolean; output: string[] }> {
+  const outputBuffer: string[] = [];
+  const addLine = (line: string) => {
+    const trimmed = line.trim();
+    if (trimmed) {
+      outputBuffer.push(trimmed);
+      onOutput?.(trimmed);
+    }
+  };
+
+  const readStream = async (stream: ReadableStream<Uint8Array> | number | undefined) => {
+    if (!stream || typeof stream === "number") return;
+
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const chunk = decoder.decode(value, { stream: true });
+      buffer += chunk;
+
+      const lines = buffer.split(/[\r\n]+/);
+      buffer = lines.pop() || "";
+
+      for (const line of lines) {
+        addLine(line);
+      }
+    }
+
+    if (buffer.trim()) {
+      addLine(buffer);
+    }
+  };
+
+  await Promise.all([readStream(proc.stdout), readStream(proc.stderr)]);
+  const exitCode = await proc.exited;
+
+  return {
+    success: exitCode === 0,
+    output: outputBuffer,
+  };
+}
+
+interface ReadProcessOutputWithBufferOptions {
+  maxBufferLines?: number;
+  onBufferUpdate?: (buffer: string[]) => void;
+}
+
+export async function readProcessOutputWithBuffer(
+  proc: ReturnType<typeof Bun.spawn>,
+  options?: ReadProcessOutputWithBufferOptions,
+): Promise<{ success: boolean; output: string[]; fullOutput: string }> {
+  const { maxBufferLines, onBufferUpdate } = options || {};
+  const outputBuffer: string[] = [];
+  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 = "";
+
+    while (true) {
+      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);
+      }
+    }
+
+    if (buffer.trim()) {
+      addLine(buffer);
+    }
+  };
+
+  await Promise.all([readStream(proc.stdout), readStream(proc.stderr)]);
+  const exitCode = await proc.exited;
+
+  return {
+    success: exitCode === 0,
+    output: outputBuffer,
+    fullOutput: fullOutputParts.join(""),
+  };
+}