@ryanfw/prompt-orchestration-pipeline 1.3.0 → 1.3.2

package/src/harness/__tests__/resolve.test.ts

@@ -1,200 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtempSync, writeFileSync, chmodSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  healedPath,
-  binEnvVar,
-  harnessBinName,
-  resolveHarnessBinary,
-  discoverHarnesses,
-  applyHarnessDiscovery,
-} from "../resolve.ts";
-import { DESCRIPTORS } from "../descriptors/index.ts";
-import type { HarnessDescriptor, HarnessEvent, HarnessName, HarnessProbe } from "../types.ts";
-
-function stubDescriptor(overrides: Partial<HarnessDescriptor> & { name: HarnessName }): HarnessDescriptor {
-  return {
-    versionArgv: [overrides.binName ?? overrides.name, "--version"],
-    buildArgv: () => [overrides.binName ?? overrides.name],
-    buildEnv: () => ({ env: {} }),
-    parseEvents: () => [] as HarnessEvent[],
-    extractFinalMessage: () => "",
-    extractUsage: () => undefined,
-    extractCostUsd: () => undefined,
-    extractSessionId: () => undefined,
-    ...overrides,
-  };
-}
-
-/** Create a temp dir holding an executable that prints `output` and exits with `code`. */
-function makeFakeCli(name: string, output: string, code = 0): { dir: string; bin: string } {
-  const dir = mkdtempSync(join(tmpdir(), "resolve-test-"));
-  const bin = join(dir, name);
-  writeFileSync(bin, `#!/bin/sh\nprintf '%s' '${output.replace(/'/g, "")}'\nexit ${code}\n`);
-  chmodSync(bin, 0o755);
-  return { dir, bin };
-}
-
-describe("healedPath", () => {
-  let existingDir: string;
-
-  beforeEach(() => {
-    existingDir = mkdtempSync(join(tmpdir(), "healed-"));
-  });
-  afterEach(() => {
-    rmSync(existingDir, { recursive: true, force: true });
-  });
-
-  it("prepends an existing extra dir and preserves the base PATH", () => {
-    const result = healedPath([existingDir], "/usr/bin:/bin");
-    expect(result.split(":")[0]).toBe(existingDir);
-    expect(result.endsWith("/usr/bin:/bin")).toBe(true);
-  });
-
-  it("skips a dir that does not exist", () => {
-    const result = healedPath(["/no/such/dir/xyz"], "/usr/bin");
-    expect(result.includes("/no/such/dir/xyz")).toBe(false);
-  });
-
-  it("does not duplicate a dir already on the base PATH", () => {
-    const result = healedPath([existingDir], `${existingDir}:/bin`);
-    expect(result.split(":").filter((d) => d === existingDir).length).toBe(1);
-  });
-});
-
-describe("binEnvVar", () => {
-  it("maps a harness name to its uppercase override variable", () => {
-    expect(binEnvVar("opencode")).toBe("POP_OPENCODE_BIN");
-    expect(binEnvVar("claude")).toBe("POP_CLAUDE_BIN");
-    expect(binEnvVar("codex")).toBe("POP_CODEX_BIN");
-  });
-});
-
-describe("harnessBinName", () => {
-  it("uses binName when set, else the harness name", () => {
-    expect(harnessBinName(stubDescriptor({ name: "opencode", binName: "opencode" }))).toBe("opencode");
-    expect(harnessBinName(stubDescriptor({ name: "claude" }))).toBe("claude");
-  });
-});
-
-describe("resolveHarnessBinary", () => {
-  let cli: { dir: string; bin: string };
-
-  beforeEach(() => {
-    cli = makeFakeCli("faketool", "ok");
-  });
-  afterEach(() => {
-    rmSync(cli.dir, { recursive: true, force: true });
-  });
-
-  it("returns the override env var when it points at an existing file", () => {
-    const descriptor = stubDescriptor({ name: "opencode", binName: "faketool" });
-    const resolved = resolveHarnessBinary(descriptor, { POP_OPENCODE_BIN: cli.bin, PATH: "" });
-    expect(resolved).toBe(cli.bin);
-  });
-
-  it("resolves via a known install dir when not on PATH", () => {
-    const descriptor = stubDescriptor({ name: "opencode", binName: "faketool", binDirs: [cli.dir] });
-    const resolved = resolveHarnessBinary(descriptor, { PATH: "" });
-    expect(resolved).toBe(cli.bin);
-  });
-
-  it("returns null when the CLI cannot be found", () => {
-    const descriptor = stubDescriptor({ name: "opencode", binName: "definitely-not-a-real-cli-xyz" });
-    expect(resolveHarnessBinary(descriptor, { PATH: "" })).toBeNull();
-  });
-});
-
-describe("descriptor auth interpreters", () => {
-  it("claude reads loggedIn from JSON, true and false", () => {
-    const i = DESCRIPTORS.claude.interpretAuthStatus!;
-    expect(i({ exitCode: 0, stdout: '{"loggedIn": true, "email": "x"}', stderr: "" })).toBe(true);
-    expect(i({ exitCode: 0, stdout: '{"loggedIn": false}', stderr: "" })).toBe(false);
-  });
-
-  it("claude returns null on unparseable, undeterminable output", () => {
-    const i = DESCRIPTORS.claude.interpretAuthStatus!;
-    expect(i({ exitCode: 0, stdout: "weird non-json", stderr: "" })).toBeNull();
-  });
-
-  it("codex distinguishes logged-in from not-logged-in", () => {
-    const i = DESCRIPTORS.codex.interpretAuthStatus!;
-    expect(i({ exitCode: 0, stdout: "Logged in using ChatGPT", stderr: "" })).toBe(true);
-    expect(i({ exitCode: 0, stdout: "Not logged in", stderr: "" })).toBe(false);
-    expect(i({ exitCode: 1, stdout: "", stderr: "" })).toBeNull();
-  });
-
-  it("opencode counts credentials, ignoring ANSI codes", () => {
-    const i = DESCRIPTORS.opencode.interpretAuthStatus!;
-    expect(i({ exitCode: 0, stdout: "└  5 credentials", stderr: "" })).toBe(true);
-    expect(i({ exitCode: 0, stdout: "0 credentials", stderr: "" })).toBe(false);
-    expect(i({ exitCode: 1, stdout: "", stderr: "" })).toBeNull();
-  });
-});
-
-describe("discoverHarnesses", () => {
-  let cli: { dir: string; bin: string };
-
-  beforeEach(() => {
-    cli = makeFakeCli("faketool", "AUTH_OK");
-  });
-  afterEach(() => {
-    rmSync(cli.dir, { recursive: true, force: true });
-  });
-
-  it("reports resolved path and auth result for a found CLI", async () => {
-    const descriptor = stubDescriptor({
-      name: "opencode",
-      binName: "faketool",
-      binDirs: [cli.dir],
-      authStatusArgv: ["status"],
-      interpretAuthStatus: ({ stdout }) => (stdout.includes("AUTH_OK") ? true : null),
-    });
-    const descriptors = { opencode: descriptor, claude: descriptor, codex: descriptor } as Record<HarnessName, HarnessDescriptor>;
-
-    const probes = await discoverHarnesses(descriptors, { PATH: "" });
-
-    expect(probes.opencode.binPath).toBe(cli.bin);
-    expect(probes.opencode.available).toBe(true);
-    expect(probes.opencode.authenticated).toBe(true);
-  });
-
-  it("marks a missing CLI unavailable with null auth", async () => {
-    const descriptor = stubDescriptor({ name: "codex", binName: "missing-cli-xyz" });
-    const descriptors = { opencode: descriptor, claude: descriptor, codex: descriptor } as Record<HarnessName, HarnessDescriptor>;
-
-    const probes = await discoverHarnesses(descriptors, { PATH: "" });
-
-    expect(probes.codex.available).toBe(false);
-    expect(probes.codex.binPath).toBeNull();
-    expect(probes.codex.authenticated).toBeNull();
-  });
-});
-
-describe("applyHarnessDiscovery", () => {
-  function probe(name: HarnessName, p: Partial<HarnessProbe>): HarnessProbe {
-    return { name, binPath: null, available: false, authenticated: null, ...p };
-  }
-
-  it("caches resolved bins, heals PATH, and warns without blocking", () => {
-    const env: Record<string, string | undefined> = { PATH: "/bin" };
-    const probes: Record<HarnessName, HarnessProbe> = {
-      opencode: probe("opencode", { binPath: "/x/opencode", available: true, authenticated: true }),
-      claude: probe("claude", { available: false }),
-      codex: probe("codex", { binPath: "/y/codex", available: true, authenticated: false }),
-    };
-
-    const messages = applyHarnessDiscovery(probes, env);
-
-    expect(env.POP_OPENCODE_BIN).toBe("/x/opencode");
-    expect(env.POP_CODEX_BIN).toBe("/y/codex");
-    expect(env.POP_CLAUDE_BIN).toBeUndefined();
-    expect(env.PATH!.endsWith("/bin")).toBe(true);
-
-    const byName = (n: string) => messages.find((m) => m.message.includes(`"${n}"`))!;
-    expect(byName("opencode").level).toBe("info");
-    expect(byName("claude").level).toBe("warn");
-    expect(byName("codex").level).toBe("warn");
-  });
-});

package/src/harness/__tests__/types.test.ts

@@ -1,297 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type {
-  HarnessName,
-  McpServerConnection,
-  HarnessUsage,
-  HarnessEvent,
-  HarnessRunOptions,
-  HarnessRunResult,
-  HarnessDescriptor,
-  AgentEntryConfig,
-  AgentStepResult,
-} from "../types.ts";
-
-describe("HarnessName", () => {
-  it("accepts all three valid harness names", () => {
-    const names: HarnessName[] = ["claude", "codex", "opencode"];
-    expect(names).toHaveLength(3);
-  });
-});
-
-describe("McpServerConnection", () => {
-  it("constructs with url and token", () => {
-    const conn: McpServerConnection = {
-      url: "http://127.0.0.1:9000/mcp",
-      token: "ephemeral-secret",
-    };
-    expect(conn.url).toBe("http://127.0.0.1:9000/mcp");
-    expect(conn.token).toBe("ephemeral-secret");
-  });
-});
-
-describe("HarnessUsage", () => {
-  it("constructs with all token counts", () => {
-    const usage: HarnessUsage = {
-      inputTokens: 100,
-      outputTokens: 200,
-      totalTokens: 300,
-    };
-    expect(usage.inputTokens).toBe(100);
-    expect(usage.outputTokens).toBe(200);
-    expect(usage.totalTokens).toBe(300);
-  });
-});
-
-describe("HarnessEvent", () => {
-  it("constructs a text event", () => {
-    const event: HarnessEvent = { type: "text", raw: {}, text: "hello" };
-    expect(event.type).toBe("text");
-    expect(event.text).toBe("hello");
-  });
-
-  it("constructs a tool_call event", () => {
-    const event: HarnessEvent = {
-      type: "tool_call",
-      raw: {},
-      tool: "read_file",
-    };
-    expect(event.type).toBe("tool_call");
-    expect(event.tool).toBe("read_file");
-  });
-
-  it("constructs a tool_result event", () => {
-    const event: HarnessEvent = { type: "tool_result", raw: {} };
-    expect(event.type).toBe("tool_result");
-  });
-
-  it("constructs a system event", () => {
-    const event: HarnessEvent = { type: "system", raw: {} };
-    expect(event.type).toBe("system");
-  });
-
-  it("constructs a result event", () => {
-    const event: HarnessEvent = { type: "result", raw: {} };
-    expect(event.type).toBe("result");
-  });
-
-  it("constructs a raw event", () => {
-    const event: HarnessEvent = { type: "raw", raw: { data: 1 } };
-    expect(event.type).toBe("raw");
-    expect(event.raw).toEqual({ data: 1 });
-  });
-});
-
-describe("HarnessRunOptions", () => {
-  it("constructs with required fields only", () => {
-    const opts: HarnessRunOptions = {
-      harness: "claude",
-      prompt: "do something",
-      cwd: "/tmp/work",
-    };
-    expect(opts.harness).toBe("claude");
-    expect(opts.prompt).toBe("do something");
-    expect(opts.cwd).toBe("/tmp/work");
-    expect(opts.model).toBeUndefined();
-    expect(opts.mcp).toBeUndefined();
-    expect(opts.timeoutMs).toBeUndefined();
-    expect(opts.signal).toBeUndefined();
-    expect(opts.onEvent).toBeUndefined();
-  });
-
-  it("constructs with all optional fields", () => {
-    const controller = new AbortController();
-    const opts: HarnessRunOptions = {
-      harness: "opencode",
-      prompt: "test",
-      cwd: "/tmp",
-      model: "gpt-4",
-      mcp: { url: "http://127.0.0.1:3000/mcp", token: "tok" },
-      timeoutMs: 30_000,
-      signal: controller.signal,
-      onEvent: (e) => {
-        void e;
-      },
-    };
-    expect(opts.harness).toBe("opencode");
-    expect(opts.model).toBe("gpt-4");
-    expect(opts.mcp?.url).toBe("http://127.0.0.1:3000/mcp");
-    expect(opts.timeoutMs).toBe(30_000);
-    expect(opts.signal).toBe(controller.signal);
-    expect(typeof opts.onEvent).toBe("function");
-  });
-});
-
-describe("HarnessRunResult", () => {
-  it("constructs with required fields only", () => {
-    const result: HarnessRunResult = {
-      finalMessage: "done",
-      events: [],
-      exitCode: 0,
-    };
-    expect(result.finalMessage).toBe("done");
-    expect(result.events).toHaveLength(0);
-    expect(result.exitCode).toBe(0);
-    expect(result.sessionId).toBeUndefined();
-    expect(result.usage).toBeUndefined();
-    expect(result.costUsd).toBeUndefined();
-  });
-
-  it("constructs with all optional fields", () => {
-    const result: HarnessRunResult = {
-      finalMessage: "completed",
-      sessionId: "sess-123",
-      usage: { inputTokens: 50, outputTokens: 100, totalTokens: 150 },
-      costUsd: 0.005,
-      events: [{ type: "text", raw: {}, text: "hi" }],
-      exitCode: 0,
-    };
-    expect(result.sessionId).toBe("sess-123");
-    expect(result.usage?.totalTokens).toBe(150);
-    expect(result.costUsd).toBe(0.005);
-    expect(result.events).toHaveLength(1);
-  });
-});
-
-describe("HarnessDescriptor", () => {
-  it("constructs a minimal descriptor with correct method signatures", () => {
-    const descriptor: HarnessDescriptor = {
-      name: "claude",
-      versionArgv: ["claude", "--version"],
-      buildArgv: (o) => ["claude", "-p", o.prompt],
-      buildEnv: () => ({ env: {} }),
-      parseEvents: (lines) =>
-        lines.map((raw) => ({ type: "raw" as const, raw })),
-      extractFinalMessage: (events) =>
-        events.find((e) => e.type === "text")?.text ?? "",
-      extractUsage: () => undefined,
-      extractCostUsd: () => undefined,
-      extractSessionId: () => undefined,
-    };
-    expect(descriptor.name).toBe("claude");
-    expect(descriptor.versionArgv).toEqual(["claude", "--version"]);
-    expect(descriptor.buildArgv({ harness: "claude", prompt: "hi", cwd: "/tmp" })).toEqual([
-      "claude", "-p", "hi",
-    ]);
-    expect(descriptor.buildEnv({ harness: "claude", prompt: "hi", cwd: "/tmp" })).toEqual({
-      env: {},
-    });
-    expect(descriptor.parseEvents([{ foo: 1 }])).toEqual([
-      { type: "raw", raw: { foo: 1 } },
-    ]);
-    expect(descriptor.extractFinalMessage([])).toBe("");
-    expect(descriptor.extractUsage([])).toBeUndefined();
-    expect(descriptor.extractCostUsd([])).toBeUndefined();
-    expect(descriptor.extractSessionId([])).toBeUndefined();
-  });
-
-  it("supports tmpFiles in buildEnv", () => {
-    const descriptor: HarnessDescriptor = {
-      name: "opencode",
-      versionArgv: ["opencode", "--version"],
-      buildArgv: () => [],
-      buildEnv: () => ({
-        env: { OPENCODE_PERMISSION: "allow" },
-        tmpFiles: [{ path: "/tmp/config.json", content: "{}" }],
-      }),
-      parseEvents: () => [],
-      extractFinalMessage: () => "",
-      extractUsage: () => undefined,
-      extractCostUsd: () => undefined,
-      extractSessionId: () => undefined,
-    };
-    const envResult = descriptor.buildEnv({
-      harness: "opencode",
-      prompt: "",
-      cwd: "/tmp",
-    });
-    expect(envResult.env.OPENCODE_PERMISSION).toBe("allow");
-    expect(envResult.tmpFiles).toHaveLength(1);
-    expect(envResult.tmpFiles?.[0]?.path).toBe("/tmp/config.json");
-  });
-});
-
-describe("AgentEntryConfig", () => {
-  it("constructs with required fields only", () => {
-    const config: AgentEntryConfig = { harness: "codex" };
-    expect(config.harness).toBe("codex");
-    expect(config.model).toBeUndefined();
-    expect(config.prompt).toBeUndefined();
-    expect(config.promptFrom).toBeUndefined();
-    expect(config.cwd).toBeUndefined();
-    expect(config.io).toBeUndefined();
-    expect(config.timeoutMs).toBeUndefined();
-    expect(config.captureDiff).toBeUndefined();
-  });
-
-  it("constructs with all optional fields", () => {
-    const config: AgentEntryConfig = {
-      harness: "claude",
-      model: "sonnet",
-      prompt: "do it",
-      cwd: "/work",
-      io: true,
-      timeoutMs: 60_000,
-      captureDiff: true,
-    };
-    expect(config.harness).toBe("claude");
-    expect(config.model).toBe("sonnet");
-    expect(config.prompt).toBe("do it");
-    expect(config.cwd).toBe("/work");
-    expect(config.io).toBe(true);
-    expect(config.timeoutMs).toBe(60_000);
-    expect(config.captureDiff).toBe(true);
-  });
-
-  it("supports promptFrom instead of prompt", () => {
-    const config: AgentEntryConfig = {
-      harness: "opencode",
-      promptFrom: "my-prompt-artifact",
-    };
-    expect(config.prompt).toBeUndefined();
-    expect(config.promptFrom).toBe("my-prompt-artifact");
-  });
-});
-
-describe("AgentStepResult", () => {
-  it("constructs a success result", () => {
-    const result: AgentStepResult = {
-      ok: true,
-      finalMessage: "all done",
-      artifactsWritten: ["output.md"],
-    };
-    expect(result.ok).toBe(true);
-    expect(result.finalMessage).toBe("all done");
-    expect(result.artifactsWritten).toEqual(["output.md"]);
-    expect(result.usage).toBeUndefined();
-    expect(result.costUsd).toBeUndefined();
-    expect(result.sessionId).toBeUndefined();
-    expect(result.error).toBeUndefined();
-  });
-
-  it("constructs a failure result", () => {
-    const result: AgentStepResult = {
-      ok: false,
-      finalMessage: "",
-      artifactsWritten: [],
-      error: "harness crashed",
-    };
-    expect(result.ok).toBe(false);
-    expect(result.finalMessage).toBe("");
-    expect(result.error).toBe("harness crashed");
-  });
-
-  it("constructs a result with all optional fields", () => {
-    const result: AgentStepResult = {
-      ok: true,
-      finalMessage: "done",
-      artifactsWritten: ["a.md", "b.patch"],
-      usage: { inputTokens: 100, outputTokens: 200, totalTokens: 300 },
-      costUsd: 0.01,
-      sessionId: "sess-456",
-    };
-    expect(result.usage?.inputTokens).toBe(100);
-    expect(result.costUsd).toBe(0.01);
-    expect(result.sessionId).toBe("sess-456");
-    expect(result.artifactsWritten).toHaveLength(2);
-  });
-});

package/src/harness/descriptors/claude.ts

@@ -1,132 +0,0 @@
-import type { HarnessDescriptor } from "../types.ts";
-
-export const claudeDescriptor: HarnessDescriptor = {
-  name: "claude",
-  versionArgv: ["claude", "--version"],
-  binName: "claude",
-  binDirs: ["~/.local/bin"],
-  authStatusArgv: ["auth", "status"],
-
-  // `claude auth status` returns JSON, e.g. {"loggedIn": true, ...}.
-  interpretAuthStatus({ stdout }) {
-    try {
-      const parsed = JSON.parse(stdout) as { loggedIn?: unknown };
-      if (typeof parsed.loggedIn === "boolean") return parsed.loggedIn;
-    } catch {
-      // fall through to a text heuristic
-    }
-    if (/not\s+logged\s+in|not\s+authenticated/i.test(stdout)) return false;
-    if (/logged\s+in|authenticated/i.test(stdout)) return true;
-    return null;
-  },
-
-  buildArgv(o) {
-    return [
-      "claude",
-      "-p",
-      o.prompt,
-      "--output-format",
-      "stream-json",
-      "--verbose",
-      "--dangerously-skip-permissions",
-      ...(o.model ? ["--model", o.model] : []),
-      ...(o.mcp
-        ? [
-            "--mcp-config",
-            JSON.stringify({
-              mcpServers: {
-                popio: {
-                  type: "http",
-                  url: o.mcp.url,
-                  headers: { Authorization: `Bearer ${o.mcp.token}` },
-                },
-              },
-            }),
-          ]
-        : []),
-    ];
-  },
-
-  buildEnv() {
-    return { env: {} };
-  },
-
-  parseEvents(lines) {
-    return lines.map((raw) => {
-      const obj = raw as Record<string, unknown>;
-      const type = typeof obj.type === "string" ? obj.type : undefined;
-      switch (type) {
-        case "text":
-          return { type: "text" as const, raw, text: String(obj.text ?? "") };
-        case "tool_call":
-          return {
-            type: "tool_call" as const,
-            raw,
-            tool: typeof obj.tool === "string" ? obj.tool : undefined,
-          };
-        case "tool_result":
-          return { type: "tool_result" as const, raw };
-        case "system":
-          return { type: "system" as const, raw };
-        case "result":
-          return { type: "result" as const, raw };
-        default:
-          return { type: "raw" as const, raw };
-      }
-    });
-  },
-
-  extractFinalMessage(events) {
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i]!;
-      if (e.type === "text" || e.type === "result") {
-        if (e.text) return e.text;
-      }
-    }
-    return "";
-  },
-
-  extractUsage(events) {
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i]!;
-      if (e.type === "result") {
-        const raw = e.raw as Record<string, unknown>;
-        const usage = raw.usage as Record<string, unknown> | undefined;
-        if (usage && typeof usage.input_tokens === "number" && typeof usage.output_tokens === "number") {
-          return {
-            inputTokens: usage.input_tokens as number,
-            outputTokens: usage.output_tokens as number,
-            totalTokens: (usage.input_tokens as number) + (usage.output_tokens as number),
-          };
-        }
-      }
-    }
-    return undefined;
-  },
-
-  extractCostUsd(events) {
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i]!;
-      if (e.type === "result") {
-        const raw = e.raw as Record<string, unknown>;
-        if (typeof raw.total_cost_usd === "number") {
-          return raw.total_cost_usd as number;
-        }
-      }
-    }
-    return undefined;
-  },
-
-  extractSessionId(events) {
-    for (let i = events.length - 1; i >= 0; i--) {
-      const e = events[i]!;
-      if (e.type === "result") {
-        const raw = e.raw as Record<string, unknown>;
-        if (typeof raw.session_id === "string") {
-          return raw.session_id as string;
-        }
-      }
-    }
-    return undefined;
-  },
-};