@creativeintelligence/abbie 0.1.4 → 0.1.6

package/src/lib/auto/spawn.ts

@@ -1,549 +0,0 @@
-import { execSync, spawn, spawnSync } from "node:child_process";
-import { createReadStream, existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { AgentType } from "../active-sessions.js";
-import { getContractTemplate } from "../contracts.js";
-import { getPublicUrl } from "../ngrok.js";
-import type { ResourceLease, ResourceManager } from "../resources.js";
-import type { WorkItem } from "./discover.js";
-
-export type Effort = "quick" | "thorough";
-
-export interface SpawnRequest {
-  work: WorkItem;
-  effort: Effort;
-  agent: AgentType;
-  reason: string;
-}
-
-export interface SpawnResult {
-  request: SpawnRequest;
-  status: "planned" | "spawned" | "blocked" | "failed";
-  message?: string;
-  command?: string;
-  resource?: string;
-  lease?: ResourceLease;
-  promptPath?: string;
-  outputPath?: string;
-  pid?: number;
-  // Preview funnel fields
-  preview?: {
-    worktree?: string;
-    port?: number;
-    tunnelUrl?: string;
-    devServerPid?: number;
-  };
-}
-
-export interface SpawnOptions {
-  dryRun: boolean;
-  cwd: string;
-  project: string;
-  sessionId: string;
-  resources: ResourceManager;
-  max?: number;
-  commands?: {
-    codex?: string;
-  };
-  queueDir?: string;
-  // Preview funnel options
-  preview?: {
-    enabled: boolean;
-    basePort?: number; // Starting port for dev servers (default: 3100)
-    devCommand?: string; // Command to start dev server (default: pnpm dev)
-  };
-}
-
-const QUICK_KEYWORDS = [
-  "typo",
-  "docs",
-  "readme",
-  "format",
-  "lint",
-  "cleanup",
-  "copy",
-  "minor",
-  "small",
-];
-
-const THOROUGH_KEYWORDS = [
-  "refactor",
-  "migration",
-  "architecture",
-  "performance",
-  "security",
-  "coverage",
-  "tests",
-  "incident",
-  "infra",
-  "stability",
-];
-
-export function decideAgent(work: WorkItem): SpawnRequest {
-  const effort = work.effort || inferEffort(work);
-  const agent: AgentType = effort === "thorough" ? "codex" : "copilot";
-  const reason = effort === "thorough" ? "high effort signal" : "quick effort signal";
-
-  return {
-    work,
-    effort,
-    agent,
-    reason,
-  };
-}
-
-export async function spawnWorkItems(
-  items: WorkItem[],
-  options: SpawnOptions,
-): Promise<SpawnResult[]> {
-  const limit = options.max && options.max > 0 ? options.max : items.length;
-  const selected = items.slice(0, limit);
-  const results: SpawnResult[] = [];
-
-  for (const work of selected) {
-    const request = decideAgent(work);
-    const result = await spawnWorkItem(request, options);
-    results.push(result);
-  }
-
-  return results;
-}
-
-/**
- * Spawn a single agent for a work item.
- */
-export async function spawnAgent(item: WorkItem, options: SpawnOptions): Promise<SpawnResult> {
-  const results = await spawnWorkItems([item], options);
-  return results[0];
-}
-
-async function spawnWorkItem(request: SpawnRequest, options: SpawnOptions): Promise<SpawnResult> {
-  const resource = request.agent === "codex" ? "codex_api" : "cursor_agent";
-  const command = resolveAgentCommand(request.agent, options.commands);
-
-  if (options.dryRun) {
-    const availability = options.resources.getAvailability(resource);
-    if (availability.available === 0) {
-      return {
-        request,
-        status: "blocked",
-        message: `resource at capacity (dry-run): ${resource}`,
-        command,
-        resource,
-      };
-    }
-
-    return {
-      request,
-      status: "planned",
-      message: `ready to spawn ${request.agent}`,
-      command,
-      resource,
-    };
-  }
-
-  if (!command || !isCommandAvailable(command)) {
-    const queuedPath = enqueueSpawn(request, options);
-    return {
-      request,
-      status: "planned",
-      message: queuedPath ? `queued at ${queuedPath}` : "command not available",
-      command: command || undefined,
-      resource,
-    };
-  }
-
-  const lease = options.resources.acquire(resource, options.sessionId, "auto");
-  if (!lease) {
-    return {
-      request,
-      status: "blocked",
-      message: `resource at capacity: ${resource}`,
-      command,
-      resource,
-    };
-  }
-
-  // Setup preview environment if enabled (worktree + dev server + tunnel)
-  let preview: SpawnResult["preview"];
-  let workingDir = options.cwd;
-
-  if (options.preview?.enabled) {
-    preview = await setupPreviewEnvironment(request, options);
-    if (preview?.worktree) {
-      workingDir = preview.worktree;
-    }
-  }
-
-  const env = {
-    ...process.env,
-    AUTO_SESSION_ID: options.sessionId,
-    AUTO_PROJECT: options.project,
-    AUTO_WORK_ID: request.work.id,
-    AUTO_WORK_SOURCE: request.work.source,
-    AUTO_WORK_TITLE: request.work.title,
-  } as Record<string, string>;
-
-  if (request.work.issue) env.AUTO_WORK_ISSUE = request.work.issue;
-  if (request.work.url) env.AUTO_WORK_URL = request.work.url;
-  if (request.work.details) env.AUTO_WORK_DETAILS = request.work.details;
-
-  // Add preview environment variables if available
-  if (preview) {
-    if (preview.worktree) env.AUTO_PREVIEW_WORKTREE = preview.worktree;
-    if (preview.port) env.AUTO_PREVIEW_PORT = preview.port.toString();
-    if (preview.tunnelUrl) env.AUTO_PREVIEW_URL = preview.tunnelUrl;
-  }
-
-  // Build prompt and write to temp file
-  const timestamp = Date.now();
-  const safeWorkId = request.work.id.replace(/[^a-z0-9-_]+/gi, "-");
-  const promptDir = join(homedir(), ".abbie", "auto", "prompts");
-  mkdirSync(promptDir, { recursive: true });
-
-  const promptPath = join(promptDir, `${safeWorkId}-${timestamp}.md`);
-  const outputPath = join(promptDir, `${safeWorkId}-${timestamp}-response.json`);
-  const prompt = buildAgentPrompt(request, options, preview);
-
-  writeFileSync(promptPath, prompt);
-
-  try {
-    const args = getAgentArgs(request.agent, outputPath);
-    const child = spawn(command, args, {
-      cwd: workingDir,
-      env,
-      stdio: ["pipe", "ignore", "ignore"],
-      detached: true,
-    });
-
-    // Pipe prompt to stdin
-    const promptStream = createReadStream(promptPath);
-    promptStream.pipe(child.stdin!);
-
-    child.unref();
-
-    const previewMsg = preview?.tunnelUrl ? ` | preview: ${preview.tunnelUrl}` : "";
-    return {
-      request,
-      status: "spawned",
-      message: `spawned ${request.agent} (pid ${child.pid})${previewMsg}`,
-      command,
-      resource,
-      lease,
-      promptPath,
-      outputPath,
-      pid: child.pid,
-      preview,
-    };
-  } catch (err) {
-    // Cleanup preview environment on failure
-    if (preview?.worktree) {
-      removeWorktree(preview.worktree);
-    }
-    if (preview?.devServerPid) {
-      try {
-        process.kill(preview.devServerPid);
-      } catch {
-        // Ignore if already dead
-      }
-    }
-    options.resources.release(resource, options.sessionId);
-    return {
-      request,
-      status: "failed",
-      message: (err as Error).message,
-      command,
-      resource,
-    };
-  }
-}
-
-function inferEffort(work: WorkItem): Effort {
-  const haystack = `${work.title} ${work.details || ""}`.toLowerCase();
-  for (const keyword of THOROUGH_KEYWORDS) {
-    if (haystack.includes(keyword)) {
-      return "thorough";
-    }
-  }
-  for (const keyword of QUICK_KEYWORDS) {
-    if (haystack.includes(keyword)) {
-      return "quick";
-    }
-  }
-
-  return work.source === "linear" ? "thorough" : "quick";
-}
-
-// Track allocated ports for preview mode
-let nextPreviewPort = 3100;
-
-/**
- * Preview funnel: create isolated worktree for agent work.
- * Returns the worktree path or undefined on failure.
- */
-function createWorktree(cwd: string, workId: string, branchName: string): string | undefined {
-  const worktreesDir = join(homedir(), ".abbie", "worktrees");
-  mkdirSync(worktreesDir, { recursive: true });
-
-  const safeId = workId.replace(/[^a-z0-9-_]+/gi, "-").toLowerCase();
-  const worktreePath = join(worktreesDir, safeId);
-
-  try {
-    // Check if we're in a git repo
-    execSync("git rev-parse --git-dir", { cwd, stdio: "pipe" });
-
-    // Create worktree with new branch
-    execSync(`git worktree add -b "${branchName}" "${worktreePath}" HEAD`, { cwd, stdio: "pipe" });
-
-    return worktreePath;
-  } catch (_err) {
-    // Try without -b if branch already exists
-    try {
-      execSync(`git worktree add "${worktreePath}" HEAD`, { cwd, stdio: "pipe" });
-      return worktreePath;
-    } catch {
-      return undefined;
-    }
-  }
-}
-
-/**
- * Preview funnel: remove worktree after work is done.
- */
-export function removeWorktree(worktreePath: string): boolean {
-  try {
-    execSync(`git worktree remove "${worktreePath}" --force`, { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Preview funnel: start dev server in background.
- * Returns the process and assigned port.
- */
-function startDevServer(
-  worktreePath: string,
-  port: number,
-  devCommand: string = "pnpm dev",
-): { pid: number; port: number } | undefined {
-  try {
-    // Check if pnpm/package.json exists
-    if (!existsSync(join(worktreePath, "package.json"))) {
-      return undefined;
-    }
-
-    // Install deps first (quick)
-    try {
-      execSync("pnpm install --frozen-lockfile", {
-        cwd: worktreePath,
-        stdio: "pipe",
-        timeout: 60000,
-      });
-    } catch {
-      // Continue even if install fails (deps might already exist)
-    }
-
-    // Start dev server with specific port
-    const [cmd, ...args] = devCommand.split(" ");
-    const child = spawn(cmd, [...args, "--port", port.toString()], {
-      cwd: worktreePath,
-      detached: true,
-      stdio: "ignore",
-      env: { ...process.env, PORT: port.toString() },
-    });
-
-    child.unref();
-
-    return { pid: child.pid!, port };
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Preview funnel: setup complete preview environment.
- * Creates worktree, starts dev server, creates ngrok tunnel.
- */
-async function setupPreviewEnvironment(
-  request: SpawnRequest,
-  options: SpawnOptions,
-): Promise<SpawnResult["preview"]> {
-  if (!options.preview?.enabled) {
-    return undefined;
-  }
-
-  const workId = request.work.id;
-  const branchName = `auto/${options.sessionId.slice(0, 8)}/${workId.replace(/[^a-z0-9-]+/gi, "-").toLowerCase()}`;
-
-  // 1. Create worktree
-  const worktreePath = createWorktree(options.cwd, workId, branchName);
-  if (!worktreePath) {
-    return undefined;
-  }
-
-  // 2. Start dev server
-  const port = options.preview.basePort || nextPreviewPort++;
-  const devCommand = options.preview.devCommand || "pnpm dev";
-  const devServer = startDevServer(worktreePath, port, devCommand);
-
-  if (!devServer) {
-    // Cleanup worktree if dev server fails
-    removeWorktree(worktreePath);
-    return undefined;
-  }
-
-  // 3. Wait for dev server to be ready (up to 30s)
-  await new Promise((r) => setTimeout(r, 5000));
-
-  // 4. Create ngrok tunnel
-  const tunnelUrl = await getPublicUrl(port);
-
-  return {
-    worktree: worktreePath,
-    port: devServer.port,
-    tunnelUrl: tunnelUrl || undefined,
-    devServerPid: devServer.pid,
-  };
-}
-
-function resolveAgentCommand(
-  agent: AgentType,
-  commands?: { codex?: string; copilot?: string },
-): string | undefined {
-  if (agent === "codex") {
-    return commands?.codex || process.env.CODEX_CMD || process.env.CODEX_BIN || "codex";
-  }
-
-  if (agent === "copilot") {
-    return commands?.copilot || process.env.COPILOT_CMD || "copilot";
-  }
-
-  return undefined;
-}
-
-function isCommandAvailable(command: string): boolean {
-  if (command.includes("/")) {
-    return existsSync(command);
-  }
-
-  const result = spawnSync("which", [command], { stdio: "ignore" });
-  return result.status === 0;
-}
-
-function enqueueSpawn(request: SpawnRequest, options: SpawnOptions): string | undefined {
-  const baseDir = options.queueDir || join(process.env.HOME || "", ".abbie", "auto", "queue");
-
-  try {
-    mkdirSync(baseDir, { recursive: true });
-    const safeId = request.work.id.replace(/[^a-z0-9-_]+/gi, "-");
-    const filePath = join(baseDir, `${safeId}.json`);
-    const payload = {
-      session_id: options.sessionId,
-      project: options.project,
-      created_at: new Date().toISOString(),
-      request,
-    };
-    writeFileSync(filePath, JSON.stringify(payload, null, 2));
-    return filePath;
-  } catch {
-    return undefined;
-  }
-}
-
-/**
- * Get CLI arguments for the agent.
- * - codex: exec - --full-auto -o outputPath
- * - copilot: --yolo --model gemini-3-pro
- */
-function getAgentArgs(agent: AgentType, outputPath: string): string[] {
-  if (agent === "codex") {
-    return ["exec", "-", "--full-auto", "-o", outputPath, "--json"];
-  }
-
-  if (agent === "copilot") {
-    return ["--yolo", "--model", "gemini-3-pro"];
-  }
-
-  throw new Error(`Unsupported agent for auto spawn: ${agent}`);
-}
-
-/**
- * Build the prompt for an agent to work on a task.
- * Includes context, task, and output contract for structured responses.
- */
-function buildAgentPrompt(
-  request: SpawnRequest,
-  options: SpawnOptions,
-  preview?: SpawnResult["preview"],
-): string {
-  const { work, agent, effort } = request;
-  const metadata = work.metadata || {};
-
-  const issueRef = metadata.source_identifier || work.issue || work.id;
-  const issueUrl = metadata.source_url || work.url || "";
-  const taskType = metadata.type || "task";
-  const complexity = metadata.complexity || effort;
-  const suggestedPrompt = work.details || `Work on: ${work.title}`;
-  const workingDir = preview?.worktree || options.cwd;
-
-  const contractType = agent === "copilot" || agent === "gemini" ? "exploration" : "implementation";
-  const outputContract = getContractTemplate(contractType);
-
-  const previewSection = preview?.tunnelUrl
-    ? `
-<preview>
-A live preview environment is running:
-- Preview URL: ${preview.tunnelUrl}
-- Local port: ${preview.port}
-- Working in isolated git worktree: ${preview.worktree}
-
-After implementing changes, verify they work correctly by checking the preview URL.
-The changes you make are isolated in a git worktree and won't affect the main branch.
-</preview>
-`
-    : "";
-
-  return `<role>
-You are an autonomous coding agent working on a ${taskType} task.
-Project: ${options.project}
-Working directory: ${workingDir}
-</role>
-
-<context>
-Issue: ${issueRef}
-${issueUrl ? `URL: ${issueUrl}` : ""}
-Title: ${work.title}
-Type: ${taskType}
-Complexity: ${complexity}
-Effort: ${effort}
-</context>
-${previewSection}
-<task>
-${suggestedPrompt}
-</task>
-
-<exploration>
-Before implementing, explore the codebase:
-1. Run \`layer .\` to understand architecture
-2. Run \`outline\` on relevant directories to map code structure
-3. Use \`--callers\` and \`--callees\` to trace dependencies
-</exploration>
-
-<verification>
-After implementation:
-1. Run \`verify --format=summary\` to check tests
-2. Ensure no type errors
-3. Commit with message referencing ${issueRef}${preview?.tunnelUrl ? "\n4. Verify changes work in live preview" : ""}
-</verification>
-
-<output_contract>
-Conclude your work naturally — summarize what was done, the current state, and what comes next.
-
-Also include this structured JSON at the END of your response for machine parsing:
-${outputContract}
-</output_contract>
-`;
-}