letmecook 0.0.1 → 0.0.4

package/src/git.ts

@@ -0,0 +1,256 @@
+import { join } from "node:path";
+import { rm } from "node:fs/promises";
+import type { RepoSpec } from "./types";
+import { readProcessOutputWithBuffer } from "./utils/stream";
+
+export interface CloneProgress {
+  repo: RepoSpec;
+  status: "pending" | "cloning" | "done" | "error";
+  error?: string;
+  outputLines?: string[]; // Last 5 lines of git output
+}
+
+export interface RefreshResult {
+  repo: RepoSpec;
+  status: "updated" | "up-to-date" | "skipped" | "error";
+  reason?: string;
+}
+
+export type RefreshProgressStatus = "refreshing" | "updated" | "up-to-date" | "skipped" | "error";
+
+export async function cloneRepo(
+  repo: RepoSpec,
+  sessionPath: string,
+  onProgress?: (status: CloneProgress["status"], outputLines?: string[]) => void,
+): Promise<void> {
+  const url = `https://github.com/${repo.owner}/${repo.name}.git`;
+  const targetDir = join(sessionPath, repo.dir);
+  onProgress?.("cloning");
+
+  try {
+    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];
+
+    const proc = Bun.spawn(args, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    // Buffer to collect output lines
+    const outputBuffer: string[] = [];
+    const MAX_LINES = 5;
+
+    // Helper to add line to buffer and notify
+    const addLine = (line: string) => {
+      const trimmed = line.trim();
+      if (trimmed) {
+        outputBuffer.push(trimmed);
+        if (outputBuffer.length > MAX_LINES) {
+          outputBuffer.shift();
+        }
+        onProgress?.("cloning", [...outputBuffer]);
+      }
+    };
+
+    // Read stderr (git clone sends progress to stderr)
+    const stderrReader = proc.stderr.getReader();
+    const decoder = new TextDecoder();
+    let stderrBuffer = "";
+
+    const readStderr = async () => {
+      while (true) {
+        const { done, value } = await stderrReader.read();
+        if (done) break;
+        stderrBuffer += decoder.decode(value, { stream: true });
+
+        // Process lines (split on newline or carriage return for progress updates)
+        const lines = stderrBuffer.split(/[\r\n]+/);
+        stderrBuffer = lines.pop() || "";
+
+        for (const line of lines) {
+          addLine(line);
+        }
+      }
+      // Process remaining buffer
+      if (stderrBuffer.trim()) {
+        addLine(stderrBuffer);
+      }
+    };
+
+    // Read stdout as well
+    const stdoutReader = proc.stdout.getReader();
+    let stdoutBuffer = "";
+
+    const readStdout = async () => {
+      while (true) {
+        const { done, value } = await stdoutReader.read();
+        if (done) break;
+        stdoutBuffer += decoder.decode(value, { stream: true });
+
+        const lines = stdoutBuffer.split(/[\r\n]+/);
+        stdoutBuffer = lines.pop() || "";
+
+        for (const line of lines) {
+          addLine(line);
+        }
+      }
+      if (stdoutBuffer.trim()) {
+        addLine(stdoutBuffer);
+      }
+    };
+
+    // Read both streams and wait for process
+    await Promise.all([readStderr(), readStdout()]);
+    const exitCode = await proc.exited;
+
+    if (exitCode !== 0) {
+      onProgress?.("error", [...outputBuffer]);
+      throw new Error(`git clone exited with code ${exitCode}`);
+    }
+
+    onProgress?.("done", [...outputBuffer]);
+  } catch (error) {
+    onProgress?.("error");
+    throw new Error(
+      `Failed to clone ${repo.owner}/${repo.name}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+      { cause: error },
+    );
+  }
+}
+
+export async function recloneRepo(
+  repo: RepoSpec,
+  sessionPath: string,
+  onProgress?: (status: CloneProgress["status"], outputLines?: string[]) => void,
+): Promise<void> {
+  const repoPath = join(sessionPath, repo.dir);
+
+  try {
+    await rm(repoPath, { recursive: true, force: true });
+    await cloneRepo(repo, sessionPath, onProgress);
+  } catch (error) {
+    onProgress?.("error");
+    throw new Error(
+      `Failed to reclone ${repo.owner}/${repo.name}: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+      { cause: error },
+    );
+  }
+}
+
+export async function cloneAllRepos(
+  repos: RepoSpec[],
+  sessionPath: string,
+  onProgress?: (repoIndex: number, status: CloneProgress["status"], outputLines?: string[]) => void,
+): Promise<void> {
+  // Clone repos in parallel
+  await Promise.all(
+    repos.map(async (repo, index) => {
+      await cloneRepo(repo, sessionPath, (status, outputLines) => {
+        onProgress?.(index, status, outputLines);
+      });
+    }),
+  );
+}
+
+export async function hasUncommittedChanges(repoPath: string): Promise<boolean> {
+  const proc = Bun.spawn(["git", "status", "--porcelain"], {
+    cwd: repoPath,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const output = await new Response(proc.stdout).text();
+  await proc.exited;
+  return output.trim().length > 0;
+}
+
+export async function sessionHasUncommittedChanges(
+  repos: RepoSpec[],
+  sessionPath: string,
+): Promise<{ hasChanges: boolean; reposWithChanges: RepoSpec[] }> {
+  const results = await Promise.all(
+    repos.map(async (repo) => ({
+      repo,
+      hasChanges: await hasUncommittedChanges(join(sessionPath, repo.dir)),
+    })),
+  );
+  const reposWithChanges = results.filter((r) => r.hasChanges).map((r) => r.repo);
+  return { hasChanges: reposWithChanges.length > 0, reposWithChanges };
+}
+
+export async function refreshLatestRepos(
+  repos: RepoSpec[],
+  sessionPath: string,
+  onProgress?: (repoIndex: number, status: RefreshProgressStatus, outputLines?: string[]) => void,
+): Promise<RefreshResult[]> {
+  const latestRepos = repos.filter((repo) => repo.latest);
+  if (latestRepos.length === 0) return [];
+
+  const results: RefreshResult[] = [];
+
+  for (const [repoIndex, repo] of latestRepos.entries()) {
+    const repoPath = join(sessionPath, repo.dir);
+    const dirty = await hasUncommittedChanges(repoPath);
+
+    if (dirty) {
+      results.push({
+        repo,
+        status: "skipped",
+        reason: "uncommitted changes",
+      });
+      onProgress?.(repoIndex, "skipped", ["Skipped: uncommitted changes"]);
+      continue;
+    }
+
+    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 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

@@ -0,0 +1,57 @@
+import { generateText } from "ai";
+import type { RepoSpec } from "./types";
+import { generateUniqueName } from "./sessions";
+
+export async function generateSessionName(repos: RepoSpec[], goal?: string): Promise<string> {
+  const repoList = repos.map((r) => `${r.owner}/${r.name}`).join(", ");
+
+  try {
+    const { text } = await generateText({
+      model: "xai/grok-4-fast-non-reasoning",
+      temperature: 1.2, // Higher temperature for more creative/varied names
+      prompt: `Generate a creative, memorable session name for a coding workspace.
+
+Repos: ${repoList}
+${goal ? `Goal: ${goal}` : "No specific goal provided."}
+
+Requirements:
+- Max 24 characters total
+- Lowercase kebab-case only (e.g., "test-bot-fusion", "react-dash")
+- Creative and memorable - don't just mash repo names together
+- Should capture the essence of the goal if provided
+- No special characters except hyphens
+- No numbers unless they add meaning
+
+Reply with ONLY the name, nothing else. No quotes, no explanation.`,
+    });
+
+    // Clean up the response
+    let name = text
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, "")
+      .replace(/--+/g, "-")
+      .replace(/^-|-$/g, "")
+      .slice(0, 24);
+
+    // Fallback if AI returns garbage
+    if (!name || name.length < 3) {
+      name = generateFallbackName(repos);
+    }
+
+    // Ensure uniqueness
+    return generateUniqueName(name);
+  } catch (error) {
+    // If AI fails, use fallback
+    console.error("AI naming failed, using fallback:", error);
+    const fallback = generateFallbackName(repos);
+    return generateUniqueName(fallback);
+  }
+}
+
+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);
+  return `${base}-${hash}`.slice(0, 24);
+}

package/src/opencode-integration.ts

@@ -0,0 +1,20 @@
+import { spawn } from "node:child_process";
+
+export async function runInteractiveOpencode(sessionPath: string): Promise<void> {
+  return new Promise((resolve) => {
+    const proc = spawn("claude", ["--dangerously-skip-permissions"], {
+      cwd: sessionPath,
+      stdio: "inherit",
+      env: { ...process.env, IS_DEMO: "1" },
+    });
+
+    proc.on("close", () => {
+      resolve();
+    });
+
+    proc.on("error", (error) => {
+      console.error(`Failed to start claude: ${error.message}`);
+      resolve();
+    });
+  });
+}

package/src/repo-history.ts

@@ -0,0 +1,82 @@
+import { Database } from "bun:sqlite";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir } from "node:fs/promises";
+import type { RepoSpec } from "./types";
+
+const DATA_DIR = join(homedir(), ".letmecook");
+const DB_PATH = join(DATA_DIR, "history.sqlite");
+
+let db: Database | null = null;
+
+export interface RepoHistoryItem {
+  spec: string;
+  owner: string;
+  name: string;
+  branch: string | null;
+  lastUsed: string;
+  timesUsed: number;
+}
+
+async function getDb(): Promise<Database> {
+  if (db) return db;
+
+  await mkdir(DATA_DIR, { recursive: true });
+  db = new Database(DB_PATH, { create: true });
+  db.exec(`
+    create table if not exists repo_history (
+      spec text primary key,
+      owner text not null,
+      name text not null,
+      branch text,
+      last_used text not null,
+      times_used integer not null default 1
+    );
+  `);
+  db.exec("create index if not exists idx_repo_history_last_used on repo_history(last_used);");
+
+  return db;
+}
+
+export async function listRepoHistory(limit = 50): Promise<RepoHistoryItem[]> {
+  const database = await getDb();
+  const stmt = database.prepare(`
+    select
+      spec,
+      owner,
+      name,
+      branch,
+      last_used as lastUsed,
+      times_used as timesUsed
+    from repo_history
+    order by last_used desc
+    limit ?
+  `);
+
+  return stmt.all(limit) as RepoHistoryItem[];
+}
+
+export async function recordRepoHistory(repos: RepoSpec[]): Promise<void> {
+  if (repos.length === 0) return;
+
+  const database = await getDb();
+  const now = new Date().toISOString();
+  const stmt = database.prepare(`
+    insert into repo_history (spec, owner, name, branch, last_used, times_used)
+    values (?, ?, ?, ?, ?, 1)
+    on conflict(spec) do update set
+      owner = excluded.owner,
+      name = excluded.name,
+      branch = excluded.branch,
+      last_used = excluded.last_used,
+      times_used = times_used + 1
+  `);
+
+  const insertMany = database.transaction((items: RepoSpec[]) => {
+    for (const repo of items) {
+      stmt.run(repo.spec, repo.owner, repo.name, repo.branch ?? null, now);
+    }
+  });
+
+  insertMany(repos);
+}

package/src/sessions.ts

@@ -0,0 +1,217 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { mkdir, readdir, rm } from "node:fs/promises";
+import type { Session, SessionManifest, RepoSpec } from "./types";
+import { repoSpecsMatch } from "./types";
+
+const LETMECOOK_DIR = join(homedir(), ".letmecook");
+const SESSIONS_DIR = join(LETMECOOK_DIR, "sessions");
+
+export async function ensureSessionsDir(): Promise<void> {
+  await mkdir(SESSIONS_DIR, { recursive: true });
+}
+
+export async function getSessionPath(name: string): Promise<string> {
+  return join(SESSIONS_DIR, name);
+}
+
+export async function listSessions(): Promise<Session[]> {
+  await ensureSessionsDir();
+
+  const entries = await readdir(SESSIONS_DIR, { withFileTypes: true });
+  const sessions: Session[] = [];
+
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+
+    const sessionPath = join(SESSIONS_DIR, entry.name);
+    const manifestPath = join(sessionPath, "manifest.json");
+
+    try {
+      const manifestFile = Bun.file(manifestPath);
+      if (await manifestFile.exists()) {
+        const manifest: SessionManifest = await manifestFile.json();
+        sessions.push({
+          ...manifest,
+          path: sessionPath,
+        });
+      }
+    } catch {
+      // Skip invalid sessions
+    }
+  }
+
+  // Sort by lastAccessed, most recent first
+  sessions.sort((a, b) => new Date(b.lastAccessed).getTime() - new Date(a.lastAccessed).getTime());
+
+  return sessions;
+}
+
+export async function getSession(name: string): Promise<Session | null> {
+  const sessionPath = join(SESSIONS_DIR, name);
+  const manifestPath = join(sessionPath, "manifest.json");
+
+  try {
+    const manifestFile = Bun.file(manifestPath);
+    if (await manifestFile.exists()) {
+      const manifest: SessionManifest = await manifestFile.json();
+      return {
+        ...manifest,
+        path: sessionPath,
+      };
+    }
+  } catch {
+    // Session doesn't exist or is invalid
+  }
+
+  return null;
+}
+
+export async function findMatchingSession(repos: RepoSpec[]): Promise<Session | null> {
+  const sessions = await listSessions();
+
+  for (const session of sessions) {
+    if (repoSpecsMatch(session.repos, repos)) {
+      return session;
+    }
+  }
+
+  return null;
+}
+
+export async function createSession(
+  name: string,
+  repos: RepoSpec[],
+  goal?: string,
+  skills?: string[],
+): Promise<Session> {
+  await ensureSessionsDir();
+
+  const sessionPath = join(SESSIONS_DIR, name);
+  await mkdir(sessionPath, { recursive: true });
+
+  const now = new Date().toISOString();
+  const manifest: SessionManifest = {
+    name,
+    repos,
+    goal,
+    skills,
+    created: now,
+    lastAccessed: now,
+  };
+
+  const manifestPath = join(sessionPath, "manifest.json");
+  await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+
+  return {
+    ...manifest,
+    path: sessionPath,
+  };
+}
+
+export async function updateLastAccessed(name: string): Promise<void> {
+  const session = await getSession(name);
+  if (!session) return;
+
+  const manifest: SessionManifest = {
+    name: session.name,
+    repos: session.repos,
+    goal: session.goal,
+    created: session.created,
+    lastAccessed: new Date().toISOString(),
+  };
+
+  const manifestPath = join(session.path, "manifest.json");
+  await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+}
+
+export async function updateSessionRepos(name: string, repos: RepoSpec[]): Promise<Session | null> {
+  const session = await getSession(name);
+  if (!session) return null;
+
+  const manifest: SessionManifest = {
+    name: session.name,
+    repos,
+    goal: session.goal,
+    created: session.created,
+    lastAccessed: new Date().toISOString(),
+  };
+
+  const manifestPath = join(session.path, "manifest.json");
+  await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+
+  return {
+    ...manifest,
+    path: session.path,
+  };
+}
+
+export async function updateSessionSettings(
+  name: string,
+  settings: { repos?: RepoSpec[]; goal?: string; skills?: string[] },
+): Promise<Session | null> {
+  const session = await getSession(name);
+  if (!session) return null;
+
+  const manifest: SessionManifest = {
+    name: session.name,
+    repos: settings.repos ?? session.repos,
+    goal: settings.goal ?? session.goal,
+    skills: settings.skills ?? session.skills,
+    created: session.created,
+    lastAccessed: new Date().toISOString(),
+  };
+
+  const manifestPath = join(session.path, "manifest.json");
+  await Bun.write(manifestPath, JSON.stringify(manifest, null, 2));
+
+  return {
+    ...manifest,
+    path: session.path,
+  };
+}
+
+export async function updateSessionSkills(name: string, skills: string[]): Promise<Session | null> {
+  return updateSessionSettings(name, { skills });
+}
+
+export async function deleteSession(name: string): Promise<boolean> {
+  const sessionPath = join(SESSIONS_DIR, name);
+
+  try {
+    await rm(sessionPath, { recursive: true, force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function deleteAllSessions(): Promise<number> {
+  const sessions = await listSessions();
+  let deleted = 0;
+
+  for (const session of sessions) {
+    if (await deleteSession(session.name)) {
+      deleted++;
+    }
+  }
+
+  return deleted;
+}
+
+export async function sessionExists(name: string): Promise<boolean> {
+  const session = await getSession(name);
+  return session !== null;
+}
+
+export async function generateUniqueName(baseName: string): Promise<string> {
+  let name = baseName;
+  let counter = 2;
+
+  while (await sessionExists(name)) {
+    name = `${baseName}-${counter}`;
+    counter++;
+  }
+
+  return name;
+}

package/src/skills.ts

@@ -0,0 +1,49 @@
+import type { Session } from "./types";
+import { updateSessionSkills } from "./sessions";
+import { writeAgentsMd } from "./agents-md";
+import { readProcessOutput } from "./utils/stream";
+
+export async function updateSkills(
+  session: Session,
+  onProgress?: (output: string) => void,
+): Promise<{ success: boolean; output: string[] }> {
+  if (!session.skills || session.skills.length === 0) {
+    return { success: true, output: [] };
+  }
+
+  const proc = Bun.spawn(["bunx", "skills", "update", "-y"], {
+    cwd: session.path,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  return readProcessOutput(proc, onProgress);
+}
+
+export async function addSkillToSession(
+  session: Session,
+  skillString: string,
+  onProgress?: (output: string) => void,
+): Promise<{ success: boolean; output: string[] }> {
+  const proc = Bun.spawn(["bunx", "skills", "add", skillString, "-y"], {
+    cwd: session.path,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  return readProcessOutput(proc, onProgress);
+}
+
+export async function removeSkillFromSession(
+  session: Session,
+  skillString: string,
+): Promise<Session> {
+  const updatedSkills = (session.skills || []).filter((s) => s !== skillString);
+  const updatedSession = await updateSessionSkills(session.name, updatedSkills);
+
+  if (updatedSession) {
+    await writeAgentsMd(updatedSession);
+  }
+
+  return updatedSession || session;
+}