@kitsy/coop-ai 0.0.1 → 2.0.0

package/dist/index.js

@@ -1,8 +1,988 @@
-// src/index.ts
-var coopAiRuntime = {
-  package: "@kitsy/coop-ai",
-  status: "planned"
+// src/contracts/contract-builder.ts
+var DEFAULT_FORBIDDEN_COMMANDS = ["rm -rf", "git push", "deploy"];
+var DEFAULT_OUTPUT_REQUIREMENTS = [
+  "All changes on a feature branch",
+  "PR description with acceptance criteria mapping",
+  "Test coverage report"
+];
+function asRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+function asStringArray(value) {
+  if (!Array.isArray(value)) return null;
+  const out = value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+  return out;
+}
+function asBoolean(value, fallback) {
+  if (typeof value === "boolean") return value;
+  return fallback;
+}
+function asFiniteNumber(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+function normalizePath(input) {
+  const collapsed = input.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\.\//, "").replace(/\/$/, "").trim();
+  return collapsed.length > 0 ? collapsed : ".";
+}
+function isSubPath(candidate, parent) {
+  const pathValue = normalizePath(candidate);
+  const parentValue = normalizePath(parent);
+  if (parentValue === "." || parentValue === "") return true;
+  return pathValue === parentValue || pathValue.startsWith(`${parentValue}/`);
+}
+function normalizeCommand(command) {
+  return command.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function commandMatchesRule(command, rule) {
+  const normalizedCommand = normalizeCommand(command);
+  const normalizedRule = normalizeCommand(rule);
+  return normalizedCommand === normalizedRule || normalizedCommand.startsWith(`${normalizedRule} `);
+}
+function dedupe(values) {
+  return Array.from(new Set(values));
+}
+function taskAcceptance(task) {
+  const maybe = asRecord(task).acceptance;
+  return asStringArray(maybe) ?? [];
+}
+function collectRelatedArtifacts(task, graph) {
+  const context = asRecord(task.execution?.context ?? {});
+  const relatedTaskIds = dedupe(asStringArray(context.tasks) ?? []);
+  const artifacts = [];
+  for (const taskId of relatedTaskIds) {
+    const related = graph.nodes.get(taskId);
+    if (!related) continue;
+    const produces = related.artifacts?.produces ?? [];
+    artifacts.push({
+      task_id: related.id,
+      artifacts: produces.map((artifact) => ({
+        type: artifact.type,
+        target: artifact.target,
+        path: artifact.path
+      }))
+    });
+  }
+  return artifacts;
+}
+function computeGoal(task) {
+  const acceptance = taskAcceptance(task);
+  if (acceptance.length === 0) {
+    return task.title.trim();
+  }
+  return `${task.title.trim()}. Acceptance criteria: ${acceptance.join("; ")}`;
+}
+function readAiConfig(config) {
+  const root = asRecord(config);
+  const ai = asRecord(root.ai);
+  const permissions = asRecord(ai.permissions);
+  const constraints = asRecord(ai.constraints);
+  const default_executor = typeof ai.default_executor === "string" && ai.default_executor.trim().length > 0 ? ai.default_executor.trim() : "claude-sonnet";
+  const token_budget_per_task = asFiniteNumber(ai.token_budget_per_task) ?? 5e4;
+  return {
+    default_executor,
+    token_budget_per_task,
+    permissions,
+    constraints
+  };
+}
+function validateContract(contract) {
+  if (contract.constraints.max_tokens <= 0) {
+    throw new Error("Invalid contract: constraints.max_tokens must be positive.");
+  }
+  for (const writePath of contract.permissions.write_paths) {
+    const allowed = contract.permissions.read_paths.some(
+      (readPath) => isSubPath(writePath, readPath)
+    );
+    if (!allowed) {
+      throw new Error(
+        `Invalid contract: write path '${writePath}' is outside declared read paths.`
+      );
+    }
+  }
+}
+function build_contract(task, graph, config) {
+  const ai = readAiConfig(config);
+  const execution = task.execution;
+  const executionContext = asRecord(execution?.context ?? {});
+  const defaultReadPaths = asStringArray(ai.permissions.read_paths) ?? ["."];
+  const defaultWritePaths = asStringArray(ai.permissions.write_paths) ?? defaultReadPaths;
+  const defaultAllowedCommands = asStringArray(ai.permissions.allowed_commands) ?? [];
+  const defaultForbiddenCommands = asStringArray(ai.permissions.forbidden_commands) ?? DEFAULT_FORBIDDEN_COMMANDS;
+  const read_paths = dedupe(
+    (execution?.permissions?.read_paths ?? defaultReadPaths).map((entry) => normalizePath(entry))
+  );
+  const write_paths = dedupe(
+    (execution?.permissions?.write_paths ?? defaultWritePaths).map((entry) => normalizePath(entry))
+  );
+  const forbidden_commands = dedupe(
+    (execution?.permissions?.forbidden_commands ?? defaultForbiddenCommands).map(
+      (entry) => entry.trim()
+    )
+  );
+  const candidate_allowed = dedupe(
+    (execution?.permissions?.allowed_commands ?? defaultAllowedCommands).map(
+      (entry) => entry.trim()
+    )
+  );
+  const allowed_commands = candidate_allowed.filter(
+    (allowed) => !forbidden_commands.some((forbidden) => commandMatchesRule(allowed, forbidden))
+  );
+  const constraintsConfig = ai.constraints;
+  const max_tokens = execution?.constraints?.max_tokens ?? asFiniteNumber(constraintsConfig.max_tokens) ?? ai.token_budget_per_task;
+  const max_duration_minutes = execution?.constraints?.max_duration_minutes ?? asFiniteNumber(constraintsConfig.max_duration_minutes) ?? 30;
+  const max_file_changes = execution?.constraints?.max_file_changes ?? asFiniteNumber(constraintsConfig.max_file_changes) ?? 20;
+  const require_tests = asBoolean(
+    execution?.constraints?.require_tests ?? constraintsConfig.require_tests,
+    true
+  );
+  const taskContextPaths = asStringArray(executionContext.paths) ?? [];
+  const taskContextFiles = asStringArray(executionContext.files) ?? [];
+  const taskContextTasks = asStringArray(executionContext.tasks) ?? [];
+  const acceptance_criteria = taskAcceptance(task);
+  const related_task_artifacts = collectRelatedArtifacts(task, graph);
+  const output_requirements = [
+    ...DEFAULT_OUTPUT_REQUIREMENTS,
+    ...(task.artifacts?.produces ?? []).map((artifact) => {
+      if (artifact.path) {
+        return `Produce ${artifact.type} artifact at ${artifact.path}`;
+      }
+      if (artifact.target) {
+        return `Produce ${artifact.type} artifact targeting ${artifact.target}`;
+      }
+      return `Produce ${artifact.type} artifact`;
+    })
+  ];
+  const contract = {
+    task_id: task.id,
+    goal: computeGoal(task),
+    executor: execution?.agent ?? ai.default_executor,
+    permissions: {
+      read_paths,
+      write_paths,
+      allowed_commands,
+      forbidden_commands
+    },
+    constraints: {
+      max_tokens,
+      max_duration_minutes,
+      max_file_changes,
+      require_tests
+    },
+    context: {
+      paths: taskContextPaths,
+      files: taskContextFiles,
+      tasks: taskContextTasks,
+      acceptance_criteria,
+      related_task_artifacts
+    },
+    output_requirements
+  };
+  validateContract(contract);
+  return contract;
+}
+
+// src/routing/router.ts
+function asRecord2(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+function readRoutingConfig(config) {
+  const root = asRecord2(config);
+  const ai = asRecord2(root.ai);
+  const routing = asRecord2(ai.routing);
+  const defaultAgent = typeof routing.default_agent === "string" && routing.default_agent.trim() || typeof ai.default_executor === "string" && ai.default_executor.trim() || "claude-sonnet";
+  const reviewAgent = typeof routing.review_agent === "string" && routing.review_agent.trim() || defaultAgent;
+  const complexAgent = typeof routing.complex_agent === "string" && routing.complex_agent.trim() || typeof routing.opus_agent === "string" && routing.opus_agent.trim() || "claude-opus";
+  return {
+    default_agent: defaultAgent,
+    review_agent: reviewAgent,
+    complex_agent: complexAgent
+  };
+}
+function select_agent(task, config) {
+  if (task.execution?.agent && task.execution.agent.trim().length > 0) {
+    return task.execution.agent.trim();
+  }
+  const routing = readRoutingConfig(config);
+  if (task.complexity === "large" || task.complexity === "unknown" || task.type === "spike") {
+    return routing.complex_agent;
+  }
+  const hasReviewStep = (task.execution?.runbook ?? []).some((step) => step.action === "review");
+  if (hasReviewStep) {
+    return routing.review_agent;
+  }
+  return routing.default_agent;
+}
+
+// src/sandbox/sandbox.ts
+function normalizePath2(input) {
+  const collapsed = input.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\.\//, "").replace(/\/$/, "").trim();
+  return collapsed.length > 0 ? collapsed : ".";
+}
+function isSubPath2(candidate, parent) {
+  const pathValue = normalizePath2(candidate);
+  const parentValue = normalizePath2(parent);
+  if (parentValue === "." || parentValue === "") return true;
+  return pathValue === parentValue || pathValue.startsWith(`${parentValue}/`);
+}
+function normalizeCommand2(command) {
+  return command.trim().replace(/\s+/g, " ").toLowerCase();
+}
+function commandMatchesRule2(command, rule) {
+  const normalizedCommand = normalizeCommand2(command);
+  const normalizedRule = normalizeCommand2(rule);
+  return normalizedCommand === normalizedRule || normalizedCommand.startsWith(`${normalizedRule} `);
+}
+function hasBlockedShellSyntax(command) {
+  return /(\|\||&&|[|;]|`|\$\()/.test(command);
+}
+function validate_command(command, contract) {
+  if (!command || command.trim().length === 0) return false;
+  if (hasBlockedShellSyntax(command)) return false;
+  if (contract.permissions.forbidden_commands.some((rule) => commandMatchesRule2(command, rule))) {
+    return false;
+  }
+  const allowed = contract.permissions.allowed_commands;
+  if (allowed.length === 0) {
+    return true;
+  }
+  return allowed.some((rule) => commandMatchesRule2(command, rule));
+}
+function validate_file_access(pathValue, mode, contract) {
+  if (!pathValue || pathValue.trim().length === 0) return false;
+  const normalized = normalizePath2(pathValue);
+  const canRead = contract.permissions.read_paths.some((readPath) => isSubPath2(normalized, readPath));
+  if (!canRead) return false;
+  if (mode === "read") return true;
+  return contract.permissions.write_paths.some((writePath) => isSubPath2(normalized, writePath));
+}
+function constraint_violation_reasons(runState, contract) {
+  const reasons = [];
+  if (runState.tokens_used > contract.constraints.max_tokens) {
+    reasons.push("token budget exceeded");
+  }
+  if (runState.duration_minutes > contract.constraints.max_duration_minutes) {
+    reasons.push("duration limit exceeded");
+  }
+  if (runState.file_changes > contract.constraints.max_file_changes) {
+    reasons.push("file change limit exceeded");
+  }
+  return reasons;
+}
+function enforce_constraints(runState, contract) {
+  return constraint_violation_reasons(runState, contract).length === 0;
+}
+
+// src/logging/run-logger.ts
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+import { writeYamlFile } from "@kitsy/coop-core";
+function randomSuffix() {
+  return crypto.randomBytes(2).toString("hex").toUpperCase();
+}
+function compactDateToken(now) {
+  return now.toISOString().replace(/[-:]/g, "").slice(0, 15);
+}
+function generateRunId(now) {
+  return `RUN-${compactDateToken(now)}-${randomSuffix()}`;
+}
+function cloneRun(run) {
+  return {
+    ...run,
+    steps: run.steps.map((step) => ({ ...step })),
+    resources_consumed: { ...run.resources_consumed }
+  };
+}
+function create_run(task, executor, now = /* @__PURE__ */ new Date()) {
+  return {
+    id: generateRunId(now),
+    task: task.id,
+    executor,
+    status: "running",
+    started: now.toISOString(),
+    steps: [],
+    resources_consumed: {
+      ai_tokens: 0,
+      compute_minutes: 0,
+      file_changes: 0
+    }
+  };
+}
+function log_step(run, step) {
+  const next = cloneRun(run);
+  next.steps.push({ ...step });
+  return next;
+}
+function finalize_run(run, status, now = /* @__PURE__ */ new Date()) {
+  const next = cloneRun(run);
+  next.status = status;
+  next.completed = now.toISOString();
+  return next;
+}
+function write_run(run, coopDir) {
+  const runsDir = path.join(coopDir, "runs");
+  fs.mkdirSync(runsDir, { recursive: true });
+  const filePath = path.join(runsDir, `${run.id}.yml`);
+  writeYamlFile(filePath, run);
+  return filePath;
+}
+
+// src/executor/executor.ts
+import { spawnSync } from "child_process";
+import path2 from "path";
+function defaultAgentClient() {
+  return {
+    async generate(input) {
+      const tokenEstimate = Math.max(1, Math.ceil(input.prompt.length / 4));
+      return {
+        summary: `Generated draft for '${input.step.step}'.`,
+        tokens_used: tokenEstimate,
+        file_changes: 0
+      };
+    },
+    async review(input) {
+      const tokenEstimate = Math.max(1, Math.ceil(input.prompt.length / 6));
+      return {
+        summary: `AI review for '${input.step.step}' completed.`,
+        tokens_used: tokenEstimate,
+        file_changes: 0
+      };
+    }
+  };
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function durationSeconds(startMs) {
+  return Math.max(0, Math.round((Date.now() - startMs) / 1e3));
+}
+function countChangedFiles(repoRoot) {
+  const result = spawnSync("git", ["status", "--porcelain"], {
+    cwd: repoRoot,
+    encoding: "utf8",
+    windowsHide: true
+  });
+  if ((result.status ?? 1) !== 0) {
+    return 0;
+  }
+  return (result.stdout ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).length;
+}
+function executeCommand(command, repoRoot) {
+  const result = spawnSync(command, {
+    cwd: repoRoot,
+    shell: true,
+    encoding: "utf8",
+    windowsHide: true
+  });
+  const stdout = (result.stdout ?? "").trim();
+  const stderr = (result.stderr ?? "").trim();
+  const exitCode = result.status ?? 1;
+  const summary = [stdout, stderr].filter(Boolean).join("\n").trim();
+  return {
+    ok: exitCode === 0,
+    summary: summary || `Command exited with code ${exitCode}.`,
+    exitCode
+  };
+}
+function buildPrompt(task, contract, stepId, description) {
+  const sections = [
+    `Task: ${task.id}`,
+    `Goal: ${contract.goal}`,
+    `Step: ${stepId}`,
+    description ? `Description: ${description}` : "",
+    contract.context.acceptance_criteria.length > 0 ? `Acceptance: ${contract.context.acceptance_criteria.join(" | ")}` : "",
+    contract.context.paths.length > 0 ? `Context paths: ${contract.context.paths.join(", ")}` : "",
+    contract.context.files.length > 0 ? `Context files: ${contract.context.files.join(", ")}` : ""
+  ].filter(Boolean);
+  return sections.join("\n");
+}
+async function execute_task(task, contract, _graph, options = {}) {
+  const runbook = task.execution?.runbook ?? [];
+  if (runbook.length === 0) {
+    throw new Error(`Task '${task.id}' has no execution.runbook steps.`);
+  }
+  const selectedSteps = options.step ? runbook.filter((step) => step.step === options.step) : runbook;
+  if (selectedSteps.length === 0) {
+    throw new Error(`Step '${options.step}' not found in task '${task.id}'.`);
+  }
+  const repoRoot = options.repo_root ?? process.cwd();
+  const coopDir = options.coop_dir ?? path2.join(repoRoot, ".coop");
+  const onProgress = options.on_progress ?? (() => {
+  });
+  const agent = options.agent_client ?? defaultAgentClient();
+  const runState = {
+    tokens_used: 0,
+    duration_minutes: 0,
+    file_changes: countChangedFiles(repoRoot)
+  };
+  let run = create_run(task, contract.executor);
+  let finalStatus = "running";
+  for (const step of selectedSteps) {
+    const started = nowIso();
+    const startMs = Date.now();
+    onProgress(`Running step '${step.step}' (${step.action})...`);
+    let stepStatus = "completed";
+    let outputSummary = "";
+    let notes;
+    let exitCode;
+    let stepTokens = 0;
+    if (step.action === "run" || step.action === "test") {
+      if (!step.command) {
+        throw new Error(`Step '${step.step}' requires a command for action '${step.action}'.`);
+      }
+      if (!validate_command(step.command, contract)) {
+        stepStatus = "failed";
+        outputSummary = `Command rejected by sandbox: ${step.command}`;
+      } else {
+        const command = executeCommand(step.command, repoRoot);
+        stepStatus = command.ok ? "completed" : "failed";
+        outputSummary = command.summary;
+        exitCode = command.exitCode;
+      }
+    } else if (step.action === "generate") {
+      const prompt = buildPrompt(task, contract, step.step, step.description ?? "");
+      const response = await agent.generate({ task, step, contract, prompt });
+      stepTokens = response.tokens_used ?? 0;
+      runState.tokens_used += stepTokens;
+      outputSummary = response.summary;
+      runState.file_changes += response.file_changes ?? 0;
+    } else if (step.action === "review") {
+      if ((step.reviewer ?? "human") === "human") {
+        stepStatus = "paused";
+        notes = "Waiting for human reviewer.";
+        outputSummary = notes;
+      } else {
+        const prompt = buildPrompt(task, contract, step.step, step.description ?? "Perform review");
+        const response = await agent.review({ task, step, contract, prompt });
+        stepTokens = response.tokens_used ?? 0;
+        runState.tokens_used += stepTokens;
+        outputSummary = response.summary;
+      }
+    } else {
+      stepStatus = "failed";
+      outputSummary = `Unsupported action '${step.action}'.`;
+    }
+    const duration = durationSeconds(startMs);
+    runState.duration_minutes += duration / 60;
+    runState.file_changes = Math.max(runState.file_changes, countChangedFiles(repoRoot));
+    const stepResult = {
+      step: step.step,
+      action: step.action,
+      status: stepStatus,
+      started,
+      completed: nowIso(),
+      duration_seconds: duration,
+      output_summary: outputSummary,
+      reviewer: step.reviewer,
+      notes,
+      exit_code: exitCode,
+      tokens_used: stepTokens || void 0
+    };
+    run = log_step(run, stepResult);
+    run.resources_consumed.ai_tokens = runState.tokens_used;
+    run.resources_consumed.compute_minutes = Number(runState.duration_minutes.toFixed(2));
+    run.resources_consumed.file_changes = runState.file_changes;
+    if (!enforce_constraints(runState, contract)) {
+      finalStatus = "paused";
+      const reasons = constraint_violation_reasons(runState, contract);
+      run = log_step(run, {
+        step: `${step.step}-constraint-check`,
+        action: "constraint",
+        status: "paused",
+        started: nowIso(),
+        completed: nowIso(),
+        duration_seconds: 0,
+        notes: reasons.join("; "),
+        output_summary: reasons.join("; ")
+      });
+      break;
+    }
+    if (stepStatus === "failed") {
+      finalStatus = "failed";
+      break;
+    }
+    if (stepStatus === "paused") {
+      finalStatus = "paused";
+      break;
+    }
+  }
+  if (finalStatus === "running") {
+    finalStatus = "completed";
+  }
+  run = finalize_run(run, finalStatus);
+  const logPath = write_run(run, coopDir);
+  return {
+    status: finalStatus,
+    run,
+    log_path: logPath
+  };
+}
+
+// src/decomposition/decompose.ts
+function nonEmptyLines(input) {
+  return input.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+}
+function extractBulletIdeas(body) {
+  const lines = nonEmptyLines(body);
+  return lines.filter((line) => /^[-*]\s+/.test(line)).map((line) => line.replace(/^[-*]\s+/, "").trim()).filter(Boolean).slice(0, 5);
+}
+function sentenceCase(value) {
+  if (value.length === 0) return value;
+  return `${value[0]?.toUpperCase() ?? ""}${value.slice(1)}`;
+}
+function defaultDecomposition(input) {
+  const bullets = extractBulletIdeas(input.body);
+  if (bullets.length > 0) {
+    return bullets.slice(0, 3).map((bullet, index) => ({
+      title: sentenceCase(bullet),
+      body: `Derived from idea ${input.idea_id}: ${input.title}`,
+      type: index === 0 ? "spike" : "feature",
+      priority: index === 0 ? "p1" : "p2",
+      track: "unassigned"
+    }));
+  }
+  return [
+    {
+      title: `Define scope and acceptance for ${input.title}`,
+      body: `Derived from idea ${input.idea_id}. Capture constraints and success criteria.`,
+      type: "spike",
+      priority: "p1",
+      track: "unassigned"
+    },
+    {
+      title: `Implement ${input.title}`,
+      body: `Derived from idea ${input.idea_id}. Build the primary functionality.`,
+      type: "feature",
+      priority: "p1",
+      track: "unassigned"
+    },
+    {
+      title: `Validate and rollout ${input.title}`,
+      body: `Derived from idea ${input.idea_id}. Add tests and release checklist.`,
+      type: "chore",
+      priority: "p2",
+      track: "unassigned"
+    }
+  ];
+}
+function build_decomposition_prompt(input) {
+  return [
+    "You are a planning agent for COOP.",
+    "Decompose the idea into 2-5 implementation tasks.",
+    "Each task needs: title, type(feature|bug|chore|spike), priority(p0-p3), and body.",
+    `Idea ID: ${input.idea_id}`,
+    `Title: ${input.title}`,
+    "Body:",
+    input.body || "(empty)"
+  ].join("\n");
+}
+async function decompose_idea_to_tasks(input, client) {
+  const prompt = build_decomposition_prompt(input);
+  if (!client) {
+    return defaultDecomposition(input);
+  }
+  const drafts = await client.decompose(prompt, input);
+  if (!Array.isArray(drafts) || drafts.length === 0) {
+    return defaultDecomposition(input);
+  }
+  return drafts;
+}
+
+// src/providers/config.ts
+var DEFAULT_MODELS = {
+  openai: "gpt-5-mini",
+  anthropic: "claude-3-5-sonnet-latest",
+  gemini: "gemini-2.0-flash",
+  ollama: "llama3.2"
 };
+var DEFAULT_KEY_ENV = {
+  openai: "OPENAI_API_KEY",
+  anthropic: "ANTHROPIC_API_KEY",
+  gemini: "GEMINI_API_KEY"
+};
+var DEFAULT_BASE_URL = {
+  openai: "https://api.openai.com/v1",
+  anthropic: "https://api.anthropic.com/v1",
+  gemini: "https://generativelanguage.googleapis.com/v1beta",
+  ollama: "http://localhost:11434"
+};
+function asRecord3(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return {};
+  }
+  return value;
+}
+function asString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function asFinite(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+function readProvider(value) {
+  const normalized = asString(value)?.toLowerCase();
+  if (normalized === "openai" || normalized === "anthropic" || normalized === "gemini" || normalized === "ollama" || normalized === "mock") {
+    return normalized;
+  }
+  return "mock";
+}
+function lookupProviderSection(ai, provider) {
+  return asRecord3(ai[provider]);
+}
+function resolve_provider_config(config) {
+  const root = asRecord3(config);
+  const ai = asRecord3(root.ai);
+  const provider = readProvider(ai.provider);
+  if (provider === "mock") {
+    return {
+      provider,
+      model: "mock-local",
+      temperature: 0.2,
+      max_output_tokens: 1024,
+      timeout_ms: 6e4
+    };
+  }
+  const section = lookupProviderSection(ai, provider);
+  const model = asString(section.model) ?? asString(ai.model) ?? DEFAULT_MODELS[provider];
+  const base_url = asString(section.base_url) ?? asString(ai.base_url) ?? DEFAULT_BASE_URL[provider];
+  const temperature = asFinite(section.temperature) ?? asFinite(ai.temperature) ?? 0.2;
+  const max_output_tokens = asFinite(section.max_output_tokens) ?? asFinite(ai.max_output_tokens) ?? 1024;
+  const timeout_ms = asFinite(section.timeout_ms) ?? asFinite(ai.timeout_ms) ?? 6e4;
+  let api_key;
+  if (provider !== "ollama") {
+    const envName = asString(section.api_key_env) ?? asString(ai.api_key_env) ?? DEFAULT_KEY_ENV[provider];
+    const envValue = envName ? asString(process.env[envName]) : null;
+    api_key = asString(section.api_key) ?? asString(ai.api_key) ?? envValue ?? void 0;
+    if (!api_key) {
+      throw new Error(
+        `Missing API key for provider '${provider}'. Set ${envName ?? "the configured api_key_env"} or ai.${provider}.api_key.`
+      );
+    }
+  }
+  return {
+    provider,
+    model,
+    base_url,
+    api_key,
+    temperature,
+    max_output_tokens,
+    timeout_ms
+  };
+}
+
+// src/providers/http.ts
+async function post_json(url, init) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Math.max(1, init.timeout_ms));
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        ...init.headers ?? {}
+      },
+      body: JSON.stringify(init.body),
+      signal: controller.signal
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      throw new Error(`Provider HTTP ${response.status}: ${text.slice(0, 500)}`);
+    }
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Provider returned invalid JSON: ${message}`);
+    }
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// src/providers/anthropic.ts
+var AnthropicProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  name = "anthropic";
+  async complete(input) {
+    const base = this.config.base_url ?? "https://api.anthropic.com/v1";
+    const json = await post_json(`${base}/messages`, {
+      headers: {
+        "x-api-key": this.config.api_key ?? "",
+        "anthropic-version": "2023-06-01"
+      },
+      body: {
+        model: this.config.model,
+        max_tokens: this.config.max_output_tokens,
+        temperature: this.config.temperature,
+        system: input.system,
+        messages: [{ role: "user", content: input.prompt }]
+      },
+      timeout_ms: this.config.timeout_ms
+    });
+    const text = (json.content ?? []).filter((part) => part.type === "text" && typeof part.text === "string").map((part) => part.text?.trim() ?? "").filter(Boolean).join("\n").trim();
+    if (!text) {
+      throw new Error("Anthropic response did not include completion text.");
+    }
+    const tokens = (json.usage?.input_tokens ?? 0) + (json.usage?.output_tokens ?? 0);
+    return {
+      text,
+      total_tokens: tokens > 0 ? tokens : void 0
+    };
+  }
+};
+
+// src/providers/gemini.ts
+var GeminiProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  name = "gemini";
+  async complete(input) {
+    const base = this.config.base_url ?? "https://generativelanguage.googleapis.com/v1beta";
+    const key = this.config.api_key ?? "";
+    const model = encodeURIComponent(this.config.model);
+    const json = await post_json(`${base}/models/${model}:generateContent?key=${key}`, {
+      body: {
+        systemInstruction: {
+          parts: [{ text: input.system }]
+        },
+        generationConfig: {
+          temperature: this.config.temperature,
+          maxOutputTokens: this.config.max_output_tokens
+        },
+        contents: [
+          {
+            role: "user",
+            parts: [{ text: input.prompt }]
+          }
+        ]
+      },
+      timeout_ms: this.config.timeout_ms
+    });
+    const text = (json.candidates?.[0]?.content?.parts ?? []).map((part) => part.text?.trim() ?? "").filter(Boolean).join("\n").trim();
+    if (!text) {
+      throw new Error("Gemini response did not include completion text.");
+    }
+    return {
+      text,
+      total_tokens: json.usageMetadata?.totalTokenCount
+    };
+  }
+};
+
+// src/providers/mock.ts
+var MockProvider = class {
+  name = "mock";
+  async complete(input) {
+    const preview = input.prompt.trim().split(/\r?\n/).slice(0, 3).join(" ").slice(0, 120);
+    const text = `MOCK_RESPONSE: ${preview}`;
+    return {
+      text,
+      total_tokens: Math.max(1, Math.ceil((input.system.length + input.prompt.length) / 4))
+    };
+  }
+};
+
+// src/providers/ollama.ts
+var OllamaProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  name = "ollama";
+  async complete(input) {
+    const base = this.config.base_url ?? "http://localhost:11434";
+    const json = await post_json(`${base}/api/chat`, {
+      body: {
+        model: this.config.model,
+        stream: false,
+        options: {
+          temperature: this.config.temperature,
+          num_predict: this.config.max_output_tokens
+        },
+        messages: [
+          { role: "system", content: input.system },
+          { role: "user", content: input.prompt }
+        ]
+      },
+      timeout_ms: this.config.timeout_ms
+    });
+    const text = json.message?.content?.trim();
+    if (!text) {
+      throw new Error("Ollama response did not include completion text.");
+    }
+    const tokens = (json.prompt_eval_count ?? 0) + (json.eval_count ?? 0);
+    return {
+      text,
+      total_tokens: tokens > 0 ? tokens : void 0
+    };
+  }
+};
+
+// src/providers/openai.ts
+var OpenAiProvider = class {
+  constructor(config) {
+    this.config = config;
+  }
+  name = "openai";
+  async complete(input) {
+    const base = this.config.base_url ?? "https://api.openai.com/v1";
+    const json = await post_json(`${base}/chat/completions`, {
+      headers: {
+        authorization: `Bearer ${this.config.api_key ?? ""}`
+      },
+      body: {
+        model: this.config.model,
+        temperature: this.config.temperature,
+        max_tokens: this.config.max_output_tokens,
+        messages: [
+          { role: "system", content: input.system },
+          { role: "user", content: input.prompt }
+        ]
+      },
+      timeout_ms: this.config.timeout_ms
+    });
+    const text = json.choices?.[0]?.message?.content?.trim();
+    if (!text) {
+      throw new Error("OpenAI response did not include completion text.");
+    }
+    return {
+      text,
+      total_tokens: json.usage?.total_tokens
+    };
+  }
+};
+
+// src/providers/factory.ts
+function create_provider(config) {
+  const resolved = resolve_provider_config(config);
+  switch (resolved.provider) {
+    case "openai":
+      return new OpenAiProvider(resolved);
+    case "anthropic":
+      return new AnthropicProvider(resolved);
+    case "gemini":
+      return new GeminiProvider(resolved);
+    case "ollama":
+      return new OllamaProvider(resolved);
+    case "mock":
+    default:
+      return new MockProvider();
+  }
+}
+
+// src/providers/provider-client.ts
+function parseJsonArray(text) {
+  const trimmed = text.trim();
+  try {
+    const direct = JSON.parse(trimmed);
+    if (Array.isArray(direct)) return direct;
+  } catch {
+  }
+  const fence = trimmed.match(/```json\s*([\s\S]*?)```/i);
+  if (fence?.[1]) {
+    try {
+      const parsed = JSON.parse(fence[1]);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  const start = trimmed.indexOf("[");
+  const end = trimmed.lastIndexOf("]");
+  if (start >= 0 && end > start) {
+    const candidate = trimmed.slice(start, end + 1);
+    try {
+      const parsed = JSON.parse(candidate);
+      if (Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+function toTaskDrafts(value) {
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) continue;
+    const record = entry;
+    const title = typeof record.title === "string" ? record.title.trim() : "";
+    if (!title) continue;
+    out.push({
+      title,
+      body: typeof record.body === "string" ? record.body : void 0,
+      type: record.type === "feature" || record.type === "bug" || record.type === "chore" || record.type === "spike" ? record.type : void 0,
+      priority: record.priority === "p0" || record.priority === "p1" || record.priority === "p2" || record.priority === "p3" ? record.priority : void 0,
+      track: typeof record.track === "string" ? record.track : void 0
+    });
+  }
+  return out;
+}
+function asAgentResponse(text, tokens) {
+  return {
+    summary: text.trim(),
+    tokens_used: tokens
+  };
+}
+function create_provider_agent_client(config) {
+  const provider = create_provider(config);
+  return {
+    async generate(input) {
+      const result = await provider.complete({
+        system: "You are an implementation agent. Return a concise execution summary for the requested step.",
+        prompt: input.prompt
+      });
+      return asAgentResponse(result.text, result.total_tokens);
+    },
+    async review(input) {
+      const result = await provider.complete({
+        system: "You are a code-review agent. Return concise review findings, risks, and verdict.",
+        prompt: input.prompt
+      });
+      return asAgentResponse(result.text, result.total_tokens);
+    }
+  };
+}
+function create_provider_idea_decomposer(config) {
+  const provider = create_provider(config);
+  return {
+    async decompose(prompt) {
+      const result = await provider.complete({
+        system: "Return ONLY JSON array. Each item must include title, type, priority, body, track.",
+        prompt
+      });
+      const parsed = parseJsonArray(result.text);
+      if (!parsed) {
+        return [];
+      }
+      return toTaskDrafts(parsed);
+    }
+  };
+}
 export {
-  coopAiRuntime
+  build_contract,
+  build_decomposition_prompt,
+  constraint_violation_reasons,
+  create_provider,
+  create_provider_agent_client,
+  create_provider_idea_decomposer,
+  create_run,
+  decompose_idea_to_tasks,
+  enforce_constraints,
+  execute_task,
+  finalize_run,
+  log_step,
+  resolve_provider_config,
+  select_agent,
+  validate_command,
+  validate_file_access,
+  write_run
 };