@open330/oac-execution 2026.2.17

package/dist/index.js

@@ -0,0 +1,1479 @@
+// src/agents/claude-code.adapter.ts
+import { createInterface } from "readline";
+import { OacError, executionError } from "@open330/oac-core";
+import { execa } from "execa";
+var AsyncEventQueue = class {
+  values = [];
+  resolvers = [];
+  done = false;
+  pendingError;
+  push(value) {
+    if (this.done) {
+      return;
+    }
+    const nextResolver = this.resolvers.shift();
+    if (nextResolver) {
+      nextResolver({ done: false, value });
+      return;
+    }
+    this.values.push(value);
+  }
+  close() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    this.flush();
+  }
+  fail(error) {
+    this.pendingError = error;
+    this.done = true;
+    this.flush();
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.values.length > 0) {
+          const value = this.values.shift();
+          if (value === void 0) {
+            return { done: true, value: void 0 };
+          }
+          return { done: false, value };
+        }
+        if (this.pendingError !== void 0) {
+          throw this.pendingError;
+        }
+        if (this.done) {
+          return { done: true, value: void 0 };
+        }
+        return new Promise((resolve2) => {
+          this.resolvers.push(resolve2);
+        });
+      }
+    };
+  }
+  flush() {
+    for (const resolve2 of this.resolvers.splice(0)) {
+      resolve2({ done: true, value: void 0 });
+    }
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function readNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function readString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function parseJsonPayload(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  const candidates = [trimmed];
+  const start = trimmed.indexOf("{");
+  const end = trimmed.lastIndexOf("}");
+  if (start >= 0 && end > start) {
+    const fragment = trimmed.slice(start, end + 1);
+    if (fragment !== trimmed) {
+      candidates.push(fragment);
+    }
+  }
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate);
+      if (isRecord(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function patchTokenState(state, patch) {
+  if (patch.inputTokens === void 0 && patch.outputTokens === void 0 && patch.cumulativeTokens === void 0) {
+    return void 0;
+  }
+  state.inputTokens = patch.inputTokens ?? state.inputTokens;
+  state.outputTokens = patch.outputTokens ?? state.outputTokens;
+  const computedTotal = state.inputTokens + state.outputTokens;
+  state.cumulativeTokens = Math.max(
+    state.cumulativeTokens,
+    patch.cumulativeTokens ?? computedTotal
+  );
+  return {
+    type: "tokens",
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    cumulativeTokens: state.cumulativeTokens
+  };
+}
+function parseTokenPatchFromPayload(payload) {
+  const usage = isRecord(payload.usage) ? payload.usage : void 0;
+  return {
+    inputTokens: readNumber(
+      payload.inputTokens ?? payload.input_tokens ?? payload.promptTokens ?? payload.prompt_tokens ?? usage?.inputTokens ?? usage?.input_tokens ?? usage?.promptTokens ?? usage?.prompt_tokens
+    ),
+    outputTokens: readNumber(
+      payload.outputTokens ?? payload.output_tokens ?? payload.completionTokens ?? payload.completion_tokens ?? usage?.outputTokens ?? usage?.output_tokens ?? usage?.completionTokens ?? usage?.completion_tokens
+    ),
+    cumulativeTokens: readNumber(
+      payload.cumulativeTokens ?? payload.cumulative_tokens ?? payload.totalTokens ?? payload.total_tokens ?? usage?.cumulativeTokens ?? usage?.cumulative_tokens ?? usage?.totalTokens ?? usage?.total_tokens
+    )
+  };
+}
+function parseTokenPatchFromLine(line) {
+  const inputMatch = line.match(/(?:input|prompt)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const outputMatch = line.match(/(?:output|completion)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const totalMatch = line.match(/(?:total|cumulative|used)\s*tokens?\s*[:=]\s*(\d+)/i);
+  return {
+    inputTokens: inputMatch ? Number.parseInt(inputMatch[1], 10) : void 0,
+    outputTokens: outputMatch ? Number.parseInt(outputMatch[1], 10) : void 0,
+    cumulativeTokens: totalMatch ? Number.parseInt(totalMatch[1], 10) : void 0
+  };
+}
+function parseTokenEvent(line, state) {
+  const payload = parseJsonPayload(line);
+  const patch = payload ? parseTokenPatchFromPayload(payload) : parseTokenPatchFromLine(line);
+  return patchTokenState(state, patch);
+}
+function normalizeFileAction(value) {
+  if (value !== "create" && value !== "modify" && value !== "delete") {
+    return void 0;
+  }
+  return value;
+}
+function parseFileEditFromPayload(payload) {
+  if (payload.type === "file_edit") {
+    const action = normalizeFileAction(payload.action);
+    const path = readString(payload.path);
+    if (action && path) {
+      return {
+        type: "file_edit",
+        action,
+        path
+      };
+    }
+  }
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  const input = isRecord(payload.input) ? payload.input : void 0;
+  const inputPath = readString(input?.path ?? input?.file_path ?? input?.filePath);
+  if (!tool || !inputPath) {
+    return void 0;
+  }
+  if (tool === "create_file") {
+    return { type: "file_edit", action: "create", path: inputPath };
+  }
+  if (tool === "delete_file") {
+    return { type: "file_edit", action: "delete", path: inputPath };
+  }
+  if (tool === "write_file" || tool === "edit_file" || tool === "replace_file") {
+    return { type: "file_edit", action: "modify", path: inputPath };
+  }
+  return void 0;
+}
+function parseFileEditFromLine(line) {
+  const fileActionMatch = line.match(/\b(created|modified|deleted)\s+(?:file\s+)?([^\s"'`]+)/i);
+  if (!fileActionMatch) {
+    return void 0;
+  }
+  const actionMap = {
+    created: "create",
+    modified: "modify",
+    deleted: "delete"
+  };
+  const action = actionMap[fileActionMatch[1].toLowerCase()];
+  const path = fileActionMatch[2]?.trim();
+  if (!action || !path) {
+    return void 0;
+  }
+  return {
+    type: "file_edit",
+    action,
+    path
+  };
+}
+function parseFileEditEvent(line) {
+  const payload = parseJsonPayload(line);
+  return payload ? parseFileEditFromPayload(payload) : parseFileEditFromLine(line);
+}
+function parseToolUseEvent(line) {
+  const payload = parseJsonPayload(line);
+  if (!payload) {
+    return void 0;
+  }
+  const tool = readString(payload.tool ?? payload.tool_name ?? payload.name);
+  if (!tool) {
+    return void 0;
+  }
+  return {
+    type: "tool_use",
+    tool,
+    input: payload.input
+  };
+}
+function parseErrorEvent(line, stream) {
+  const payload = parseJsonPayload(line);
+  if (payload?.type === "error") {
+    const message = readString(payload.message) ?? "Unknown Claude CLI error";
+    const recoverable = payload.recoverable !== false;
+    return { type: "error", message, recoverable };
+  }
+  if (stream === "stderr" && /error|failed|exception/i.test(line)) {
+    return { type: "error", message: line.trim(), recoverable: true };
+  }
+  return void 0;
+}
+function estimateTokenCount(text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalizeUnknownError(error, executionId) {
+  if (error instanceof OacError) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return executionError("AGENT_TIMEOUT", `Claude execution timed out for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/out of memory|ENOMEM|heap/i.test(message)) {
+    return executionError("AGENT_OOM", `Claude execution ran out of memory for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+    return new OacError(
+      "Claude execution failed due to network issues",
+      "NETWORK_ERROR",
+      "recoverable",
+      {
+        executionId,
+        message
+      },
+      error
+    );
+  }
+  return executionError("AGENT_EXECUTION_FAILED", `Claude execution failed for ${executionId}`, {
+    context: { executionId, message },
+    cause: error
+  });
+}
+function computeTotalTokens(state) {
+  return Math.max(state.cumulativeTokens, state.inputTokens + state.outputTokens);
+}
+function normalizeExitCode(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return 1;
+}
+function hasBooleanFlag(value, key) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return value[key] === true;
+}
+function buildFailureMessage(stdout, stderr) {
+  const trimmedStderr = stderr.trim();
+  if (trimmedStderr.length > 0) {
+    return trimmedStderr;
+  }
+  const trimmedStdout = stdout.trim();
+  if (trimmedStdout.length > 0) {
+    return trimmedStdout;
+  }
+  return "Claude CLI process exited with a non-zero status.";
+}
+var ClaudeCodeAdapter = class {
+  id = "claude-code";
+  name = "Claude Code";
+  runningExecutions = /* @__PURE__ */ new Map();
+  async checkAvailability() {
+    try {
+      const result = await execa("claude", ["--version"], { reject: false });
+      const version = result.stdout.trim().split("\n")[0];
+      if (result.exitCode === 0) {
+        return {
+          available: true,
+          version: version.length > 0 ? version : void 0
+        };
+      }
+      return {
+        available: false,
+        error: result.stderr.trim() || `claude --version exited with code ${result.exitCode}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        available: false,
+        error: message
+      };
+    }
+  }
+  execute(params) {
+    const startedAt = Date.now();
+    const filesChanged = /* @__PURE__ */ new Set();
+    const tokenState = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cumulativeTokens: 0
+    };
+    const eventQueue = new AsyncEventQueue();
+    const processEnv = {
+      ...Object.fromEntries(
+        Object.entries(process.env).filter(
+          (entry) => typeof entry[1] === "string"
+        )
+      ),
+      ...params.env,
+      OAC_TOKEN_BUDGET: `${params.tokenBudget}`,
+      OAC_ALLOW_COMMITS: `${params.allowCommits}`
+    };
+    const subprocess = execa("claude", ["-p", params.prompt], {
+      cwd: params.workingDirectory,
+      env: processEnv,
+      reject: false,
+      timeout: params.timeoutMs
+    });
+    this.runningExecutions.set(params.executionId, subprocess);
+    const consumeStream = async (stream, streamName) => {
+      if (!stream) {
+        return;
+      }
+      const lineReader = createInterface({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY
+      });
+      for await (const line of lineReader) {
+        eventQueue.push({
+          type: "output",
+          content: line,
+          stream: streamName
+        });
+        const tokenEvent = parseTokenEvent(line, tokenState);
+        if (tokenEvent?.type === "tokens") {
+          eventQueue.push(tokenEvent);
+        }
+        const fileEvent = parseFileEditEvent(line);
+        if (fileEvent) {
+          filesChanged.add(fileEvent.path);
+          eventQueue.push(fileEvent);
+        }
+        const toolEvent = parseToolUseEvent(line);
+        if (toolEvent) {
+          eventQueue.push(toolEvent);
+        }
+        const errorEvent = parseErrorEvent(line, streamName);
+        if (errorEvent) {
+          eventQueue.push(errorEvent);
+        }
+      }
+    };
+    const stdoutDone = consumeStream(subprocess.stdout ?? void 0, "stdout");
+    const stderrDone = consumeStream(subprocess.stderr ?? void 0, "stderr");
+    const resultPromise = (async () => {
+      try {
+        const settled = await subprocess;
+        await Promise.all([stdoutDone, stderrDone]);
+        const timedOut = hasBooleanFlag(settled, "timedOut");
+        if (timedOut) {
+          const timeoutError = executionError(
+            "AGENT_TIMEOUT",
+            `Claude execution timed out for ${params.executionId}`,
+            {
+              context: {
+                executionId: params.executionId,
+                timeoutMs: params.timeoutMs
+              }
+            }
+          );
+          eventQueue.push({
+            type: "error",
+            message: timeoutError.message,
+            recoverable: true
+          });
+          throw timeoutError;
+        }
+        const canceled = hasBooleanFlag(settled, "isCanceled");
+        if (canceled) {
+          return {
+            success: false,
+            exitCode: normalizeExitCode(settled.exitCode),
+            totalTokensUsed: computeTotalTokens(tokenState),
+            filesChanged: [...filesChanged],
+            duration: Date.now() - startedAt,
+            error: "Claude execution was cancelled."
+          };
+        }
+        const exitCode = normalizeExitCode(settled.exitCode);
+        const success = exitCode === 0;
+        return {
+          success,
+          exitCode,
+          totalTokensUsed: computeTotalTokens(tokenState),
+          filesChanged: [...filesChanged],
+          duration: Date.now() - startedAt,
+          error: success ? void 0 : buildFailureMessage(settled.stdout, settled.stderr)
+        };
+      } catch (error) {
+        const normalized = normalizeUnknownError(error, params.executionId);
+        eventQueue.push({
+          type: "error",
+          message: normalized.message,
+          recoverable: normalized.severity !== "fatal"
+        });
+        eventQueue.fail(normalized);
+        throw normalized;
+      } finally {
+        this.runningExecutions.delete(params.executionId);
+        eventQueue.close();
+      }
+    })();
+    return {
+      executionId: params.executionId,
+      providerId: this.id,
+      events: eventQueue,
+      result: resultPromise,
+      pid: subprocess.pid
+    };
+  }
+  async estimateTokens(params) {
+    const contextTokens = params.contextTokens ?? params.targetFiles.length * 80 + params.targetFiles.join("\n").length;
+    const promptTokens = estimateTokenCount(params.prompt);
+    const expectedOutputTokens = params.expectedOutputTokens ?? Math.max(128, Math.ceil(promptTokens * 0.6));
+    const totalEstimatedTokens = contextTokens + promptTokens + expectedOutputTokens;
+    return {
+      taskId: params.taskId,
+      providerId: this.id,
+      contextTokens,
+      promptTokens,
+      expectedOutputTokens,
+      totalEstimatedTokens,
+      confidence: 0.6,
+      feasible: true
+    };
+  }
+  async abort(executionId) {
+    const running = this.runningExecutions.get(executionId);
+    if (!running) {
+      return;
+    }
+    running.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      running.kill("SIGKILL");
+    }, 5e3);
+    forceKillTimer.unref();
+    try {
+      await running;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+};
+
+// src/agents/codex.adapter.ts
+import { stat } from "fs/promises";
+import { createInterface as createInterface2 } from "readline";
+import { OacError as OacError2, executionError as executionError2 } from "@open330/oac-core";
+import { execa as execa2 } from "execa";
+var AsyncEventQueue2 = class {
+  values = [];
+  resolvers = [];
+  done = false;
+  pendingError;
+  push(value) {
+    if (this.done) {
+      return;
+    }
+    const nextResolver = this.resolvers.shift();
+    if (nextResolver) {
+      nextResolver({ done: false, value });
+      return;
+    }
+    this.values.push(value);
+  }
+  close() {
+    if (this.done) {
+      return;
+    }
+    this.done = true;
+    this.flush();
+  }
+  fail(error) {
+    this.pendingError = error;
+    this.done = true;
+    this.flush();
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: async () => {
+        if (this.values.length > 0) {
+          const value = this.values.shift();
+          if (value === void 0) {
+            return { done: true, value: void 0 };
+          }
+          return { done: false, value };
+        }
+        if (this.pendingError !== void 0) {
+          throw this.pendingError;
+        }
+        if (this.done) {
+          return { done: true, value: void 0 };
+        }
+        return new Promise((resolve2) => {
+          this.resolvers.push(resolve2);
+        });
+      }
+    };
+  }
+  flush() {
+    for (const resolve2 of this.resolvers.splice(0)) {
+      resolve2({ done: true, value: void 0 });
+    }
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+function readString2(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function readNumber2(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return Math.max(0, Math.floor(value));
+}
+function parseJsonPayload2(line) {
+  const trimmed = line.trim();
+  if (trimmed.length === 0) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (isRecord2(parsed)) {
+      return parsed;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function parseTokenPatchFromPayload2(payload) {
+  const usage = isRecord2(payload.usage) ? payload.usage : void 0;
+  return {
+    inputTokens: readNumber2(
+      payload.inputTokens ?? payload.input_tokens ?? payload.promptTokens ?? payload.prompt_tokens ?? usage?.inputTokens ?? usage?.input_tokens ?? usage?.promptTokens ?? usage?.prompt_tokens
+    ),
+    outputTokens: readNumber2(
+      payload.outputTokens ?? payload.output_tokens ?? payload.completionTokens ?? payload.completion_tokens ?? usage?.outputTokens ?? usage?.output_tokens ?? usage?.completionTokens ?? usage?.completion_tokens
+    ),
+    cumulativeTokens: readNumber2(
+      payload.cumulativeTokens ?? payload.cumulative_tokens ?? payload.totalTokens ?? payload.total_tokens ?? usage?.cumulativeTokens ?? usage?.cumulative_tokens ?? usage?.totalTokens ?? usage?.total_tokens
+    )
+  };
+}
+function patchTokenState2(state, patch) {
+  if (patch.inputTokens === void 0 && patch.outputTokens === void 0 && patch.cumulativeTokens === void 0) {
+    return void 0;
+  }
+  state.inputTokens = patch.inputTokens ?? state.inputTokens;
+  state.outputTokens = patch.outputTokens ?? state.outputTokens;
+  const computedTotal = state.inputTokens + state.outputTokens;
+  state.cumulativeTokens = Math.max(
+    state.cumulativeTokens,
+    patch.cumulativeTokens ?? computedTotal
+  );
+  return {
+    type: "tokens",
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    cumulativeTokens: state.cumulativeTokens
+  };
+}
+function parseTokenEvent2(line, payload, state) {
+  if (payload) {
+    return patchTokenState2(state, parseTokenPatchFromPayload2(payload));
+  }
+  const inputMatch = line.match(/(?:input|prompt)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const outputMatch = line.match(/(?:output|completion)\s*tokens?\s*[:=]\s*(\d+)/i);
+  const totalMatch = line.match(/(?:total|cumulative|used)\s*tokens?\s*[:=]\s*(\d+)/i);
+  return patchTokenState2(state, {
+    inputTokens: inputMatch ? Number.parseInt(inputMatch[1], 10) : void 0,
+    outputTokens: outputMatch ? Number.parseInt(outputMatch[1], 10) : void 0,
+    cumulativeTokens: totalMatch ? Number.parseInt(totalMatch[1], 10) : void 0
+  });
+}
+function normalizeFileAction2(value) {
+  if (value !== "create" && value !== "modify" && value !== "delete") {
+    return void 0;
+  }
+  return value;
+}
+function parseFileEditFromPayload2(payload) {
+  if (payload.type === "file_edit") {
+    const action = normalizeFileAction2(payload.action);
+    const path = readString2(payload.path);
+    if (action && path) {
+      return {
+        type: "file_edit",
+        action,
+        path
+      };
+    }
+  }
+  const tool = readString2(payload.tool ?? payload.tool_name ?? payload.name);
+  const input = isRecord2(payload.input) ? payload.input : void 0;
+  const inputPath = readString2(input?.path ?? input?.file_path ?? input?.filePath);
+  if (!tool || !inputPath) {
+    return void 0;
+  }
+  if (tool === "create_file") {
+    return { type: "file_edit", action: "create", path: inputPath };
+  }
+  if (tool === "delete_file") {
+    return { type: "file_edit", action: "delete", path: inputPath };
+  }
+  if (tool === "write_file" || tool === "edit_file" || tool === "replace_file") {
+    return { type: "file_edit", action: "modify", path: inputPath };
+  }
+  return void 0;
+}
+function parseToolUseFromPayload(payload) {
+  const tool = readString2(payload.tool ?? payload.tool_name ?? payload.name);
+  if (!tool) {
+    return void 0;
+  }
+  return {
+    type: "tool_use",
+    tool,
+    input: payload.input
+  };
+}
+function parseErrorFromPayload(payload) {
+  if (payload.type !== "error") {
+    return void 0;
+  }
+  return {
+    type: "error",
+    message: readString2(payload.message) ?? "Unknown Codex CLI error",
+    recoverable: payload.recoverable !== false
+  };
+}
+function estimateTokenCount2(text) {
+  if (text.length === 0) {
+    return 0;
+  }
+  return Math.max(1, Math.ceil(text.length / 4));
+}
+function normalizeUnknownError2(error, executionId) {
+  if (error instanceof OacError2) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return executionError2("AGENT_TIMEOUT", `Codex execution timed out for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/out of memory|ENOMEM|heap/i.test(message)) {
+    return executionError2("AGENT_OOM", `Codex execution ran out of memory for ${executionId}`, {
+      context: { executionId, message },
+      cause: error
+    });
+  }
+  if (/rate.limit|429|too many requests|throttl/i.test(message)) {
+    return executionError2(
+      "AGENT_RATE_LIMITED",
+      `Codex execution rate-limited for ${executionId}`,
+      {
+        context: { executionId, message },
+        cause: error
+      }
+    );
+  }
+  if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+    return new OacError2(
+      "Codex execution failed due to network issues",
+      "NETWORK_ERROR",
+      "recoverable",
+      {
+        executionId,
+        message
+      },
+      error
+    );
+  }
+  return executionError2("AGENT_EXECUTION_FAILED", `Codex execution failed for ${executionId}`, {
+    context: { executionId, message },
+    cause: error
+  });
+}
+function computeTotalTokens2(state) {
+  return Math.max(state.cumulativeTokens, state.inputTokens + state.outputTokens);
+}
+function normalizeExitCode2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  return 1;
+}
+function hasBooleanFlag2(value, key) {
+  if (!isRecord2(value)) {
+    return false;
+  }
+  return value[key] === true;
+}
+function buildFailureMessage2(stdout, stderr) {
+  const trimmedStderr = stderr.trim();
+  if (trimmedStderr.length > 0) {
+    return trimmedStderr;
+  }
+  const trimmedStdout = stdout.trim();
+  if (trimmedStdout.length > 0) {
+    return trimmedStdout;
+  }
+  return "Codex CLI process exited with a non-zero status.";
+}
+function parseVersion(output) {
+  const match = output.match(/(\d+\.\d+\.\d+)/);
+  if (!match) {
+    return void 0;
+  }
+  return match[1];
+}
+async function estimateContextTokens(targetFiles) {
+  let totalBytes = 0;
+  for (const filePath of targetFiles) {
+    try {
+      const fileStat = await stat(filePath);
+      if (fileStat.isFile()) {
+        totalBytes += fileStat.size;
+      }
+    } catch {
+    }
+  }
+  return Math.ceil(totalBytes / 4);
+}
+var CodexAdapter = class {
+  id = "codex";
+  name = "Codex CLI";
+  runningExecutions = /* @__PURE__ */ new Map();
+  async checkAvailability() {
+    try {
+      const result = await execa2("codex", ["--version"], { reject: false });
+      if (result.exitCode === 0) {
+        const versionLine = result.stdout.trim().split("\n")[0] ?? "";
+        return {
+          available: true,
+          version: parseVersion(versionLine)
+        };
+      }
+      return {
+        available: false,
+        error: result.stderr.trim() || result.stdout.trim() || `codex --version exited with code ${result.exitCode}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        available: false,
+        error: message
+      };
+    }
+  }
+  execute(params) {
+    const startedAt = Date.now();
+    const filesChanged = /* @__PURE__ */ new Set();
+    const tokenState = {
+      inputTokens: 0,
+      outputTokens: 0,
+      cumulativeTokens: 0
+    };
+    const eventQueue = new AsyncEventQueue2();
+    const processEnv = {
+      ...Object.fromEntries(
+        Object.entries(process.env).filter(
+          (entry) => typeof entry[1] === "string"
+        )
+      ),
+      ...params.env,
+      OAC_TOKEN_BUDGET: `${params.tokenBudget}`,
+      OAC_ALLOW_COMMITS: `${params.allowCommits}`
+    };
+    const subprocess = execa2(
+      "codex",
+      ["exec", "--full-auto", "-C", params.workingDirectory, params.prompt],
+      {
+        cwd: params.workingDirectory,
+        env: processEnv,
+        reject: false,
+        timeout: params.timeoutMs
+      }
+    );
+    this.runningExecutions.set(params.executionId, subprocess);
+    const consumeStream = async (stream, streamName) => {
+      if (!stream) {
+        return;
+      }
+      const lineReader = createInterface2({
+        input: stream,
+        crlfDelay: Number.POSITIVE_INFINITY
+      });
+      for await (const line of lineReader) {
+        eventQueue.push({
+          type: "output",
+          content: line,
+          stream: streamName
+        });
+        if (streamName === "stdout") {
+          const payload = parseJsonPayload2(line);
+          const tokenEvent = parseTokenEvent2(line, payload, tokenState);
+          if (tokenEvent?.type === "tokens") {
+            eventQueue.push(tokenEvent);
+          }
+          if (payload) {
+            const fileEvent = parseFileEditFromPayload2(payload);
+            if (fileEvent) {
+              filesChanged.add(fileEvent.path);
+              eventQueue.push(fileEvent);
+            }
+            const toolEvent = parseToolUseFromPayload(payload);
+            if (toolEvent) {
+              eventQueue.push(toolEvent);
+            }
+            const errorEvent = parseErrorFromPayload(payload);
+            if (errorEvent) {
+              eventQueue.push(errorEvent);
+            }
+          }
+        } else if (/error|failed|exception/i.test(line)) {
+          eventQueue.push({
+            type: "error",
+            message: line.trim(),
+            recoverable: true
+          });
+        }
+      }
+    };
+    const stdoutDone = consumeStream(subprocess.stdout ?? void 0, "stdout");
+    const stderrDone = consumeStream(subprocess.stderr ?? void 0, "stderr");
+    const resultPromise = (async () => {
+      try {
+        const settled = await subprocess;
+        await Promise.all([stdoutDone, stderrDone]);
+        const timedOut = hasBooleanFlag2(settled, "timedOut");
+        if (timedOut) {
+          const timeoutError = executionError2(
+            "AGENT_TIMEOUT",
+            `Codex execution timed out for ${params.executionId}`,
+            {
+              context: {
+                executionId: params.executionId,
+                timeoutMs: params.timeoutMs
+              }
+            }
+          );
+          eventQueue.push({
+            type: "error",
+            message: timeoutError.message,
+            recoverable: true
+          });
+          throw timeoutError;
+        }
+        const canceled = hasBooleanFlag2(settled, "isCanceled");
+        if (canceled) {
+          return {
+            success: false,
+            exitCode: normalizeExitCode2(settled.exitCode),
+            totalTokensUsed: computeTotalTokens2(tokenState),
+            filesChanged: [...filesChanged],
+            duration: Date.now() - startedAt,
+            error: "Codex execution was cancelled."
+          };
+        }
+        const exitCode = normalizeExitCode2(settled.exitCode);
+        const success = exitCode === 0;
+        return {
+          success,
+          exitCode,
+          totalTokensUsed: computeTotalTokens2(tokenState),
+          filesChanged: [...filesChanged],
+          duration: Date.now() - startedAt,
+          error: success ? void 0 : buildFailureMessage2(settled.stdout, settled.stderr)
+        };
+      } catch (error) {
+        const normalized = normalizeUnknownError2(error, params.executionId);
+        eventQueue.push({
+          type: "error",
+          message: normalized.message,
+          recoverable: normalized.severity !== "fatal"
+        });
+        eventQueue.fail(normalized);
+        throw normalized;
+      } finally {
+        this.runningExecutions.delete(params.executionId);
+        eventQueue.close();
+      }
+    })();
+    return {
+      executionId: params.executionId,
+      providerId: this.id,
+      events: eventQueue,
+      result: resultPromise,
+      pid: subprocess.pid
+    };
+  }
+  async estimateTokens(params) {
+    const baseTokens = params.targetFiles.length * 2e3;
+    const promptTokens = estimateTokenCount2(params.prompt);
+    const contextTokens = await estimateContextTokens(params.targetFiles);
+    const expectedOutputTokens = baseTokens;
+    const totalEstimatedTokens = contextTokens + promptTokens + expectedOutputTokens;
+    return {
+      taskId: params.taskId,
+      providerId: this.id,
+      contextTokens,
+      promptTokens,
+      expectedOutputTokens,
+      totalEstimatedTokens,
+      confidence: 0.6,
+      feasible: totalEstimatedTokens < 2e5
+    };
+  }
+  async abort(executionId) {
+    const running = this.runningExecutions.get(executionId);
+    if (!running) {
+      return;
+    }
+    running.kill("SIGTERM");
+    const forceKillTimer = setTimeout(() => {
+      running.kill("SIGKILL");
+    }, 2e3);
+    forceKillTimer.unref();
+    try {
+      await running;
+    } catch {
+    } finally {
+      clearTimeout(forceKillTimer);
+    }
+  }
+};
+
+// src/sandbox.ts
+import { mkdir } from "fs/promises";
+import { join, resolve } from "path";
+import { simpleGit } from "simple-git";
+function getWorktreePath(repoPath, branchName) {
+  return resolve(join(repoPath, "..", ".oac-worktrees", branchName));
+}
+async function createSandbox(repoPath, branchName, baseBranch) {
+  const worktreePath = getWorktreePath(repoPath, branchName);
+  const worktreeRoot = resolve(join(repoPath, "..", ".oac-worktrees"));
+  const git = simpleGit(repoPath);
+  await mkdir(worktreeRoot, { recursive: true });
+  await git.raw(["worktree", "add", worktreePath, "-b", branchName, `origin/${baseBranch}`]);
+  let cleanedUp = false;
+  return {
+    path: worktreePath,
+    branchName,
+    cleanup: async () => {
+      if (cleanedUp) {
+        return;
+      }
+      cleanedUp = true;
+      try {
+        await git.raw(["worktree", "remove", worktreePath, "--force"]);
+      } finally {
+        try {
+          await git.raw(["worktree", "prune"]);
+        } catch {
+        }
+      }
+    }
+  };
+}
+
+// src/worker.ts
+import { randomUUID } from "crypto";
+import {
+  OacError as OacError3,
+  executionError as executionError3
+} from "@open330/oac-core";
+var DEFAULT_TOKEN_BUDGET = 5e4;
+var DEFAULT_TIMEOUT_MS = 3e5;
+function readPositiveNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+    return void 0;
+  }
+  return Math.floor(value);
+}
+function readMetadataNumber(task, key) {
+  return readPositiveNumber(task.metadata[key]);
+}
+function buildTaskPrompt(task) {
+  const fileList = task.targetFiles.length > 0 ? task.targetFiles.join("\n") : "(none provided)";
+  return [
+    "You are implementing a scoped repository contribution task.",
+    `Task ID: ${task.id}`,
+    `Title: ${task.title}`,
+    `Source: ${task.source}`,
+    `Priority: ${task.priority}`,
+    `Complexity: ${task.complexity}`,
+    `Execution mode: ${task.executionMode}`,
+    "Description:",
+    task.description,
+    "Target files:",
+    fileList,
+    "Apply minimal, safe changes and ensure the repository remains buildable."
+  ].join("\n");
+}
+function stageFromEvent(event) {
+  switch (event.type) {
+    case "output":
+      return event.stream;
+    case "tokens":
+      return "tokens";
+    case "file_edit":
+      return `file:${event.action}`;
+    case "tool_use":
+      return `tool:${event.tool}`;
+    case "error":
+      return event.recoverable ? "agent-warning" : "agent-error";
+    default:
+      return "running";
+  }
+}
+function mergeExecutionResult(result, observedTokens, observedFiles, startedAt) {
+  for (const changedFile of result.filesChanged) {
+    observedFiles.add(changedFile);
+  }
+  return {
+    success: result.success,
+    exitCode: result.exitCode,
+    totalTokensUsed: Math.max(result.totalTokensUsed, observedTokens),
+    filesChanged: [...observedFiles],
+    duration: result.duration > 0 ? result.duration : Date.now() - startedAt,
+    error: result.error
+  };
+}
+function normalizeExecutionError(error, task, executionId) {
+  if (error instanceof OacError3) {
+    return error;
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  if (/timed out|timeout/i.test(message)) {
+    return executionError3("AGENT_TIMEOUT", `Task ${task.id} timed out during execution.`, {
+      context: {
+        taskId: task.id,
+        executionId,
+        message
+      },
+      cause: error
+    });
+  }
+  return executionError3("AGENT_EXECUTION_FAILED", `Task ${task.id} failed during execution.`, {
+    context: {
+      taskId: task.id,
+      executionId,
+      message
+    },
+    cause: error
+  });
+}
+async function executeTask(agent, task, sandbox, eventBus, options = {}) {
+  const executionId = options.executionId ?? randomUUID();
+  const tokenBudget = options.tokenBudget ?? readMetadataNumber(task, "tokenBudget") ?? DEFAULT_TOKEN_BUDGET;
+  const timeoutMs = options.timeoutMs ?? readMetadataNumber(task, "timeoutMs") ?? DEFAULT_TIMEOUT_MS;
+  const allowCommits = options.allowCommits ?? true;
+  const startedAt = Date.now();
+  let observedTokens = 0;
+  const observedFiles = /* @__PURE__ */ new Set();
+  const execution = agent.execute({
+    executionId,
+    workingDirectory: sandbox.path,
+    prompt: buildTaskPrompt(task),
+    targetFiles: task.targetFiles,
+    tokenBudget,
+    allowCommits,
+    timeoutMs
+  });
+  const streamPromise = (async () => {
+    for await (const event of execution.events) {
+      if (event.type === "tokens") {
+        observedTokens = Math.max(observedTokens, event.cumulativeTokens);
+      }
+      if (event.type === "file_edit") {
+        observedFiles.add(event.path);
+      }
+      eventBus.emit("execution:progress", {
+        jobId: executionId,
+        tokensUsed: observedTokens,
+        stage: stageFromEvent(event)
+      });
+    }
+  })();
+  try {
+    const result = await execution.result;
+    await streamPromise;
+    return mergeExecutionResult(result, observedTokens, observedFiles, startedAt);
+  } catch (error) {
+    try {
+      await streamPromise;
+    } catch {
+    }
+    throw normalizeExecutionError(error, task, executionId);
+  }
+}
+
+// src/engine.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { setTimeout as delay } from "timers/promises";
+import {
+  OacError as OacError4,
+  executionError as executionError4
+} from "@open330/oac-core";
+import PQueue from "p-queue";
+var DEFAULT_CONCURRENCY = 2;
+var DEFAULT_MAX_ATTEMPTS = 2;
+var DEFAULT_TIMEOUT_MS2 = 3e5;
+var DEFAULT_TOKEN_BUDGET2 = 5e4;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function toErrorMessage(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+function sanitizeBranchSegment(value) {
+  const sanitized = value.toLowerCase().replace(/[^a-z0-9/_-]+/g, "-").replace(/-+/g, "-").replace(/^[-/]+|[-/]+$/g, "");
+  return sanitized || "task";
+}
+function isTransientError(error) {
+  return error.code === "AGENT_TIMEOUT" || error.code === "AGENT_OOM" || error.code === "AGENT_RATE_LIMITED" || error.code === "NETWORK_ERROR" || error.code === "GIT_LOCK_FAILED";
+}
+var ExecutionEngine = class {
+  constructor(agents, eventBus, config = {}) {
+    this.agents = agents;
+    this.eventBus = eventBus;
+    if (agents.length === 0) {
+      throw executionError4(
+        "AGENT_NOT_AVAILABLE",
+        "ExecutionEngine requires at least one agent provider"
+      );
+    }
+    this.concurrency = Math.max(1, config.concurrency ?? DEFAULT_CONCURRENCY);
+    this.maxAttempts = Math.max(1, config.maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
+    this.repoPath = config.repoPath ?? process.cwd();
+    this.baseBranch = config.baseBranch ?? "main";
+    this.branchPrefix = config.branchPrefix ?? "oac";
+    this.taskTimeoutMs = Math.max(1, config.taskTimeoutMs ?? DEFAULT_TIMEOUT_MS2);
+    this.defaultTokenBudget = Math.max(1, config.defaultTokenBudget ?? DEFAULT_TOKEN_BUDGET2);
+    this.queue = new PQueue({
+      concurrency: this.concurrency,
+      autoStart: false
+    });
+  }
+  queue;
+  jobs = /* @__PURE__ */ new Map();
+  activeJobs = /* @__PURE__ */ new Map();
+  concurrency;
+  maxAttempts;
+  repoPath;
+  baseBranch;
+  branchPrefix;
+  taskTimeoutMs;
+  defaultTokenBudget;
+  aborted = false;
+  nextAgentIndex = 0;
+  enqueue(plan) {
+    const enqueuedJobs = [];
+    for (const { task, estimate } of plan.selectedTasks) {
+      const job = {
+        id: randomUUID2(),
+        task,
+        estimate,
+        status: "queued",
+        attempts: 0,
+        maxAttempts: this.maxAttempts,
+        createdAt: Date.now()
+      };
+      this.jobs.set(job.id, job);
+      enqueuedJobs.push(job);
+      this.schedule(job);
+    }
+    return enqueuedJobs;
+  }
+  async run() {
+    this.aborted = false;
+    this.queue.start();
+    await this.queue.onIdle();
+    return this.buildRunResult();
+  }
+  async abort() {
+    this.aborted = true;
+    this.queue.pause();
+    this.queue.clear();
+    const abortError = executionError4("AGENT_EXECUTION_FAILED", "Execution aborted by user.");
+    for (const job of this.jobs.values()) {
+      if (job.status === "queued" || job.status === "retrying") {
+        job.status = "aborted";
+        job.completedAt = Date.now();
+        job.error = abortError;
+      }
+    }
+    await Promise.all(
+      [...this.activeJobs.values()].map(async ({ job, agent }) => {
+        job.status = "aborted";
+        job.completedAt = Date.now();
+        job.error = abortError;
+        this.eventBus.emit("execution:failed", {
+          jobId: job.id,
+          error: abortError
+        });
+        try {
+          await agent.abort(job.id);
+        } catch {
+        }
+      })
+    );
+  }
+  schedule(job, delayMs = 0) {
+    void this.queue.add(
+      async () => {
+        if (delayMs > 0) {
+          await delay(delayMs);
+        }
+        await this.runJob(job);
+      },
+      { priority: job.task.priority }
+    ).catch((error) => {
+      const normalized = this.normalizeError(error, job);
+      job.status = "failed";
+      job.completedAt = Date.now();
+      job.error = normalized;
+      this.eventBus.emit("execution:failed", {
+        jobId: job.id,
+        error: normalized
+      });
+    });
+  }
+  async runJob(job) {
+    if (this.aborted || job.status === "aborted") {
+      return;
+    }
+    job.attempts += 1;
+    job.status = "running";
+    job.startedAt ??= Date.now();
+    const agent = this.selectAgent();
+    job.workerId = agent.id;
+    this.activeJobs.set(job.id, { job, agent });
+    this.eventBus.emit("execution:started", {
+      jobId: job.id,
+      task: job.task,
+      agent: agent.id
+    });
+    let sandboxCleanup;
+    try {
+      const branchName = this.createBranchName(job);
+      const sandbox = await createSandbox(this.repoPath, branchName, this.baseBranch);
+      sandboxCleanup = sandbox.cleanup;
+      const result = await executeTask(agent, job.task, sandbox, this.eventBus, {
+        executionId: job.id,
+        tokenBudget: job.estimate.totalEstimatedTokens > 0 ? job.estimate.totalEstimatedTokens : this.defaultTokenBudget,
+        timeoutMs: this.taskTimeoutMs,
+        allowCommits: true
+      });
+      job.result = result;
+      job.completedAt = Date.now();
+      if (result.success) {
+        job.status = "completed";
+        this.eventBus.emit("execution:completed", {
+          jobId: job.id,
+          result
+        });
+        return;
+      }
+      const failure = executionError4(
+        "AGENT_EXECUTION_FAILED",
+        result.error ?? `Task ${job.task.id} exited with code ${result.exitCode}.`,
+        {
+          context: {
+            taskId: job.task.id,
+            jobId: job.id,
+            exitCode: result.exitCode,
+            attempt: job.attempts
+          }
+        }
+      );
+      await this.handleFailure(job, failure);
+    } catch (error) {
+      const normalized = this.normalizeError(error, job);
+      await this.handleFailure(job, normalized);
+    } finally {
+      this.activeJobs.delete(job.id);
+      if (sandboxCleanup) {
+        try {
+          await sandboxCleanup();
+        } catch (cleanupError) {
+          const cleanupMessage = toErrorMessage(cleanupError);
+          job.error ??= executionError4(
+            "AGENT_EXECUTION_FAILED",
+            `Sandbox cleanup failed for job ${job.id}`,
+            {
+              context: {
+                jobId: job.id,
+                cleanupError: cleanupMessage
+              },
+              cause: cleanupError
+            }
+          );
+        }
+      }
+    }
+  }
+  async handleFailure(job, error) {
+    job.error = error;
+    if (this.aborted || job.status === "aborted") {
+      job.status = "aborted";
+      job.completedAt = Date.now();
+      return;
+    }
+    if (job.attempts < job.maxAttempts && isTransientError(error)) {
+      job.status = "retrying";
+      const retryDelay = error.code === "AGENT_RATE_LIMITED" ? Math.min(6e4, 1e4 * 2 ** (job.attempts - 1)) : Math.min(5e3, job.attempts * 1e3);
+      this.schedule(job, retryDelay);
+      return;
+    }
+    job.status = "failed";
+    job.completedAt = Date.now();
+    this.eventBus.emit("execution:failed", {
+      jobId: job.id,
+      error
+    });
+  }
+  selectAgent() {
+    const agent = this.agents[this.nextAgentIndex % this.agents.length];
+    this.nextAgentIndex = (this.nextAgentIndex + 1) % this.agents.length;
+    return agent;
+  }
+  createBranchName(job) {
+    const dateSegment = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replaceAll("-", "");
+    const taskSegment = sanitizeBranchSegment(job.task.id);
+    return `${this.branchPrefix}/${dateSegment}/${taskSegment}-${job.id.slice(0, 8)}-a${job.attempts}`;
+  }
+  normalizeError(error, job) {
+    if (error instanceof OacError4) {
+      return error;
+    }
+    const message = toErrorMessage(error);
+    if (/timed out|timeout/i.test(message)) {
+      return executionError4("AGENT_TIMEOUT", `Job ${job.id} timed out.`, {
+        context: {
+          jobId: job.id,
+          taskId: job.task.id,
+          message,
+          attempt: job.attempts
+        },
+        cause: error
+      });
+    }
+    if (/out of memory|ENOMEM|heap/i.test(message)) {
+      return executionError4("AGENT_OOM", `Job ${job.id} ran out of memory.`, {
+        context: {
+          jobId: job.id,
+          taskId: job.task.id,
+          message,
+          attempt: job.attempts
+        },
+        cause: error
+      });
+    }
+    if (/network|ECONN|ENOTFOUND|EAI_AGAIN/i.test(message)) {
+      return new OacError4(
+        `Job ${job.id} failed due to a network error.`,
+        "NETWORK_ERROR",
+        "recoverable",
+        {
+          jobId: job.id,
+          taskId: job.task.id,
+          message,
+          attempt: job.attempts
+        },
+        error
+      );
+    }
+    if (/index\.lock|cannot lock ref|Unable to create '.+?\.git\/index\.lock'/i.test(message)) {
+      return new OacError4(
+        `Job ${job.id} failed due to a git lock conflict.`,
+        "GIT_LOCK_FAILED",
+        "recoverable",
+        {
+          jobId: job.id,
+          taskId: job.task.id,
+          message,
+          attempt: job.attempts
+        },
+        error
+      );
+    }
+    if (isRecord3(error) && error.name === "AbortError") {
+      return executionError4("AGENT_EXECUTION_FAILED", `Job ${job.id} was aborted.`, {
+        context: {
+          jobId: job.id,
+          taskId: job.task.id,
+          attempt: job.attempts
+        },
+        cause: error
+      });
+    }
+    return executionError4("AGENT_EXECUTION_FAILED", `Job ${job.id} failed unexpectedly.`, {
+      context: {
+        jobId: job.id,
+        taskId: job.task.id,
+        message,
+        attempt: job.attempts
+      },
+      cause: error
+    });
+  }
+  buildRunResult() {
+    const jobs = [...this.jobs.values()];
+    return {
+      jobs,
+      completed: jobs.filter((job) => job.status === "completed"),
+      failed: jobs.filter((job) => job.status === "failed"),
+      aborted: jobs.filter((job) => job.status === "aborted")
+    };
+  }
+};
+export {
+  ClaudeCodeAdapter,
+  CodexAdapter,
+  ExecutionEngine,
+  createSandbox,
+  executeTask,
+  isTransientError
+};
+//# sourceMappingURL=index.js.map