@ulpi/cli 0.1.4 → 0.1.5

package/dist/ci-JQ56YIKC.js

@@ -0,0 +1,756 @@
+import {
+  buildPrompt
+} from "./chunk-AV5RB3N2.js";
+import {
+  external_exports
+} from "./chunk-KIKPIH6N.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/ci.ts
+import * as fs from "fs";
+import * as path from "path";
+import { spawn, execFileSync } from "child_process";
+import chalk from "chalk";
+
+// ../../packages/contracts-ci/dist/index.js
+var CiCommandTypeSchema = external_exports.enum(["run", "cancel", "fork", "status"]);
+var CiCommandSchema = external_exports.object({
+  type: CiCommandTypeSchema,
+  instruction: external_exports.string().optional(),
+  prNumber: external_exports.number().int().positive(),
+  repoFullName: external_exports.string(),
+  // "org/repo"
+  commentId: external_exports.number().int().positive(),
+  commentAuthor: external_exports.string(),
+  forkName: external_exports.string().optional()
+});
+var JobStatusSchema = external_exports.enum([
+  "queued",
+  "provisioning",
+  "running",
+  "completing",
+  "completed",
+  "failed",
+  "cancelled",
+  "timed_out"
+]);
+var JobConfigSchema = external_exports.object({
+  repoUrl: external_exports.string().url(),
+  ref: external_exports.string(),
+  baseBranch: external_exports.string(),
+  prNumber: external_exports.number().int().positive(),
+  repoFullName: external_exports.string(),
+  instruction: external_exports.string(),
+  jiraContext: external_exports.string().optional(),
+  timeoutMinutes: external_exports.number().int().positive().default(1440),
+  envVars: external_exports.record(external_exports.string()).optional()
+});
+var JobResultSchema = external_exports.object({
+  jobId: external_exports.string(),
+  status: JobStatusSchema,
+  exitCode: external_exports.number().int().optional(),
+  diff: external_exports.string().optional(),
+  testOutput: external_exports.string().optional(),
+  summary: external_exports.string().optional(),
+  filesChanged: external_exports.array(external_exports.string()),
+  sessionEvents: external_exports.number().int().default(0),
+  durationMs: external_exports.number().int(),
+  error: external_exports.string().optional()
+});
+var JobSchema = external_exports.object({
+  id: external_exports.string(),
+  config: JobConfigSchema,
+  status: JobStatusSchema,
+  result: JobResultSchema.optional(),
+  containerId: external_exports.string().optional(),
+  workspaceDir: external_exports.string().optional(),
+  parentJobId: external_exports.string().optional(),
+  createdAt: external_exports.string().datetime(),
+  startedAt: external_exports.string().datetime().optional(),
+  completedAt: external_exports.string().datetime().optional(),
+  cancelledBy: external_exports.string().optional(),
+  commentId: external_exports.number().int().positive(),
+  commentAuthor: external_exports.string()
+});
+var GitHubAppAuthSchema = external_exports.object({
+  appId: external_exports.string(),
+  privateKeyPath: external_exports.string(),
+  webhookSecret: external_exports.string(),
+  installationId: external_exports.number().int().positive().optional()
+});
+var GitHubAuthConfigSchema = external_exports.discriminatedUnion("mode", [
+  external_exports.object({ mode: external_exports.literal("app"), config: GitHubAppAuthSchema }),
+  external_exports.object({ mode: external_exports.literal("pat"), token: external_exports.string() })
+]);
+var JiraConfigSchema = external_exports.object({
+  baseUrl: external_exports.string().url(),
+  email: external_exports.string().email(),
+  apiToken: external_exports.string(),
+  defaultProject: external_exports.string().optional()
+});
+var DockerConfigSchema = external_exports.object({
+  image: external_exports.string(),
+  network: external_exports.string().optional(),
+  memoryLimit: external_exports.string().optional(),
+  // e.g. "4g"
+  cpuLimit: external_exports.number().positive().optional(),
+  // e.g. 2.0
+  volumeBaseDir: external_exports.string(),
+  // Host path — used for Docker bind mounts
+  localVolumeBaseDir: external_exports.string().optional()
+  // Container-local path — used for fs ops (defaults to volumeBaseDir)
+});
+var SecurityConfigSchema = external_exports.object({
+  requireWriteAccess: external_exports.boolean().default(true),
+  allowedRepos: external_exports.array(external_exports.string()).optional(),
+  allowedAuthors: external_exports.array(external_exports.string()).optional(),
+  allowedOrgs: external_exports.array(external_exports.string()).optional(),
+  apiToken: external_exports.string(),
+  rateLimitWebhook: external_exports.number().int().positive().default(60),
+  rateLimitApi: external_exports.number().int().positive().default(200)
+});
+var OrchestratorConfigSchema = external_exports.object({
+  github: GitHubAuthConfigSchema,
+  jira: JiraConfigSchema.optional(),
+  docker: DockerConfigSchema,
+  jobs: external_exports.object({
+    maxConcurrent: external_exports.number().int().positive().default(3),
+    timeoutMinutes: external_exports.number().int().positive().default(1440),
+    retainCompletedHours: external_exports.number().int().positive().default(72)
+  }),
+  security: SecurityConfigSchema,
+  port: external_exports.number().int().positive().default(3e3),
+  host: external_exports.string().default("0.0.0.0")
+});
+var ClaudeCredentialsSchema = external_exports.object({
+  blob: external_exports.string(),
+  // base64-encoded credentials directory contents
+  createdAt: external_exports.string().datetime(),
+  expiresAt: external_exports.string().datetime().optional()
+});
+var WorkerInputSchema = external_exports.object({
+  jobId: external_exports.string(),
+  config: JobConfigSchema,
+  claudeModel: external_exports.string().optional()
+});
+var WorkerOutputSchema = external_exports.object({
+  jobId: external_exports.string(),
+  result: JobResultSchema
+});
+var WorkerProgressSchema = external_exports.object({
+  phase: external_exports.string(),
+  message: external_exports.string(),
+  timestamp: external_exports.string().datetime()
+});
+var JiraTicketSchema = external_exports.object({
+  key: external_exports.string(),
+  // e.g. "ABC-123"
+  summary: external_exports.string(),
+  description: external_exports.string().optional(),
+  status: external_exports.string(),
+  assignee: external_exports.string().optional(),
+  priority: external_exports.string().optional(),
+  labels: external_exports.array(external_exports.string()),
+  acceptanceCriteria: external_exports.string().optional()
+});
+var JiraReferenceSchema = external_exports.object({
+  key: external_exports.string(),
+  url: external_exports.string().url()
+});
+
+// src/commands/ci.ts
+async function runCi(args, projectDir) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "run":
+      return runCiJob(args.slice(1));
+    default:
+      console.log(`
+${chalk.bold("ulpi ci")} \u2014 CI/PR worker mode
+
+Usage: ulpi ci <command>
+
+Commands:
+  run     Execute a CI job (used inside worker containers)
+
+Options:
+  --job-id <id>       Job identifier
+  --config <json>     Job config (JSON string or from ULPI_JOB_CONFIG env)
+  --output <path>     Output file path for results
+  --model <model>     Claude model to use (default: claude-sonnet-4-20250514)
+`.trim());
+  }
+}
+async function runCiJob(args) {
+  let jobId = "";
+  let configJson = "";
+  let outputPath = "";
+  let model = "claude-sonnet-4-20250514";
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--job-id":
+        jobId = args[++i] ?? "";
+        break;
+      case "--config":
+        configJson = args[++i] ?? "";
+        break;
+      case "--output":
+        outputPath = args[++i] ?? "";
+        break;
+      case "--model":
+        model = args[++i] ?? model;
+        break;
+    }
+  }
+  jobId = jobId || process.env.ULPI_JOB_ID || "";
+  configJson = configJson || process.env.ULPI_JOB_CONFIG || "";
+  outputPath = outputPath || "/workspace/.ulpi-ci/output.json";
+  if (!jobId) {
+    console.error(chalk.red("Error: --job-id is required"));
+    process.exit(1);
+  }
+  if (!configJson) {
+    console.error(chalk.red("Error: --config is required (or set ULPI_JOB_CONFIG env)"));
+    process.exit(1);
+  }
+  let rawConfig;
+  try {
+    rawConfig = JSON.parse(configJson);
+  } catch {
+    console.error(chalk.red("Error: Invalid JSON in --config"));
+    process.exit(1);
+  }
+  const parseResult = JobConfigSchema.safeParse(rawConfig);
+  if (!parseResult.success) {
+    console.error(chalk.red("Error: Invalid job config:"));
+    console.error(parseResult.error.format());
+    process.exit(1);
+  }
+  const config = parseResult.data;
+  const startTime = Date.now();
+  console.log(chalk.blue(`[ulpi-ci] Job ${jobId} starting`));
+  console.log(chalk.blue(`[ulpi-ci] Instruction: ${config.instruction}`));
+  console.log(chalk.blue(`[ulpi-ci] Repo: ${config.repoFullName} PR#${config.prNumber}`));
+  const projectDir = process.cwd();
+  const subsystemInfo = await initUlpiSubsystems(projectDir);
+  const prompt = buildPrompt(config, {
+    stackContext: subsystemInfo.stackContext
+  });
+  const claudePath = findClaudeBinary();
+  if (!claudePath) {
+    console.error(chalk.red("Error: claude binary not found in PATH"));
+    writeOutput(outputPath, {
+      jobId,
+      status: "failed",
+      filesChanged: [],
+      sessionEvents: 0,
+      durationMs: Date.now() - startTime,
+      error: "claude binary not found"
+    });
+    process.exit(1);
+  }
+  console.log(chalk.blue(`[ulpi-ci] Using claude at: ${claudePath}`));
+  const claudeArgs = [
+    "--print",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--dangerously-skip-permissions",
+    "--model",
+    model
+  ];
+  console.log(chalk.blue("[ulpi-ci] Spawning Claude Code..."));
+  const result = await spawnClaude(claudePath, claudeArgs, prompt, config.timeoutMinutes * 60 * 1e3);
+  commitUnstagedWork(process.cwd());
+  await postSessionFinalize(process.cwd());
+  const baseBranch = config.baseBranch;
+  let diff = "";
+  let filesChanged = [];
+  try {
+    diff = execFileSync("git", ["diff", `origin/${baseBranch}...HEAD`], {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      timeout: 3e4,
+      maxBuffer: 10 * 1024 * 1024
+    });
+  } catch {
+  }
+  try {
+    const output = execFileSync("git", ["diff", "--name-only", `origin/${baseBranch}...HEAD`], {
+      cwd: process.cwd(),
+      encoding: "utf-8",
+      timeout: 3e4
+    });
+    filesChanged = output.trim().split("\n").filter(Boolean);
+  } catch {
+  }
+  const jobResult = {
+    jobId,
+    status: result.exitCode === 0 ? "completed" : "failed",
+    exitCode: result.exitCode,
+    diff: diff || void 0,
+    summary: result.summary.slice(0, 5e3) || void 0,
+    filesChanged,
+    sessionEvents: result.toolUseCount,
+    durationMs: Date.now() - startTime,
+    error: result.exitCode !== 0 ? `Claude exited with code ${result.exitCode}` : void 0
+  };
+  writeOutput(outputPath, jobResult);
+  console.log(chalk.blue(`[ulpi-ci] Job ${jobId} ${jobResult.status} in ${formatDuration(jobResult.durationMs)}`));
+  console.log(chalk.blue(`[ulpi-ci] Files changed: ${filesChanged.length}`));
+  console.log(chalk.blue(`[ulpi-ci] Tool uses: ${result.toolUseCount}`));
+  process.exit(result.exitCode === 0 ? 0 : 1);
+}
+async function initUlpiSubsystems(projectDir) {
+  console.log(chalk.blue("[ulpi-ci] Initializing ULPI subsystems..."));
+  const info = {};
+  const rulesDir = path.join(projectDir, ".ulpi");
+  fs.mkdirSync(rulesDir, { recursive: true });
+  try {
+    const { detectStack } = await import("./dist-2K7IEVTA.js");
+    const stack = detectStack(projectDir);
+    const parts = [];
+    if (stack.runtime) parts.push(`- **Runtime:** ${stack.runtime.id}`);
+    if (stack.language) parts.push(`- **Language:** ${stack.language.id}`);
+    if (stack.framework) parts.push(`- **Framework:** ${stack.framework.id}`);
+    if (stack.packageManager) parts.push(`- **Package manager:** ${stack.packageManager.id}`);
+    if (stack.testRunner) parts.push(`- **Test runner:** ${stack.testRunner.id}`);
+    if (stack.linter) parts.push(`- **Linter:** ${stack.linter.id}`);
+    if (stack.formatter) parts.push(`- **Formatter:** ${stack.formatter.id}`);
+    if (stack.orm) parts.push(`- **ORM:** ${stack.orm.id}`);
+    if (stack.gitWorkflow) parts.push(`- **Git workflow:** ${stack.gitWorkflow.id}`);
+    if (parts.length > 0) {
+      parts.unshift("Detected project stack. Use these technologies when writing code:");
+      info.stackContext = parts.join("\n");
+    }
+    const guardsPath = path.join(rulesDir, "guards.yml");
+    if (fs.existsSync(guardsPath)) {
+      console.log(chalk.blue("[ulpi-ci] guards.yml found \u2014 rules will be enforced"));
+    } else {
+      const { loadBundledTemplates, composeTemplates, resolveTemplate } = await import("./dist-XG2GG5SD.js");
+      const stackConfig = {
+        name: path.basename(projectDir),
+        runtime: stack.runtime?.id ?? "unknown",
+        language: stack.language?.id,
+        framework: stack.framework?.id,
+        package_manager: stack.packageManager?.id ?? "npm",
+        orm: stack.orm?.id,
+        test_runner: stack.testRunner?.id,
+        formatter: stack.formatter?.id,
+        linter: stack.linter?.id,
+        git_workflow: stack.gitWorkflow?.id
+      };
+      const all = loadBundledTemplates();
+      const selected = [all.find((t) => t.id === "quality-of-life")].filter(Boolean);
+      const detectors = [
+        stack.runtime,
+        stack.language,
+        stack.packageManager,
+        stack.framework,
+        stack.formatter,
+        stack.linter,
+        stack.testRunner,
+        stack.orm,
+        stack.gitWorkflow
+      ];
+      for (const det of detectors) {
+        if (det) {
+          const t = all.find((l) => l.id === det.id);
+          if (t && !selected.includes(t)) selected.push(t);
+        }
+      }
+      const composed = composeTemplates(selected);
+      const resolved = resolveTemplate(composed, stackConfig);
+      const rulesYaml = generateGuardsYaml(resolved, stackConfig);
+      fs.writeFileSync(guardsPath, rulesYaml, "utf-8");
+      console.log(chalk.blue("[ulpi-ci] Generated guards.yml from detected stack"));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not detect stack/generate guards.yml: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { installHooks } = await import("./hooks-installer-K2JXEBNN.js");
+    installHooks(projectDir);
+    console.log(chalk.blue("[ulpi-ci] Hooks installed"));
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not install hooks: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { installMcpServer, installMemoryMcpServer } = await import("./mcp-installer-TOYDP77X.js");
+    installMcpServer(projectDir);
+    installMemoryMcpServer(projectDir);
+    console.log(chalk.blue("[ulpi-ci] MCP servers registered"));
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not register MCP servers: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    execFileSync("git", ["config", "user.name", "ULPI CI"], { cwd: projectDir, encoding: "utf-8", timeout: 5e3 });
+    execFileSync("git", ["config", "user.email", "ci@ulpi.io"], { cwd: projectDir, encoding: "utf-8", timeout: 5e3 });
+  } catch {
+  }
+  try {
+    const { historyBranchExists, initHistoryBranch } = await import("./dist-5R4RYNQO.js");
+    if (!historyBranchExists(projectDir)) {
+      const projectName = path.basename(projectDir);
+      const version = true ? "0.1.5" : "0.0.0";
+      initHistoryBranch(projectDir, projectName, version);
+      console.log(chalk.blue("[ulpi-ci] History branch initialized"));
+    } else {
+      console.log(chalk.blue("[ulpi-ci] History branch exists"));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init history: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG, initMemoryBranch } = await import("./dist-7WLLPWWB.js");
+    const { projectMemoryDir } = await import("./dist-GWGTAHNM.js");
+    if (!isMemoryInitialized(projectDir)) {
+      const memDir = projectMemoryDir(projectDir);
+      fs.mkdirSync(memDir, { recursive: true });
+      saveMemoryConfig(projectDir, { ...DEFAULT_MEMORY_CONFIG, enabled: true });
+      console.log(chalk.blue("[ulpi-ci] Memory initialized"));
+    }
+    try {
+      initMemoryBranch(projectDir);
+    } catch {
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init memory: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { resolveApiKey } = await import("./dist-GWGTAHNM.js");
+    const hasOpenAiKey = !!resolveApiKey("openai");
+    const hasUlpiKey = !!resolveApiKey("ulpi");
+    if (hasOpenAiKey || hasUlpiKey) {
+      const { runInitPipeline } = await import("./dist-6MFVWIFF.js");
+      console.log(chalk.blue("[ulpi-ci] Indexing codebase..."));
+      await runInitPipeline(projectDir, (progress) => {
+        if (progress.message) {
+          process.stdout.write(`\r  ${chalk.dim(progress.message)}${"".padEnd(20)}`);
+        }
+      });
+      process.stdout.write("\r");
+      console.log(chalk.blue("[ulpi-ci] Codemap index ready"));
+    } else {
+      console.log(chalk.dim("[ulpi-ci] Skipping codemap (no embedding API key)"));
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not init codemap: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  console.log(chalk.blue("[ulpi-ci] Subsystem initialization complete"));
+  return info;
+}
+function generateGuardsYaml(resolved, config) {
+  const lines = [
+    "# ULPI \u2014 Rules Configuration",
+    "# Generated automatically for CI worker.",
+    `# Project: ${config.name}`,
+    "",
+    "project:",
+    `  name: "${config.name}"`,
+    `  runtime: "${config.runtime}"`,
+    `  package_manager: "${config.package_manager}"`,
+    ""
+  ];
+  const sections = ["preconditions", "postconditions", "permissions", "pipelines"];
+  for (const section of sections) {
+    const data = resolved[section];
+    if (data && Object.keys(data).length > 0) {
+      lines.push(`${section}:`);
+      for (const [key, rule] of Object.entries(data)) {
+        lines.push(`  ${key}:`);
+        writeYamlFields(rule, lines, 4);
+      }
+      lines.push("");
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+function writeYamlFields(obj, lines, indent) {
+  const pad = " ".repeat(indent);
+  for (const [k, v] of Object.entries(obj)) {
+    if (k === "id" || k === "type" || k === "source") continue;
+    if (typeof v === "string") {
+      lines.push(`${pad}${k}: "${v}"`);
+    } else if (typeof v === "boolean" || typeof v === "number") {
+      lines.push(`${pad}${k}: ${v}`);
+    } else if (Array.isArray(v)) {
+      lines.push(`${pad}${k}:`);
+      for (const item of v) {
+        if (typeof item === "string") {
+          lines.push(`${pad}  - "${item}"`);
+        } else if (typeof item === "object" && item !== null) {
+          lines.push(`${pad}  -`);
+          writeYamlFields(item, lines, indent + 4);
+        }
+      }
+    } else if (v !== null && typeof v === "object") {
+      lines.push(`${pad}${k}:`);
+      writeYamlFields(v, lines, indent + 2);
+    }
+  }
+}
+function commitUnstagedWork(cwd) {
+  try {
+    const status = execFileSync("git", ["status", "--porcelain"], {
+      cwd,
+      encoding: "utf-8",
+      timeout: 1e4
+    }).trim();
+    if (!status) return;
+    const fileCount = status.split("\n").filter(Boolean).length;
+    console.log(chalk.blue(`[ulpi-ci] Committing ${fileCount} uncommitted files...`));
+    execFileSync("git", ["add", "-A"], { cwd, timeout: 3e4 });
+    execFileSync("git", ["commit", "-m", "wip: auto-commit from ULPI CI worker"], {
+      cwd,
+      timeout: 3e4
+    });
+    console.log(chalk.blue("[ulpi-ci] WIP commit created"));
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Could not auto-commit: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+async function postSessionFinalize(projectDir) {
+  try {
+    const {
+      historyBranchExists,
+      listBranchOnlyCommits,
+      entryExists,
+      getCommitMetadata,
+      getCommitDiffStats,
+      getCommitRawDiff,
+      writeHistoryEntry,
+      readBranchMeta,
+      DEFAULT_HISTORY_CONFIG
+    } = await import("./dist-5R4RYNQO.js");
+    const { loadActiveGuards } = await import("./dist-5R4RYNQO.js");
+    if (historyBranchExists(projectDir)) {
+      const commits = listBranchOnlyCommits(projectDir, 50);
+      const meta = readBranchMeta(projectDir);
+      const maxDiffSize = meta?.config?.maxDiffSize ?? DEFAULT_HISTORY_CONFIG.maxDiffSize;
+      let captured = 0;
+      for (const sha of commits) {
+        if (entryExists(projectDir, sha)) continue;
+        try {
+          const metadata = getCommitMetadata(projectDir, sha);
+          const diffStats = getCommitDiffStats(projectDir, sha);
+          const rawDiffResult = getCommitRawDiff(projectDir, sha, maxDiffSize);
+          const guardsYaml = loadActiveGuards(projectDir);
+          await writeHistoryEntry(projectDir, {
+            version: 1,
+            capturedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            commit: metadata,
+            diff: diffStats,
+            rawDiff: rawDiffResult.diff || void 0,
+            diffTruncated: rawDiffResult.truncated || void 0,
+            session: null,
+            enrichment: null,
+            reviewPlans: null
+          }, {
+            state: null,
+            events: [],
+            guardsYaml
+          });
+          captured++;
+        } catch {
+        }
+      }
+      if (captured > 0) {
+        console.log(chalk.blue(`[ulpi-ci] History backfill: captured ${captured} commits`));
+      }
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: History backfill failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+  try {
+    const { isMemoryInitialized, classifySession } = await import("./dist-7WLLPWWB.js");
+    const { ULPI_GLOBAL_DIR } = await import("./dist-GWGTAHNM.js");
+    const { JsonSessionStore } = await import("./dist-XD4YI27T.js");
+    if (isMemoryInitialized(projectDir)) {
+      const store = new JsonSessionStore(ULPI_GLOBAL_DIR, projectDir);
+      const latest = store.getLatestForProject(projectDir);
+      if (latest) {
+        console.log(chalk.blue(`[ulpi-ci] Classifying session ${latest.sessionId}...`));
+        const result = await classifySession(projectDir, latest.sessionId, (p) => {
+          if (p.message) {
+            process.stdout.write(`\r  ${chalk.dim(p.message)}${"".padEnd(20)}`);
+          }
+        });
+        process.stdout.write("\r");
+        if (result.memoriesStored > 0) {
+          console.log(chalk.blue(`[ulpi-ci] Memory: ${result.memoriesStored} memories extracted`));
+        }
+      }
+    }
+  } catch (err) {
+    console.log(chalk.yellow(`[ulpi-ci] Warning: Memory classify failed: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+function findClaudeBinary() {
+  try {
+    const result = execFileSync("which", ["claude"], { encoding: "utf-8", timeout: 5e3 });
+    return result.trim();
+  } catch {
+  }
+  const commonPaths = ["/usr/local/bin/claude", "/usr/bin/claude"];
+  for (const p of commonPaths) {
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+function logStreamEvent(line) {
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    return;
+  }
+  const type = event.type;
+  switch (type) {
+    case "assistant": {
+      const msg = event.message;
+      if (!msg) break;
+      const content = msg.content;
+      if (!content) break;
+      for (const block of content) {
+        if (block.type === "tool_use") {
+          const name = block.name;
+          const input = block.input;
+          let detail = "";
+          if (input) {
+            if (input.file_path) detail = ` ${input.file_path}`;
+            else if (input.command) detail = ` ${String(input.command).slice(0, 80)}`;
+            else if (input.pattern) detail = ` ${input.pattern}`;
+            else if (input.query) detail = ` ${String(input.query).slice(0, 80)}`;
+            else if (input.prompt) detail = ` ${String(input.prompt).slice(0, 80)}`;
+          }
+          console.log(chalk.cyan(`[claude] tool: ${name}${detail}`));
+        } else if (block.type === "text") {
+          const text = String(block.text).trim();
+          if (text) {
+            const firstLine = text.split("\n")[0].slice(0, 120);
+            console.log(chalk.gray(`[claude] ${firstLine}`));
+          }
+        }
+      }
+      break;
+    }
+    case "tool_result": {
+      break;
+    }
+    case "result": {
+      const cost = event.total_cost_usd;
+      const turns = event.num_turns;
+      const duration = event.duration_ms;
+      console.log(chalk.blue(
+        `[claude] Done \u2014 ${turns ?? "?"} turns, ${duration ? formatDuration(duration) : "?"}, $${cost?.toFixed(4) ?? "?"}`
+      ));
+      break;
+    }
+    case "system": {
+      const subtype = event.subtype;
+      if (subtype === "init") {
+        const model = event.model;
+        const version = event.claude_code_version;
+        console.log(chalk.blue(`[claude] Initialized \u2014 model: ${model ?? "?"}, version: ${version ?? "?"}`));
+      }
+      break;
+    }
+  }
+}
+function spawnClaude(claudePath, args, prompt, timeoutMs) {
+  return new Promise((resolve) => {
+    const proc = spawn(claudePath, args, {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let resultText = "";
+    let toolUseCount = 0;
+    let lineBuffer = "";
+    proc.stdout.on("data", (data) => {
+      const text = data.toString();
+      stdout += text;
+      lineBuffer += text;
+      const lines = lineBuffer.split("\n");
+      lineBuffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        logStreamEvent(trimmed);
+        try {
+          const event = JSON.parse(trimmed);
+          if (event.type === "result") {
+            resultText = event.result ?? "";
+          } else if (event.type === "assistant") {
+            const msg = event.message;
+            const content = msg?.content;
+            if (content) {
+              for (const block of content) {
+                if (block.type === "tool_use") toolUseCount++;
+              }
+            }
+          }
+        } catch {
+        }
+      }
+    });
+    proc.stderr.on("data", (data) => {
+      const text = data.toString();
+      stderr += text;
+      process.stderr.write(text);
+    });
+    proc.stdin.write(prompt);
+    proc.stdin.end();
+    const timer = setTimeout(() => {
+      console.log(chalk.yellow("[ulpi-ci] Timeout reached, killing Claude process..."));
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        if (!proc.killed) proc.kill("SIGKILL");
+      }, 1e4);
+    }, timeoutMs);
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (lineBuffer.trim()) {
+        logStreamEvent(lineBuffer.trim());
+        try {
+          const event = JSON.parse(lineBuffer.trim());
+          if (event.type === "result") {
+            resultText = event.result ?? "";
+          }
+        } catch {
+        }
+      }
+      resolve({ exitCode: code ?? 1, summary: resultText, toolUseCount });
+    });
+    const onSigterm = () => {
+      console.log(chalk.yellow("[ulpi-ci] Received SIGTERM, stopping Claude..."));
+      proc.kill("SIGTERM");
+    };
+    process.on("SIGTERM", onSigterm);
+    proc.on("close", () => {
+      process.removeListener("SIGTERM", onSigterm);
+    });
+  });
+}
+function writeOutput(outputPath, result) {
+  try {
+    const dir = path.dirname(outputPath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(outputPath, JSON.stringify({ jobId: result.jobId, result }, null, 2), "utf-8");
+  } catch (err) {
+    console.error(chalk.red(`Error writing output: ${err instanceof Error ? err.message : String(err)}`));
+  }
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = seconds % 60;
+  return `${minutes}m ${remainingSeconds}s`;
+}
+export {
+  runCi
+};