okiro 0.1.0

package/dist/index.js

@@ -0,0 +1,1408 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+
+// src/commands/spawn.ts
+import path4 from "path";
+import chalk2 from "chalk";
+import ora from "ora";
+
+// src/lib/config.ts
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".okiro");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function getProjectDir(projectName) {
+  return path.join(CONFIG_DIR, "projects", projectName);
+}
+async function ensureConfigDir() {
+  await fs.ensureDir(CONFIG_DIR);
+}
+async function getConfig() {
+  await ensureConfigDir();
+  try {
+    const content = await fs.readFile(CONFIG_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      version: "1.0.0",
+      projects: {}
+    };
+  }
+}
+async function saveConfig(config) {
+  await ensureConfigDir();
+  await fs.writeFile(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+async function addProject(projectPath, variations) {
+  const config = await getConfig();
+  const projectName = path.basename(projectPath);
+  const variationsDir = getProjectDir(projectName);
+  const projectConfig = {
+    originalPath: projectPath,
+    variationsDir,
+    variations,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  config.projects[projectPath] = projectConfig;
+  await saveConfig(config);
+  return projectConfig;
+}
+async function getProjectConfig(projectPath) {
+  const config = await getConfig();
+  return config.projects[projectPath] || null;
+}
+async function removeProject(projectPath) {
+  const config = await getConfig();
+  delete config.projects[projectPath];
+  await saveConfig(config);
+}
+function resolveProjectPath(inputPath) {
+  if (inputPath) {
+    return path.resolve(inputPath);
+  }
+  return process.cwd();
+}
+
+// src/lib/workspace.ts
+import { execa as execa2 } from "execa";
+import fs2 from "fs-extra";
+import path2 from "path";
+
+// src/lib/platform.ts
+import { execa } from "execa";
+import os2 from "os";
+var cachedPlatformInfo = null;
+async function getPlatformInfo() {
+  if (cachedPlatformInfo) {
+    return cachedPlatformInfo;
+  }
+  const nodePlatform = os2.platform();
+  let platform;
+  if (nodePlatform === "darwin") {
+    platform = "macos";
+  } else if (nodePlatform === "linux") {
+    platform = "linux";
+  } else if (nodePlatform === "win32") {
+    platform = "windows";
+  } else {
+    platform = "linux";
+  }
+  const [supportsApfsClone, supportsBtrfsReflink, hasTmux2, hasIterm2] = await Promise.all([
+    checkApfsCloneSupport(),
+    checkBtrfsReflinkSupport(),
+    checkTmuxAvailable(),
+    checkIterm2Available()
+  ]);
+  cachedPlatformInfo = {
+    platform,
+    supportsApfsClone,
+    supportsBtrfsReflink,
+    hasTmux: hasTmux2,
+    hasIterm2,
+    shell: process.env.SHELL || "/bin/bash"
+  };
+  return cachedPlatformInfo;
+}
+async function checkApfsCloneSupport() {
+  if (os2.platform() !== "darwin") {
+    return false;
+  }
+  try {
+    const { stdout } = await execa("sw_vers", ["-productVersion"]);
+    const [major, minor] = stdout.trim().split(".").map(Number);
+    return major > 10 || major === 10 && minor >= 13;
+  } catch {
+    return false;
+  }
+}
+async function checkBtrfsReflinkSupport() {
+  if (os2.platform() !== "linux") {
+    return false;
+  }
+  try {
+    await execa("cp", ["--help"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkTmuxAvailable() {
+  try {
+    await execa("which", ["tmux"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkIterm2Available() {
+  if (os2.platform() !== "darwin") {
+    return false;
+  }
+  try {
+    await execa("test", ["-d", "/Applications/iTerm.app"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/workspace.ts
+async function createWorkspace(sourcePath, destPath, options = {}) {
+  const platformInfo = await getPlatformInfo();
+  await fs2.ensureDir(path2.dirname(destPath));
+  if (platformInfo.supportsApfsClone) {
+    await createApfsClone(sourcePath, destPath);
+  } else if (platformInfo.supportsBtrfsReflink) {
+    await createReflinkCopy(sourcePath, destPath);
+  } else {
+    await createRsyncCopy(sourcePath, destPath, options);
+  }
+}
+async function createApfsClone(source, dest) {
+  await execa2("cp", ["-c", "-R", source, dest]);
+}
+async function createReflinkCopy(source, dest) {
+  await execa2("cp", ["-r", "--reflink=auto", source, dest]);
+}
+async function createRsyncCopy(source, dest, options) {
+  const excludes = [];
+  if (options.excludeGitDir) {
+    excludes.push("--exclude=.git");
+  }
+  await execa2("rsync", [
+    "-a",
+    "--delete",
+    ...excludes,
+    source + "/",
+    dest + "/"
+  ]);
+}
+async function removeAllWorkspaces(projectPath) {
+  const projectName = path2.basename(projectPath);
+  const projectDir = getProjectDir(projectName);
+  if (await fs2.pathExists(projectDir)) {
+    await fs2.remove(projectDir);
+  }
+}
+async function listChangedFiles(originalPath, variationPath) {
+  const changedFiles = [];
+  async function compareDir(relPath) {
+    const origDir = path2.join(originalPath, relPath);
+    const varDir = path2.join(variationPath, relPath);
+    const [origExists, varExists] = await Promise.all([
+      fs2.pathExists(origDir),
+      fs2.pathExists(varDir)
+    ]);
+    if (!origExists && !varExists) return;
+    const origFiles = origExists ? await fs2.readdir(origDir) : [];
+    const varFiles = varExists ? await fs2.readdir(varDir) : [];
+    const allFiles = /* @__PURE__ */ new Set([...origFiles, ...varFiles]);
+    for (const file of allFiles) {
+      if (shouldSkipFile(file)) continue;
+      const relFilePath = path2.join(relPath, file);
+      const origFilePath = path2.join(originalPath, relFilePath);
+      const varFilePath = path2.join(variationPath, relFilePath);
+      const [origStat, varStat] = await Promise.all([
+        fs2.stat(origFilePath).catch(() => null),
+        fs2.stat(varFilePath).catch(() => null)
+      ]);
+      if (origStat?.isDirectory() || varStat?.isDirectory()) {
+        await compareDir(relFilePath);
+        continue;
+      }
+      if (!origStat && varStat) {
+        changedFiles.push({ path: relFilePath, status: "A" });
+      } else if (origStat && !varStat) {
+        changedFiles.push({ path: relFilePath, status: "D" });
+      } else if (origStat && varStat) {
+        const [origContent, varContent] = await Promise.all([
+          fs2.readFile(origFilePath),
+          fs2.readFile(varFilePath)
+        ]);
+        if (!origContent.equals(varContent)) {
+          changedFiles.push({ path: relFilePath, status: "M" });
+        }
+      }
+    }
+  }
+  await compareDir("");
+  return changedFiles.sort((a, b) => a.path.localeCompare(b.path));
+}
+function shouldSkipFile(filename) {
+  const skipPatterns = [
+    "node_modules",
+    ".git",
+    ".DS_Store",
+    "dist",
+    "build",
+    ".next",
+    ".nuxt",
+    ".cache",
+    "coverage",
+    "AGENTS.md",
+    ".cursor"
+  ];
+  return skipPatterns.includes(filename);
+}
+async function getWorkspaceSize(workspacePath) {
+  try {
+    const { stdout } = await execa2("du", ["-sk", workspacePath]);
+    const sizeKb = parseInt(stdout.split("	")[0], 10);
+    return sizeKb * 1024;
+  } catch {
+    return 0;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(1))} ${units[i]}`;
+}
+
+// src/lib/terminal.ts
+import { execa as execa3 } from "execa";
+import chalk from "chalk";
+function getTerminalProgram() {
+  return process.env.TERM_PROGRAM || null;
+}
+async function hasTmux() {
+  try {
+    await execa3("which", ["tmux"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isInsideVSCodeOrCursor() {
+  const termProgram = getTerminalProgram();
+  return termProgram === "vscode" || termProgram === "cursor";
+}
+async function openTerminals(sessions, sessionName) {
+  if (isInsideVSCodeOrCursor()) {
+    printManualInstructions(sessions);
+    return;
+  }
+  const termProgram = getTerminalProgram();
+  if (termProgram === "iTerm.app") {
+    await openWithIterm(sessions);
+  } else if (await hasTmux()) {
+    await openWithTmux(sessions, sessionName);
+  } else if (termProgram === "Apple_Terminal") {
+    await openWithTerminalApp(sessions);
+  } else if (process.platform === "darwin") {
+    await openWithTerminalApp(sessions);
+  } else {
+    printManualInstructions(sessions);
+  }
+}
+async function openWithIterm(sessions) {
+  const script = `
+    tell application "iTerm"
+      activate
+      tell current window
+        ${sessions.map((session) => `
+          set newTab to (create tab with default profile)
+          tell current session of newTab
+            write text "cd '${session.path}' && clear && echo '[ ${session.id} ]'"
+          end tell
+        `).join("\n")}
+      end tell
+    end tell
+  `;
+  await execa3("osascript", ["-e", script]);
+  console.log(chalk.green(`
+\u2713 Opened ${sessions.length} iTerm tabs`));
+  console.log(chalk.dim("Cmd+Shift+] to switch tabs. Run okiro commands from any tab.\n"));
+}
+async function openWithTmux(sessions, sessionName) {
+  const existingSession = await checkTmuxSessionExists(sessionName);
+  if (existingSession) {
+    await execa3("tmux", ["kill-session", "-t", sessionName]);
+  }
+  const firstSession = sessions[0];
+  await execa3("tmux", [
+    "new-session",
+    "-d",
+    "-s",
+    sessionName,
+    "-c",
+    firstSession.path,
+    "-n",
+    firstSession.id
+  ]);
+  for (let i = 1; i < sessions.length; i++) {
+    const session = sessions[i];
+    await execa3("tmux", [
+      "new-window",
+      "-t",
+      sessionName,
+      "-c",
+      session.path,
+      "-n",
+      session.id
+    ]);
+  }
+  for (const session of sessions) {
+    await execa3("tmux", [
+      "send-keys",
+      "-t",
+      `${sessionName}:${session.id}`,
+      `clear && echo "[ ${session.id} ]"`,
+      "Enter"
+    ]);
+  }
+  await execa3("tmux", ["select-window", "-t", `${sessionName}:${sessions[0].id}`]);
+  console.log(chalk.green(`
+\u2713 Opening tmux session: ${sessionName}`));
+  console.log(chalk.dim("Ctrl+B then N/P to switch windows. Run okiro commands from any window.\n"));
+  await execa3("tmux", ["attach-session", "-t", sessionName], {
+    stdio: "inherit"
+  });
+}
+async function checkTmuxSessionExists(sessionName) {
+  try {
+    await execa3("tmux", ["has-session", "-t", sessionName]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function openWithTerminalApp(sessions) {
+  for (const session of sessions) {
+    const script = `
+      tell application "Terminal"
+        do script "cd '${session.path}' && clear && echo '[ ${session.id} ]'"
+        activate
+      end tell
+    `;
+    await execa3("osascript", ["-e", script]);
+  }
+  console.log(chalk.green(`
+\u2713 Opened ${sessions.length} Terminal windows`));
+  console.log(chalk.dim("Run okiro commands from any window.\n"));
+}
+function printManualInstructions(sessions) {
+  console.log(chalk.dim("\nOpen terminals manually:\n"));
+  for (const session of sessions) {
+    console.log(`  ${chalk.cyan(session.id)}: cd ${session.path}`);
+  }
+  console.log(chalk.dim("\nRun okiro commands from any terminal.\n"));
+}
+async function killTmuxSession(sessionName) {
+  try {
+    await execa3("tmux", ["kill-session", "-t", sessionName]);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/prompt.ts
+import readline from "readline";
+import fs3 from "fs-extra";
+import path3 from "path";
+async function promptForInput(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function promptForVariationDirections(count, basePrompt) {
+  const directions = [];
+  console.log("");
+  if (basePrompt) {
+    console.log(`Base task: ${basePrompt}
+`);
+  }
+  console.log("Enter a direction/style for each variation (or press Enter to skip):\n");
+  for (let i = 1; i <= count; i++) {
+    const direction = await promptForInput(`  var-${i}: `);
+    directions.push(direction);
+  }
+  return directions;
+}
+async function writeAIConfigFiles(variationPath, variationId, direction, basePrompt) {
+  if (!direction && !basePrompt) return;
+  const configContent = buildAIConfigContent(variationId, direction, basePrompt);
+  await fs3.writeFile(
+    path3.join(variationPath, "AGENTS.md"),
+    configContent
+  );
+  const cursorDir = path3.join(variationPath, ".cursor");
+  await fs3.ensureDir(cursorDir);
+  await fs3.writeFile(
+    path3.join(cursorDir, "rules"),
+    configContent
+  );
+}
+function buildAIConfigContent(variationId, direction, basePrompt) {
+  const lines = [
+    `# Okiro Variation: ${variationId}`,
+    "",
+    "You are working on an isolated variation of this project.",
+    "Your changes will be compared against other variations.",
+    ""
+  ];
+  if (basePrompt) {
+    lines.push("## Task");
+    lines.push("");
+    lines.push(basePrompt);
+    lines.push("");
+  }
+  if (direction) {
+    lines.push("## Direction for this variation");
+    lines.push("");
+    lines.push(direction);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/commands/spawn.ts
+async function spawn(count, options) {
+  const projectPath = resolveProjectPath();
+  const projectName = path4.basename(projectPath);
+  const existingProject = await getProjectConfig(projectPath);
+  if (existingProject && !options.force) {
+    console.log(
+      chalk2.yellow(
+        `
+Project already has ${existingProject.variations.length} active variations.`
+      )
+    );
+    console.log("Run with --force to replace them, or run `okiro cleanup` first.\n");
+    return;
+  }
+  if (existingProject) {
+    const cleanupSpinner = ora("Cleaning up existing variations...").start();
+    await removeAllWorkspaces(projectPath);
+    cleanupSpinner.succeed("Cleaned up existing variations");
+  }
+  const variationsDir = getProjectDir(projectName);
+  const variations = [];
+  const sessions = [];
+  let directions = [];
+  if (options.prompt) {
+    const basePrompt = typeof options.prompt === "string" ? options.prompt : void 0;
+    directions = await promptForVariationDirections(count, basePrompt);
+  }
+  console.log(chalk2.bold(`
+Creating ${count} variations for ${projectName}
+`));
+  for (let i = 1; i <= count; i++) {
+    const varId = `var-${i}`;
+    const varPath = path4.join(variationsDir, varId);
+    const spinner = ora(`Creating ${varId}...`).start();
+    try {
+      await createWorkspace(projectPath, varPath);
+      const direction = directions[i - 1] || "";
+      const basePrompt = typeof options.prompt === "string" ? options.prompt : void 0;
+      if (direction || basePrompt) {
+        await writeAIConfigFiles(varPath, varId, direction, basePrompt);
+      }
+      spinner.succeed(`Created ${varId} at ${chalk2.dim(varPath)}`);
+      variations.push({
+        id: varId,
+        path: varPath,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      sessions.push({
+        id: varId,
+        path: varPath
+      });
+    } catch (error) {
+      spinner.fail(`Failed to create ${varId}`);
+      throw error;
+    }
+  }
+  await addProject(projectPath, variations);
+  console.log(chalk2.green(`
+\u2713 Created ${count} variations
+`));
+  if (!options.noTerminal) {
+    await openTerminals(sessions, `okiro-${projectName}`);
+  }
+}
+
+// src/commands/status.ts
+import path5 from "path";
+import chalk3 from "chalk";
+async function status() {
+  const projectPath = resolveProjectPath();
+  const projectName = path5.basename(projectPath);
+  const project = await getProjectConfig(projectPath);
+  if (!project) {
+    console.log(chalk3.yellow("\nNo active variations for this project."));
+    console.log("Run `okiro 3` to create variations.\n");
+    return;
+  }
+  console.log(chalk3.bold(`
+Variations for ${projectName}:
+`));
+  for (const variation of project.variations) {
+    const changedFiles = await listChangedFiles(projectPath, variation.path);
+    const diskUsage = await getWorkspaceSize(variation.path);
+    console.log(`  ${chalk3.cyan(variation.id)}`);
+    console.log(`    Path: ${chalk3.dim(variation.path)}`);
+    console.log(`    Changed: ${changedFiles.length} files`);
+    console.log(`    Size: ${formatBytes(diskUsage)}`);
+    console.log("");
+  }
+}
+
+// src/commands/cleanup.ts
+import path6 from "path";
+import chalk4 from "chalk";
+import ora2 from "ora";
+import readline2 from "readline";
+async function confirm(message) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+async function cleanup(options) {
+  const projectPath = resolveProjectPath();
+  const projectName = path6.basename(projectPath);
+  const project = await getProjectConfig(projectPath);
+  if (!project) {
+    console.log(chalk4.yellow("\nNo active variations to clean up.\n"));
+    return;
+  }
+  let totalSize = 0;
+  for (const variation of project.variations) {
+    totalSize += await getWorkspaceSize(variation.path);
+  }
+  console.log(
+    `
+This will remove ${project.variations.length} variations (${formatBytes(totalSize)})`
+  );
+  if (!options.force) {
+    const confirmed = await confirm("Continue? [y/N] ");
+    if (!confirmed) {
+      console.log("Aborted.\n");
+      return;
+    }
+  }
+  const sessionName = `okiro-${projectName}`;
+  const killedSession = await killTmuxSession(sessionName);
+  if (killedSession) {
+    console.log(chalk4.dim(`Killed tmux session: ${sessionName}`));
+  }
+  const spinner = ora2("Removing variations...").start();
+  try {
+    await removeAllWorkspaces(projectPath);
+    await removeProject(projectPath);
+    spinner.succeed(
+      `Removed ${project.variations.length} variations (freed ${formatBytes(totalSize)})`
+    );
+  } catch (error) {
+    spinner.fail("Failed to clean up variations");
+    throw error;
+  }
+  console.log("");
+}
+
+// src/commands/diff.ts
+import chalk5 from "chalk";
+
+// src/lib/diff.ts
+import { createTwoFilesPatch } from "diff";
+import fs4 from "fs-extra";
+import path7 from "path";
+async function generateFileDiff(originalPath, variationPath, relativeFilePath) {
+  const origFile = path7.join(originalPath, relativeFilePath);
+  const varFile = path7.join(variationPath, relativeFilePath);
+  const [origContent, varContent] = await Promise.all([
+    fs4.readFile(origFile, "utf-8").catch(() => ""),
+    fs4.readFile(varFile, "utf-8").catch(() => "")
+  ]);
+  let status2;
+  if (!origContent && varContent) {
+    status2 = "A";
+  } else if (origContent && !varContent) {
+    status2 = "D";
+  } else {
+    status2 = "M";
+  }
+  const patch = createTwoFilesPatch(
+    `a/${relativeFilePath}`,
+    `b/${relativeFilePath}`,
+    origContent,
+    varContent,
+    "",
+    ""
+  );
+  return {
+    filePath: relativeFilePath,
+    status: status2,
+    original: origContent,
+    modified: varContent,
+    patch
+  };
+}
+function colorizeUnifiedDiff(patch) {
+  const lines = patch.split("\n");
+  const coloredLines = lines.map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---")) {
+      return `\x1B[1m${line}\x1B[0m`;
+    }
+    if (line.startsWith("+")) {
+      return `\x1B[32m${line}\x1B[0m`;
+    }
+    if (line.startsWith("-")) {
+      return `\x1B[31m${line}\x1B[0m`;
+    }
+    if (line.startsWith("@@")) {
+      return `\x1B[36m${line}\x1B[0m`;
+    }
+    return line;
+  });
+  return coloredLines.join("\n");
+}
+
+// src/commands/diff.ts
+async function diff(var1, var2) {
+  const projectPath = resolveProjectPath();
+  const project = await getProjectConfig(projectPath);
+  if (!project) {
+    console.log(chalk5.yellow("\nNo active variations for this project."));
+    console.log("Run `okiro spawn <count>` to create variations.\n");
+    return;
+  }
+  let sourcePath;
+  let targetPath;
+  let sourceLabel;
+  let targetLabel;
+  if (!var1 && !var2) {
+    sourcePath = projectPath;
+    sourceLabel = "original";
+    targetPath = project.variations[0].path;
+    targetLabel = project.variations[0].id;
+  } else if (var1 && !var2) {
+    sourcePath = projectPath;
+    sourceLabel = "original";
+    const variation = project.variations.find((v) => v.id === var1);
+    if (!variation) {
+      console.log(chalk5.red(`
+Variation "${var1}" not found.`));
+      console.log("Available:", project.variations.map((v) => v.id).join(", "));
+      return;
+    }
+    targetPath = variation.path;
+    targetLabel = variation.id;
+  } else {
+    if (var1 === "original") {
+      sourcePath = projectPath;
+      sourceLabel = "original";
+    } else {
+      const sourceVar = project.variations.find((v) => v.id === var1);
+      if (!sourceVar) {
+        console.log(chalk5.red(`
+Variation "${var1}" not found.`));
+        return;
+      }
+      sourcePath = sourceVar.path;
+      sourceLabel = sourceVar.id;
+    }
+    if (var2 === "original") {
+      targetPath = projectPath;
+      targetLabel = "original";
+    } else {
+      const targetVar = project.variations.find((v) => v.id === var2);
+      if (!targetVar) {
+        console.log(chalk5.red(`
+Variation "${var2}" not found.`));
+        return;
+      }
+      targetPath = targetVar.path;
+      targetLabel = targetVar.id;
+    }
+  }
+  console.log(chalk5.bold(`
+Comparing ${sourceLabel} \u2192 ${targetLabel}
+`));
+  const changedFiles = await listChangedFiles(sourcePath, targetPath);
+  if (changedFiles.length === 0) {
+    console.log(chalk5.dim("No changes detected.\n"));
+    return;
+  }
+  console.log(chalk5.dim(`${changedFiles.length} file(s) changed:
+`));
+  for (const file of changedFiles) {
+    const fileDiff = await generateFileDiff(sourcePath, targetPath, file.path);
+    console.log(colorizeUnifiedDiff(fileDiff.patch));
+    console.log("");
+  }
+}
+
+// src/commands/promote.ts
+import path8 from "path";
+import chalk6 from "chalk";
+import ora3 from "ora";
+import readline3 from "readline";
+import fs5 from "fs-extra";
+import { execa as execa4 } from "execa";
+async function confirm2(message) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+async function promote(variationId, options) {
+  const projectPath = resolveProjectPath();
+  const projectName = path8.basename(projectPath);
+  const project = await getProjectConfig(projectPath);
+  if (!project) {
+    console.log(chalk6.yellow("\nNo active variations for this project.\n"));
+    return;
+  }
+  const variation = project.variations.find((v) => v.id === variationId);
+  if (!variation) {
+    console.log(chalk6.red(`
+Variation "${variationId}" not found.`));
+    console.log("Available:", project.variations.map((v) => v.id).join(", "));
+    return;
+  }
+  const changedFiles = await listChangedFiles(projectPath, variation.path);
+  if (changedFiles.length === 0) {
+    console.log(chalk6.yellow("\nNo changes to promote.\n"));
+    return;
+  }
+  console.log(chalk6.bold(`
+Promoting ${variationId} to ${projectName}
+`));
+  console.log("Changed files:");
+  for (const file of changedFiles) {
+    const icon = file.status === "M" ? "~" : file.status === "A" ? "+" : "-";
+    const color = file.status === "A" ? chalk6.green : file.status === "D" ? chalk6.red : chalk6.yellow;
+    console.log(color(`  ${icon} ${file.path}`));
+  }
+  console.log("");
+  if (!options.force) {
+    const confirmed = await confirm2("Apply these changes? [y/N] ");
+    if (!confirmed) {
+      console.log("Aborted.\n");
+      return;
+    }
+  }
+  const spinner = ora3("Applying changes...").start();
+  try {
+    for (const file of changedFiles) {
+      const srcPath = path8.join(variation.path, file.path);
+      const destPath = path8.join(projectPath, file.path);
+      if (file.status === "D") {
+        await fs5.remove(destPath);
+      } else {
+        await fs5.ensureDir(path8.dirname(destPath));
+        await fs5.copy(srcPath, destPath);
+      }
+    }
+    spinner.succeed(`Promoted ${changedFiles.length} files from ${variationId}`);
+    if (options.commit) {
+      const commitSpinner = ora3("Committing changes...").start();
+      try {
+        await execa4("git", ["add", ...changedFiles.map((f) => f.path)], {
+          cwd: projectPath
+        });
+        const defaultMessage = `feat: promote ${variationId} from okiro`;
+        const commitMessage = typeof options.commit === "string" ? options.commit : defaultMessage;
+        await execa4("git", ["commit", "-m", commitMessage], {
+          cwd: projectPath
+        });
+        commitSpinner.succeed(`Committed: "${commitMessage}"`);
+      } catch (error) {
+        commitSpinner.fail("Failed to commit (is this a git repository?)");
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to promote changes");
+    throw error;
+  }
+  console.log("");
+}
+
+// src/commands/compare.ts
+import path9 from "path";
+import chalk7 from "chalk";
+import express from "express";
+import open from "open";
+async function compare(options) {
+  const projectPath = resolveProjectPath();
+  const project = await getProjectConfig(projectPath);
+  if (!project) {
+    console.log(chalk7.yellow("\nNo active variations for this project."));
+    console.log("Run `okiro 3` to create variations.\n");
+    return;
+  }
+  const app = express();
+  const port = options.port ?? 6789;
+  app.use(express.json());
+  app.use((_req, res, next) => {
+    res.header("Access-Control-Allow-Origin", "*");
+    res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
+    next();
+  });
+  app.get("/api/project", (_req, res) => {
+    res.json({
+      name: path9.basename(projectPath),
+      originalPath: projectPath,
+      variations: project.variations.map((v) => ({
+        id: v.id,
+        createdAt: v.createdAt
+      }))
+    });
+  });
+  app.get("/api/all-files", async (_req, res) => {
+    const fileMap = /* @__PURE__ */ new Map();
+    for (const variation of project.variations) {
+      const files = await listChangedFiles(projectPath, variation.path);
+      for (const file of files) {
+        const existing = fileMap.get(file.path);
+        if (existing) {
+          existing.variations.push(variation.id);
+          if (file.status === "A" && existing.status !== "A") {
+            existing.status = file.status;
+          }
+        } else {
+          fileMap.set(file.path, {
+            ...file,
+            variations: [variation.id]
+          });
+        }
+      }
+    }
+    const allFiles = Array.from(fileMap.values()).sort(
+      (a, b) => a.path.localeCompare(b.path)
+    );
+    res.json(allFiles);
+  });
+  app.get("/api/files/:variation", async (req, res) => {
+    const variationId = req.params.variation;
+    if (variationId === "original") {
+      res.json([]);
+      return;
+    }
+    const variation = project.variations.find((v) => v.id === variationId);
+    if (!variation) {
+      res.status(404).json({ error: "Variation not found" });
+      return;
+    }
+    const files = await listChangedFiles(projectPath, variation.path);
+    res.json(files);
+  });
+  app.get("/api/diff/:variation", async (req, res) => {
+    const variation = req.params.variation;
+    const file = req.query.file;
+    if (!file) {
+      res.status(400).json({ error: "Missing file query param" });
+      return;
+    }
+    const varConfig = project.variations.find((v) => v.id === variation);
+    if (!varConfig) {
+      res.status(404).json({ error: "Variation not found" });
+      return;
+    }
+    const diff2 = await generateFileDiff(projectPath, varConfig.path, file);
+    res.json(diff2);
+  });
+  app.get("/", (_req, res) => {
+    res.send(getCompareHtml(project.variations.map((v) => v.id)));
+  });
+  app.listen(port, () => {
+    console.log(chalk7.green(`
+\u2713 Diff viewer at http://localhost:${port}
+`));
+    if (!options.noBrowser) {
+      open(`http://localhost:${port}`);
+    }
+  });
+}
+function getCompareHtml(variations) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>okiro</title>
+  <link rel="preconnect" href="https://cdn.jsdelivr.net">
+  <link href="https://cdn.jsdelivr.net/npm/iosevka@31.1.0/iosevka.min.css" rel="stylesheet">
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    
+    :root {
+      --rp-base: #191724;
+      --rp-surface: #1f1d2e;
+      --rp-overlay: #26233a;
+      --rp-muted: #6e6a86;
+      --rp-subtle: #908caa;
+      --rp-text: #e0def4;
+      --rp-love: #eb6f92;
+      --rp-gold: #f6c177;
+      --rp-rose: #ebbcba;
+      --rp-pine: #31748f;
+      --rp-foam: #9ccfd8;
+      --rp-iris: #c4a7e7;
+      --rp-highlight-low: #21202e;
+      --rp-highlight-med: #403d52;
+      --rp-highlight-high: #524f67;
+    }
+    
+    body {
+      font-family: 'Iosevka Web', 'Iosevka', monospace;
+      background: var(--rp-base);
+      color: var(--rp-text);
+      min-height: 100vh;
+      font-size: 13px;
+    }
+    
+    header {
+      padding: 12px 20px;
+      border-bottom: 1px solid var(--rp-overlay);
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      background: var(--rp-surface);
+      position: sticky;
+      top: 0;
+      z-index: 100;
+    }
+    
+    .header-left {
+      display: flex;
+      align-items: center;
+      gap: 24px;
+    }
+    
+    h1 { 
+      font-size: 13px; 
+      font-weight: 600;
+      color: var(--rp-iris);
+      letter-spacing: 1px;
+    }
+    
+    .view-toggle {
+      display: flex;
+      gap: 2px;
+      background: var(--rp-base);
+      padding: 2px;
+      border-radius: 4px;
+    }
+    
+    .view-toggle button {
+      padding: 4px 10px;
+      background: transparent;
+      border: none;
+      color: var(--rp-muted);
+      font-family: inherit;
+      font-size: 11px;
+      cursor: pointer;
+      border-radius: 3px;
+      transition: all 0.15s;
+    }
+    
+    .view-toggle button:hover {
+      color: var(--rp-subtle);
+    }
+    
+    .view-toggle button.active {
+      background: var(--rp-overlay);
+      color: var(--rp-text);
+    }
+    
+    .variation-tabs {
+      display: flex;
+      gap: 4px;
+    }
+    
+    .variation-tab {
+      padding: 5px 12px;
+      background: var(--rp-base);
+      border: 1px solid var(--rp-overlay);
+      border-radius: 4px;
+      color: var(--rp-muted);
+      font-family: inherit;
+      font-size: 11px;
+      cursor: pointer;
+      transition: all 0.15s;
+    }
+    
+    .variation-tab:hover {
+      border-color: var(--rp-highlight-med);
+      color: var(--rp-subtle);
+    }
+    
+    .variation-tab.active {
+      background: var(--rp-overlay);
+      color: var(--rp-text);
+      border-color: var(--rp-highlight-high);
+    }
+    
+    .variation-tab.hidden {
+      display: none;
+    }
+    
+    main { 
+      display: flex; 
+      height: calc(100vh - 49px); 
+    }
+    
+    .sidebar {
+      width: 280px;
+      min-width: 280px;
+      border-right: 1px solid var(--rp-overlay);
+      overflow-y: auto;
+      background: var(--rp-base);
+    }
+    
+    .sidebar-header {
+      padding: 10px 14px;
+      font-size: 10px;
+      text-transform: uppercase;
+      letter-spacing: 1.5px;
+      color: var(--rp-muted);
+      border-bottom: 1px solid var(--rp-overlay);
+      position: sticky;
+      top: 0;
+      background: var(--rp-base);
+    }
+    
+    .file-list { 
+      list-style: none; 
+    }
+    
+    .file-item {
+      padding: 8px 14px;
+      cursor: pointer;
+      border-bottom: 1px solid var(--rp-highlight-low);
+      transition: background 0.1s;
+    }
+    
+    .file-item:hover { 
+      background: var(--rp-surface); 
+    }
+    
+    .file-item.selected { 
+      background: var(--rp-overlay);
+    }
+    
+    .file-item-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+    
+    .status { 
+      font-weight: 600; 
+      font-size: 11px;
+      width: 14px;
+      text-align: center;
+    }
+    
+    .status.M { color: var(--rp-gold); }
+    .status.A { color: var(--rp-foam); }
+    .status.D { color: var(--rp-love); }
+    
+    .file-path {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      color: var(--rp-text);
+      font-size: 12px;
+    }
+    
+    .file-variations {
+      margin-top: 3px;
+      margin-left: 22px;
+      font-size: 10px;
+      color: var(--rp-muted);
+    }
+    
+    .file-variations span {
+      margin-right: 6px;
+    }
+    
+    .diff-view {
+      flex: 1;
+      overflow: auto;
+      background: var(--rp-base);
+    }
+    
+    .diff-wrapper {
+      min-height: 100%;
+    }
+    
+    .empty-state {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      height: 100%;
+      color: var(--rp-muted);
+      font-size: 12px;
+    }
+
+    #diffContainer {
+      height: 100%;
+    }
+
+    ::-webkit-scrollbar {
+      width: 8px;
+      height: 8px;
+    }
+    
+    ::-webkit-scrollbar-track {
+      background: var(--rp-base);
+    }
+    
+    ::-webkit-scrollbar-thumb {
+      background: var(--rp-overlay);
+      border-radius: 4px;
+    }
+    
+    ::-webkit-scrollbar-thumb:hover {
+      background: var(--rp-highlight-med);
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div class="header-left">
+      <h1>OKIRO</h1>
+      <div class="view-toggle">
+        <button id="splitBtn" class="active">Split</button>
+        <button id="unifiedBtn">Unified</button>
+      </div>
+    </div>
+    <div class="variation-tabs" id="variationTabs"></div>
+  </header>
+  <main>
+    <aside class="sidebar">
+      <div class="sidebar-header">Changed Files</div>
+      <ul class="file-list" id="fileList"></ul>
+    </aside>
+    <section class="diff-view" id="diffView">
+      <div class="empty-state">Select a file to view diff</div>
+    </section>
+  </main>
+  <script type="module">
+    import { FileDiff } from 'https://esm.sh/@pierre/diffs@1.0.5';
+
+    const variations = ${JSON.stringify(variations)};
+    const fileList = document.getElementById('fileList');
+    const diffView = document.getElementById('diffView');
+    const variationTabs = document.getElementById('variationTabs');
+    const splitBtn = document.getElementById('splitBtn');
+    const unifiedBtn = document.getElementById('unifiedBtn');
+
+    let selectedFile = null;
+    let selectedVariation = variations[0];
+    let allFiles = [];
+    let diffStyle = 'split';
+    let diffInstance = null;
+
+    splitBtn.addEventListener('click', () => {
+      diffStyle = 'split';
+      splitBtn.classList.add('active');
+      unifiedBtn.classList.remove('active');
+      if (diffInstance) {
+        diffInstance.setOptions({ diffStyle: 'split' });
+        diffInstance.rerender();
+      }
+    });
+
+    unifiedBtn.addEventListener('click', () => {
+      diffStyle = 'unified';
+      unifiedBtn.classList.add('active');
+      splitBtn.classList.remove('active');
+      if (diffInstance) {
+        diffInstance.setOptions({ diffStyle: 'unified' });
+        diffInstance.rerender();
+      }
+    });
+
+    async function loadAllFiles() {
+      const response = await fetch('/api/all-files');
+      allFiles = await response.json();
+      renderFileList();
+    }
+
+    function renderFileList() {
+      fileList.innerHTML = allFiles.map(f => \`
+        <li class="file-item" data-path="\${f.path}">
+          <div class="file-item-header">
+            <span class="status \${f.status}">\${f.status}</span>
+            <span class="file-path">\${f.path}</span>
+          </div>
+          <div class="file-variations">
+            \${f.variations.map(v => \`<span>\${v}</span>\`).join('')}
+          </div>
+        </li>
+      \`).join('');
+
+      document.querySelectorAll('.file-item').forEach(item => {
+        item.addEventListener('click', () => selectFile(item.dataset.path));
+      });
+
+      if (allFiles.length > 0 && !selectedFile) {
+        selectFile(allFiles[0].path);
+      }
+    }
+
+    function selectFile(filePath) {
+      selectedFile = filePath;
+
+      document.querySelectorAll('.file-item').forEach(item => {
+        item.classList.toggle('selected', item.dataset.path === filePath);
+      });
+
+      const fileData = allFiles.find(f => f.path === filePath);
+      
+      renderVariationTabs(fileData?.variations || []);
+      
+      if (fileData && !fileData.variations.includes(selectedVariation)) {
+        selectedVariation = fileData.variations[0];
+      }
+      updateVariationTabs();
+
+      loadDiff();
+    }
+
+    function renderVariationTabs(fileVariations) {
+      variationTabs.innerHTML = fileVariations.map(v => 
+        \`<button class="variation-tab" data-var="\${v}">\${v}</button>\`
+      ).join('');
+      
+      variationTabs.querySelectorAll('.variation-tab').forEach(tab => {
+        tab.addEventListener('click', () => selectVariation(tab.dataset.var));
+      });
+    }
+
+    function selectVariation(varId) {
+      selectedVariation = varId;
+      updateVariationTabs();
+      if (selectedFile) {
+        loadDiff();
+      }
+    }
+
+    function updateVariationTabs() {
+      document.querySelectorAll('.variation-tab').forEach(tab => {
+        tab.classList.toggle('active', tab.dataset.var === selectedVariation);
+      });
+    }
+
+    async function loadDiff() {
+      if (!selectedFile || !selectedVariation) return;
+
+      const fileData = allFiles.find(f => f.path === selectedFile);
+      if (!fileData || !fileData.variations.includes(selectedVariation)) {
+        diffView.innerHTML = '<div class="empty-state">No changes in ' + selectedVariation + '</div>';
+        return;
+      }
+
+      diffView.innerHTML = '<div class="empty-state">Loading...</div>';
+
+      const response = await fetch(\`/api/diff/\${selectedVariation}?file=\${encodeURIComponent(selectedFile)}\`);
+      const diff = await response.json();
+
+      renderDiff(diff);
+    }
+
+    function renderDiff(diff) {
+      diffView.innerHTML = '<div id="diffContainer"></div>';
+      
+      if (diffInstance) {
+        diffInstance.cleanUp();
+      }
+
+      diffInstance = new FileDiff({
+        theme: 'rose-pine',
+        themeType: 'dark',
+        diffStyle: diffStyle,
+        diffIndicators: 'classic',
+        overflow: 'scroll',
+      });
+
+      diffInstance.render({
+        oldFile: { name: diff.filePath, contents: diff.original },
+        newFile: { name: diff.filePath, contents: diff.modified },
+        containerWrapper: document.getElementById('diffContainer'),
+      });
+    }
+
+    loadAllFiles();
+  </script>
+</body>
+</html>`;
+}
+
+// src/index.ts
+var firstArg = process.argv[2];
+if (firstArg && /^\d+$/.test(firstArg)) {
+  process.argv.splice(2, 0, "spawn");
+} else if (!firstArg) {
+  process.argv.push("--help");
+}
+program.name("okiro").description("Ephemeral code variation previews for AI-assisted development").version("0.1.0");
+program.command("spawn <count>").description("Create variation workspaces").option("-f, --force", "Replace existing variations").option("--no-terminal", "Do not open terminal sessions").option("--prompt [task]", "Prompt for direction per variation").action(async (count, options) => {
+  await spawn(parseInt(count, 10), {
+    force: options.force,
+    noTerminal: !options.terminal,
+    prompt: options.prompt
+  });
+});
+program.command("status").description("Show active variations").action(async () => {
+  await status();
+});
+program.command("diff [var1] [var2]").description("Show diff between variations").action(async (var1, var2) => {
+  await diff(var1, var2);
+});
+program.command("promote <variation>").description("Apply variation changes to original codebase").option("-f, --force", "Skip confirmation").option("-c, --commit [message]", "Git commit after promoting").action(async (variation, options) => {
+  await promote(variation, {
+    force: options.force,
+    commit: options.commit
+  });
+});
+program.command("compare").description("Open diff viewer UI in browser").option("-p, --port <port>", "Port for diff viewer", "6789").option("--no-browser", "Do not open browser automatically").action(async (options) => {
+  await compare({
+    port: parseInt(options.port, 10),
+    noBrowser: !options.browser
+  });
+});
+program.command("cleanup").description("Remove all variation workspaces").option("-f, --force", "Skip confirmation").action(async (options) => {
+  await cleanup({ force: options.force });
+});
+program.addHelpText("after", `
+Examples:
+  $ okiro 3                    Create 3 variations
+  $ okiro 3 --prompt           Create 3 with AI directions
+  $ okiro status               Show variation status  
+  $ okiro diff var-1           Diff original vs var-1
+  $ okiro compare              Open diff viewer
+  $ okiro promote var-2        Apply var-2 to codebase
+  $ okiro cleanup              Remove all variations
+`);
+program.parse();