@ulpi/cli 0.1.4 → 0.1.6

package/dist/run-VPNXEIBY.js

@@ -0,0 +1,687 @@
+import {
+  ExecutionEngine
+} from "./chunk-EJ7TW77N.js";
+import "./chunk-S6ANCSYO.js";
+import "./chunk-76D3BYJD.js";
+import "./chunk-IZPJHSPX.js";
+import "./chunk-5MI5GIXM.js";
+import "./chunk-SEU7WWNQ.js";
+import {
+  API_LOCK_FILE
+} from "./chunk-C7CLUQI6.js";
+import "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/run.ts
+import * as fs from "fs";
+import * as http from "http";
+import * as os from "os";
+import * as path from "path";
+import { execFileSync } from "child_process";
+import chalk from "chalk";
+function getFlag(args, flag) {
+  const idx = args.indexOf(flag);
+  if (idx !== -1 && idx + 1 < args.length) {
+    return args[idx + 1];
+  }
+  return void 0;
+}
+function hasFlag(args, flag) {
+  return args.includes(flag);
+}
+async function runRunCommand(args, projectDir) {
+  const prdFile = getFlag(args, "--prd");
+  const branchName = getFlag(args, "--branch");
+  let trackerName = getFlag(args, "--tracker") ?? "json";
+  const agentName = getFlag(args, "--agent") ?? "claude";
+  const model = getFlag(args, "--model") ?? "";
+  let tasksFile = getFlag(args, "--tasks");
+  const autoCommit = hasFlag(args, "--auto-commit");
+  const maxRetries = parseInt(getFlag(args, "--max-retries") ?? "3", 10);
+  const maxIterations = parseInt(
+    getFlag(args, "--max-iterations") ?? "0",
+    10
+  );
+  const timeout = parseInt(getFlag(args, "--timeout") ?? "0", 10);
+  const maxWorkers = parseInt(getFlag(args, "--max-workers") ?? "3", 10);
+  if (prdFile) {
+    const resolvedPrd = path.resolve(prdFile);
+    if (!fs.existsSync(resolvedPrd)) {
+      console.error(chalk.red(`PRD file not found: ${resolvedPrd}`));
+      process.exit(1);
+    }
+    try {
+      const { parsePrdMarkdown } = await import("./dist-3EIQTZHT.js");
+      const { convertPrdToJson } = await import("./dist-3EIQTZHT.js");
+      const prdContent = fs.readFileSync(resolvedPrd, "utf-8");
+      const parsed = parsePrdMarkdown(prdContent);
+      if (parsed.document.tasks.length === 0) {
+        console.error(chalk.red("No tasks found in PRD file."));
+        process.exit(1);
+      }
+      console.log(
+        chalk.green(
+          `Parsed PRD: ${parsed.document.tasks.length} task(s) from "${parsed.document.title}"`
+        )
+      );
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "ulpi-prd-"));
+      const tmpTasksFile = path.join(tmpDir, "tasks.json");
+      const tasksJson = convertPrdToJson(parsed.document);
+      fs.writeFileSync(tmpTasksFile, JSON.stringify(tasksJson, null, 2));
+      tasksFile = tmpTasksFile;
+      trackerName = "json";
+    } catch (err) {
+      console.error(
+        chalk.red(
+          `Failed to parse PRD: ${err instanceof Error ? err.message : String(err)}`
+        )
+      );
+      process.exit(1);
+    }
+  }
+  if (branchName) {
+    try {
+      execFileSync("git", ["checkout", "-b", branchName], {
+        cwd: projectDir,
+        encoding: "utf-8"
+      });
+      console.log(chalk.green(`Created and checked out branch: ${branchName}`));
+    } catch (err) {
+      try {
+        execFileSync("git", ["checkout", branchName], {
+          cwd: projectDir,
+          encoding: "utf-8"
+        });
+        console.log(chalk.yellow(`Checked out existing branch: ${branchName}`));
+      } catch (err2) {
+        console.error(
+          chalk.red(
+            `Failed to create/checkout branch: ${err2 instanceof Error ? err2.message : String(err2)}`
+          )
+        );
+        process.exit(1);
+      }
+    }
+  }
+  const trackerConfig = {};
+  if (trackerName === "json") {
+    const defaultTasksPath = path.join(projectDir, "tasks.json");
+    const resolvedTasksFile = tasksFile ? path.resolve(tasksFile) : defaultTasksPath;
+    if (!fs.existsSync(resolvedTasksFile)) {
+      console.error(
+        chalk.red(
+          `Tasks file not found: ${resolvedTasksFile}
+Create a tasks.json file or specify one with --tasks <file>`
+        )
+      );
+      process.exit(1);
+    }
+    trackerConfig.path = resolvedTasksFile;
+  } else if (tasksFile) {
+    trackerConfig.path = path.resolve(tasksFile);
+  }
+  if (hasFlag(args, "--parallel")) {
+    let prdMarkdown;
+    if (prdFile) {
+      try {
+        prdMarkdown = fs.readFileSync(path.resolve(prdFile), "utf-8");
+      } catch {
+      }
+    }
+    await runParallelMode(args, projectDir, {
+      agentName,
+      model,
+      trackerName,
+      trackerConfig,
+      maxWorkers,
+      autoCommit,
+      maxRetries,
+      prdMarkdown
+    });
+    return;
+  }
+  const config = {
+    agentName,
+    trackerName,
+    trackerConfig,
+    workingDir: projectDir,
+    maxRetries,
+    retryDelayMs: 5e3,
+    autoCommit,
+    timeout,
+    maxIterations,
+    iterationDelayMs: 0,
+    errorStrategy: "retry",
+    rateLimit: {
+      enabled: true,
+      maxRetries: 3,
+      baseBackoffMs: 5e3,
+      recoverPrimaryBetweenIterations: true
+    },
+    agentConfig: model ? { model } : {}
+  };
+  console.log(chalk.bold("\nULPI Execution Engine"));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(`  Agent:   ${chalk.cyan(agentName)}${model ? ` (${chalk.cyan(model)})` : ""}`);
+  console.log(`  Tracker: ${chalk.cyan(trackerName)}`);
+  console.log(`  Dir:     ${chalk.dim(projectDir)}`);
+  if (autoCommit) {
+    console.log(`  Auto-commit: ${chalk.green("enabled")}`);
+  }
+  if (maxIterations > 0) {
+    console.log(`  Max iterations: ${maxIterations}`);
+  }
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log();
+  const engine = new ExecutionEngine(config);
+  try {
+    await engine.initialize();
+  } catch (err) {
+    console.error(
+      chalk.red(
+        `Failed to initialize engine: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+  const startedAt = Date.now();
+  const collectedEvents = [];
+  engine.on((event) => {
+    handleEvent(event);
+    relayLoopEvent(event);
+    if (event.type !== "agent:output") {
+      collectedEvents.push({ ...event, ts: event.timestamp });
+    }
+  });
+  let stopping = false;
+  process.on("SIGINT", async () => {
+    if (stopping) {
+      console.log(chalk.red("\nForce exiting..."));
+      process.exit(1);
+    }
+    stopping = true;
+    console.log(chalk.yellow("\nInterrupted. Stopping engine..."));
+    await engine.stop();
+  });
+  try {
+    await engine.start();
+  } catch (err) {
+    console.error(
+      chalk.red(
+        `Engine error: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  }
+  const state = engine.getState();
+  try {
+    const { captureJobForClassification, isMemoryEnabled } = await import("./dist-JLU26AB6.js");
+    if (isMemoryEnabled(projectDir) && collectedEvents.length > 0) {
+      const cliJobId = `cli-${Date.now()}`;
+      captureJobForClassification(projectDir, cliJobId, collectedEvents, {
+        jobId: cliJobId,
+        mode: "sequential",
+        agentName,
+        startedAt: new Date(startedAt).toISOString(),
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tasksCompleted: state.completedTasks.length,
+        tasksFailed: state.failedTasks.length,
+        totalIterations: state.currentIteration
+      });
+      const { spawn } = await import("child_process");
+      const child = spawn(
+        process.execPath,
+        [process.argv[1], "memory", "classify", "-p", projectDir, "--session", cliJobId],
+        { detached: true, stdio: "ignore", env: { ...process.env, ULPI_BG_CLASSIFY: "1" } }
+      );
+      child.unref();
+    }
+  } catch {
+  }
+  console.log();
+  console.log(chalk.bold("Run Summary"));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(
+    `  Completed: ${chalk.green(String(state.completedTasks.length))}`
+  );
+  console.log(
+    `  Failed:    ${chalk.red(String(state.failedTasks.length))}`
+  );
+  console.log(
+    `  Skipped:   ${chalk.yellow(String(state.skippedTasks.length))}`
+  );
+  console.log(`  Iterations: ${state.currentIteration}`);
+  console.log(chalk.dim("\u2500".repeat(40)));
+}
+function handleEvent(event) {
+  switch (event.type) {
+    case "engine:started":
+      console.log(
+        chalk.green(`Engine started with ${event.totalTasks} task(s)`)
+      );
+      break;
+    case "engine:stopped":
+      console.log(
+        chalk.dim(
+          `Engine stopped: ${event.reason} (${event.totalIterations} iterations, ${event.tasksCompleted} completed)`
+        )
+      );
+      break;
+    case "engine:paused":
+      console.log(chalk.yellow("Engine paused"));
+      break;
+    case "engine:resumed":
+      console.log(chalk.green("Engine resumed"));
+      break;
+    case "iteration:started":
+      console.log(
+        chalk.blue(
+          `
+[Iteration ${event.iteration}] Task: ${event.task.id} - ${event.task.title}`
+        )
+      );
+      break;
+    case "iteration:completed":
+      if (event.result.taskCompleted) {
+        console.log(
+          chalk.green(
+            `  Task completed in ${formatDuration(event.result.durationMs)}`
+          )
+        );
+      } else {
+        console.log(
+          chalk.dim(
+            `  Iteration completed (task not done) in ${formatDuration(event.result.durationMs)}`
+          )
+        );
+      }
+      break;
+    case "iteration:failed":
+      console.log(
+        chalk.red(`  Iteration failed: ${event.error} [${event.action}]`)
+      );
+      break;
+    case "iteration:retrying":
+      console.log(
+        chalk.yellow(
+          `  Retrying (${event.retryAttempt}/${event.maxRetries}) in ${formatDuration(event.delayMs)}...`
+        )
+      );
+      break;
+    case "iteration:rate-limited":
+      console.log(
+        chalk.yellow(
+          `  Rate limited (${event.retryAttempt}/${event.maxRetries}). Waiting ${formatDuration(event.delayMs)}...`
+        )
+      );
+      break;
+    case "task:auto-committed":
+      console.log(
+        chalk.green(
+          `  Auto-committed: ${event.commitSha ?? "unknown"} - ${event.commitMessage}`
+        )
+      );
+      break;
+    case "task:auto-commit-failed":
+      console.log(
+        chalk.red(`  Auto-commit failed: ${event.error}`)
+      );
+      break;
+    case "task:auto-commit-skipped":
+      console.log(
+        chalk.dim(`  Auto-commit skipped: ${event.reason}`)
+      );
+      break;
+    case "agent:switched":
+      console.log(
+        chalk.cyan(
+          `  Agent switched: ${event.previousAgent} -> ${event.newAgent} (${event.reason})`
+        )
+      );
+      break;
+    case "agent:all-limited":
+      console.log(
+        chalk.red(
+          `  All agents rate-limited: ${event.triedAgents.join(", ")}. Pausing.`
+        )
+      );
+      break;
+    case "agent:recovery-attempted":
+      if (event.success) {
+        console.log(
+          chalk.green(
+            `  Primary agent '${event.primaryAgent}' recovered (${event.testDurationMs}ms)`
+          )
+        );
+      }
+      break;
+    case "all:complete":
+      console.log(
+        chalk.green(
+          `
+All tasks complete! ${event.totalCompleted} tasks in ${event.totalIterations} iterations.`
+        )
+      );
+      break;
+    // agent:output events are intentionally not printed to avoid flooding terminal
+    default:
+      break;
+  }
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  const mins = Math.floor(ms / 6e4);
+  const secs = Math.round(ms % 6e4 / 1e3);
+  return `${mins}m ${secs}s`;
+}
+function emitToApi(event) {
+  try {
+    const lockData = JSON.parse(fs.readFileSync(API_LOCK_FILE, "utf-8"));
+    const port = lockData.port;
+    if (!port) return;
+    const body = JSON.stringify(event);
+    const headers = {
+      "Content-Type": "application/json",
+      "Content-Length": String(Buffer.byteLength(body))
+    };
+    if (lockData.secret) {
+      headers["X-Ulpi-Secret"] = lockData.secret;
+    }
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port,
+      path: "/api/events/emit",
+      method: "POST",
+      headers,
+      timeout: 2e3
+    });
+    req.on("error", () => {
+    });
+    req.on("timeout", () => req.destroy());
+    req.write(body);
+    req.end();
+  } catch {
+  }
+}
+function relayLoopEvent(event) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const base = { ts, sessionId: "" };
+  let mapped = null;
+  switch (event.type) {
+    case "engine:started":
+      mapped = { ...base, type: "engine:started", totalTasks: event.totalTasks, tasks: [] };
+      break;
+    case "engine:stopped":
+      mapped = { ...base, type: "engine:stopped", reason: event.reason, totalIterations: event.totalIterations, tasksCompleted: event.tasksCompleted };
+      break;
+    case "iteration:started":
+      mapped = { ...base, type: "iteration:started", iteration: event.iteration, taskId: event.task.id };
+      break;
+    case "iteration:completed":
+      mapped = {
+        ...base,
+        type: "iteration:completed",
+        iteration: event.result.iteration,
+        taskId: event.result.task.id,
+        durationMs: event.result.durationMs,
+        completionSignalDetected: event.result.completionSignalDetected
+      };
+      break;
+    case "iteration:failed":
+      mapped = { ...base, type: "iteration:failed", iteration: event.iteration, taskId: "", error: event.error, action: event.action };
+      break;
+    case "task:auto-committed":
+      mapped = {
+        ...base,
+        type: "task:auto-committed",
+        taskId: event.task.id,
+        iteration: event.iteration,
+        commitMessage: event.commitMessage,
+        commitSha: event.commitSha
+      };
+      break;
+    case "all:complete":
+      mapped = { ...base, type: "all:complete", totalCompleted: event.totalCompleted, totalIterations: event.totalIterations };
+      break;
+    default:
+      break;
+  }
+  if (mapped) {
+    emitToApi(mapped);
+  }
+}
+async function runParallelMode(args, projectDir, opts) {
+  const { ParallelExecutor } = await import("./dist-AYBGHEDY.js");
+  const { getTrackerRegistry } = await import("./dist-NUEMFZFL.js");
+  console.log(chalk.bold("\nULPI Parallel Execution"));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(`  Agent:       ${chalk.cyan(opts.agentName)}${opts.model ? ` (${chalk.cyan(opts.model)})` : ""}`);
+  console.log(`  Tracker:     ${chalk.cyan(opts.trackerName)}`);
+  console.log(`  Workers:     ${chalk.cyan(String(opts.maxWorkers))}`);
+  console.log(`  Dir:         ${chalk.dim(projectDir)}`);
+  console.log(`  Auto-commit: ${chalk.green("enabled")} (required for worktree merge)`);
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log();
+  const registry = getTrackerRegistry();
+  await registry.initialize();
+  await registry.disposeInstance(opts.trackerName);
+  const tracker = await registry.getInstance({
+    name: opts.trackerName,
+    plugin: opts.trackerName,
+    options: opts.trackerConfig
+  });
+  await tracker.sync();
+  const tasks = await tracker.getTasks();
+  if (tasks.length === 0) {
+    console.error(chalk.red("No open tasks found. Nothing to execute."));
+    process.exit(1);
+  }
+  console.log(chalk.green(`Found ${tasks.length} task(s)`));
+  const baseEngineConfig = {
+    agentName: opts.agentName,
+    trackerName: opts.trackerName,
+    trackerConfig: opts.trackerConfig,
+    workingDir: projectDir,
+    maxRetries: opts.maxRetries,
+    retryDelayMs: 5e3,
+    autoCommit: true,
+    // Required for worktree merge
+    timeout: 0,
+    maxIterations: 0,
+    iterationDelayMs: 0,
+    errorStrategy: "retry",
+    rateLimit: {
+      enabled: true,
+      maxRetries: 3,
+      baseBackoffMs: 5e3,
+      recoverPrimaryBetweenIterations: true
+    },
+    agentConfig: opts.model ? { model: opts.model } : {}
+  };
+  const aiConflictResolution = !hasFlag(args, "--no-ai-conflicts");
+  const enableValidation = !hasFlag(args, "--no-validation");
+  const executor = new ParallelExecutor(
+    {
+      cwd: projectDir,
+      maxWorkers: opts.maxWorkers,
+      aiConflictResolution,
+      enableValidation,
+      prdMarkdown: opts.prdMarkdown
+    },
+    baseEngineConfig
+  );
+  const startedAt = Date.now();
+  const collectedParallelEvents = [];
+  executor.on((event) => {
+    handleParallelEvent(event);
+    if (event.type !== "worker-progress") {
+      collectedParallelEvents.push({ ...event, ts: event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString() });
+    }
+  });
+  let stopping = false;
+  const sigHandler = async () => {
+    if (stopping) {
+      console.log(chalk.red("\nForce exiting..."));
+      process.exit(1);
+    }
+    stopping = true;
+    console.log(chalk.yellow("\nInterrupted. Stopping parallel execution..."));
+    await executor.stop();
+  };
+  process.on("SIGINT", sigHandler);
+  try {
+    await executor.initialize(tasks);
+    const state = executor.getState();
+    if (state.dagAnalysis) {
+      console.log(
+        chalk.dim(
+          `  DAG: ${state.dagAnalysis.groups.length} group(s), max parallelism: ${state.dagAnalysis.maxParallelism}`
+        )
+      );
+      if (state.dagAnalysis.warnings.length > 0) {
+        for (const w of state.dagAnalysis.warnings) {
+          console.log(chalk.yellow(`  Warning: ${w}`));
+        }
+      }
+    }
+    console.log();
+    await executor.execute();
+  } catch (err) {
+    console.error(
+      chalk.red(
+        `
+Parallel execution error: ${err instanceof Error ? err.message : String(err)}`
+      )
+    );
+    process.exit(1);
+  } finally {
+    process.removeListener("SIGINT", sigHandler);
+    try {
+      await registry.disposeInstance(opts.trackerName);
+    } catch {
+    }
+  }
+  const finalState = executor.getState();
+  console.log();
+  console.log(chalk.bold("Parallel Run Summary"));
+  console.log(chalk.dim("\u2500".repeat(40)));
+  console.log(`  Total tasks:   ${finalState.totalTasks}`);
+  console.log(`  Completed:     ${chalk.green(String(finalState.totalTasksCompleted))}`);
+  console.log(`  Groups:        ${finalState.totalGroups}`);
+  const durationMs = finalState.elapsedMs;
+  console.log(`  Duration:      ${formatDuration(durationMs)}`);
+  console.log(chalk.dim("\u2500".repeat(40)));
+  try {
+    const { captureJobForClassification, isMemoryEnabled } = await import("./dist-JLU26AB6.js");
+    if (isMemoryEnabled(projectDir) && collectedParallelEvents.length > 0) {
+      const cliJobId = `cli-par-${Date.now()}`;
+      const totalFailed = finalState.totalTasks - finalState.totalTasksCompleted;
+      captureJobForClassification(projectDir, cliJobId, collectedParallelEvents, {
+        jobId: cliJobId,
+        mode: "parallel",
+        agentName: opts.agentName,
+        startedAt: new Date(startedAt).toISOString(),
+        endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        tasksCompleted: finalState.totalTasksCompleted,
+        tasksFailed: totalFailed > 0 ? totalFailed : 0,
+        totalIterations: collectedParallelEvents.filter((e) => e.type === "worker-started").length
+      });
+      const { spawn } = await import("child_process");
+      const child = spawn(
+        process.execPath,
+        [process.argv[1], "memory", "classify", "-p", projectDir, "--session", cliJobId],
+        { detached: true, stdio: "ignore", env: { ...process.env, ULPI_BG_CLASSIFY: "1" } }
+      );
+      child.unref();
+    }
+  } catch {
+  }
+}
+function handleParallelEvent(event) {
+  switch (event.type) {
+    case "worker-started":
+      console.log(
+        chalk.blue(`  [Worker ${event.workerId}] Started: task ${event.taskId}`)
+      );
+      break;
+    case "worker-completed":
+      console.log(
+        event.success ? chalk.green(
+          `  [Worker ${event.workerId}] Completed: task ${event.taskId}`
+        ) : chalk.red(
+          `  [Worker ${event.workerId}] Failed: task ${event.taskId}`
+        )
+      );
+      break;
+    case "worker-failed":
+      console.log(
+        chalk.red(`  [Worker ${event.workerId}] Failed: ${event.error}`)
+      );
+      break;
+    case "merge-started":
+      console.log(
+        chalk.dim(`  [Merge] Starting merge for task ${event.taskId}`)
+      );
+      break;
+    case "merge-completed":
+      console.log(
+        chalk.green(
+          `  [Merge] Task ${event.taskId} merged${event.commitSha ? ` (${event.commitSha})` : ""}`
+        )
+      );
+      break;
+    case "merge-failed":
+      console.log(
+        chalk.red(
+          `  [Merge] Task ${event.taskId} merge failed: ${event.error}`
+        )
+      );
+      break;
+    case "group-completed":
+      console.log(
+        chalk.bold(
+          `
+  Group ${event.groupIndex}: ${event.tasksCompleted} completed, ${event.tasksFailed} failed`
+        )
+      );
+      break;
+    case "all-completed":
+      console.log(
+        chalk.green(
+          `
+  All tasks complete! ${event.totalCompleted} completed, ${event.totalFailed} failed (${formatDuration(event.durationMs)})`
+        )
+      );
+      break;
+    case "worker-progress":
+      if (event.engineEventType === "task:auto-committed" || event.engineEventType === "iteration:failed") {
+        console.log(
+          chalk.dim(
+            `  [Worker ${event.workerId}] ${event.engineEventType}`
+          )
+        );
+      }
+      break;
+    case "validation-started":
+      console.log(
+        chalk.bold(
+          `
+  Validation: Starting post-parallel validation (${event.totalMerged} merged, ${event.totalFailed} failed)`
+        )
+      );
+      break;
+    case "validation-completed":
+      console.log(
+        event.success ? chalk.green(
+          `  Validation: Completed (${event.commitCount} commits, ${formatDuration(event.durationMs)})`
+        ) : chalk.yellow(
+          `  Validation: Finished with issues (${event.commitCount} commits, ${formatDuration(event.durationMs)})`
+        )
+      );
+      break;
+  }
+}
+export {
+  runRunCommand
+};

package/dist/server-COL4AXKU-P7S7NNF6.js

@@ -0,0 +1,11 @@
+import {
+  attachWebSocket
+} from "./chunk-E3B5NROU.js";
+import "./chunk-Z53CAR7G.js";
+import "./chunk-UXHCHOWQ.js";
+import "./chunk-SEU7WWNQ.js";
+import "./chunk-C7CLUQI6.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  attachWebSocket
+};