@forwardimpact/libharness 0.1.22 → 1.1.0

package/src/commands/supervise.js

@@ -0,0 +1,136 @@
+import { resolve, join } from "node:path";
+import { isoTimestamp } from "@forwardimpact/libutil";
+import { createSupervisor } from "../supervisor.js";
+import { createRedactor } from "../redaction.js";
+import { createTeeWriter } from "../tee-writer.js";
+import { resolveTaskContent } from "./task-input.js";
+import { resolveWorkTracker } from "./work-tracker.js";
+import { createServiceConfig } from "@forwardimpact/libconfig";
+import { AGENT_MODEL, LEAD_MODEL } from "@forwardimpact/libutil/models";
+
+/**
+ * Parse all supervise flags from parsed values into an options object.
+ * @param {object} values - Parsed option values from cli.parse()
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime
+ * @returns {Promise<object>}
+ */
+export async function parseSuperviseOptions(values, runtime) {
+  const { task: taskContent, amend: taskAmend } = resolveTaskContent(
+    values,
+    runtime,
+  );
+  const supervisorAllowedToolsRaw = values["supervisor-allowed-tools"];
+
+  const tmpRoot = runtime.proc.env.TMPDIR ?? "/tmp";
+  const agentCwd = resolve(
+    values["agent-cwd"] ??
+      (await runtime.fs.mkdtemp(join(tmpRoot, "fit-harness-agent-"))),
+  );
+
+  return {
+    taskContent,
+    taskAmend,
+    supervisorCwd: resolve(values["supervisor-cwd"] ?? "."),
+    agentCwd,
+    agentModel: values["agent-model"] || AGENT_MODEL,
+    supervisorModel: values["lead-model"] || LEAD_MODEL,
+    maxTurns: (() => {
+      const raw = values["max-turns"] ?? "200";
+      return raw === "0" ? 0 : parseInt(raw, 10);
+    })(),
+    outputPath: values.output,
+    supervisorProfile: values["lead-profile"] ?? undefined,
+    agentProfile: values["agent-profile"] ?? undefined,
+    workTracker: resolveWorkTracker(values, runtime?.proc?.env),
+    allowedTools: (
+      values["allowed-tools"] ??
+      "Bash,Read,Glob,Grep,Write,Edit,Agent,TodoWrite"
+    ).split(","),
+    supervisorAllowedTools: supervisorAllowedToolsRaw
+      ? supervisorAllowedToolsRaw.split(",")
+      : undefined,
+    mcpServer: values["mcp-server"] ?? undefined,
+  };
+}
+
+/**
+ * Supervise command — run one agent under a supervisor via the
+ * orchestration loop. The supervisor delegates work through Ask, sees
+ * each reply on its next turn, and ends with Conclude.
+ *
+ * Usage: fit-harness supervise [options]
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: boolean, code?: number, error?: string}>}
+ */
+export async function runSuperviseCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const opts = await parseSuperviseOptions(ctx.options, runtime);
+
+  // Build the redactor as the first observable side-effect after option
+  // parsing — the env snapshot must freeze BEFORE any in-process
+  // env writes the command performs (e.g. LIBHARNESS_AGENT_PROFILE).
+  const redactor = createRedactor({ runtime });
+
+  // When --output is specified, stream text to stdout while writing NDJSON to file.
+  // Otherwise, write NDJSON directly to stdout (backwards-compatible).
+  const fileStream = opts.outputPath
+    ? runtime.fs.createWriteStream(opts.outputPath)
+    : null;
+  const output = fileStream
+    ? createTeeWriter({
+        fileStream,
+        textStream: runtime.proc.stdout,
+        mode: "supervised",
+        now: () => isoTimestamp(runtime.clock.now()),
+      })
+    : runtime.proc.stdout;
+
+  let agentMcpServers = null;
+  if (opts.mcpServer) {
+    const mcpConfig = await createServiceConfig("mcp");
+    agentMcpServers = {
+      [opts.mcpServer]: {
+        type: "http",
+        url: mcpConfig.url,
+        headers: { Authorization: `Bearer ${mcpConfig.mcpToken()}` },
+      },
+    };
+    opts.allowedTools.push(`mcp__${opts.mcpServer}__*`);
+  }
+
+  if (opts.agentProfile) {
+    runtime.proc.env.LIBHARNESS_AGENT_PROFILE = opts.agentProfile;
+  }
+  // Unconditional so the default "github" is observable to the agent's
+  // active-tracker resolution, mirroring --agent-profile's env write above.
+  runtime.proc.env.LIBHARNESS_WORK_TRACKER = opts.workTracker;
+
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  const supervisor = createSupervisor({
+    supervisorCwd: opts.supervisorCwd,
+    agentCwd: opts.agentCwd,
+    query,
+    output,
+    agentModel: opts.agentModel,
+    supervisorModel: opts.supervisorModel,
+    maxTurns: opts.maxTurns,
+    allowedTools: opts.allowedTools,
+    supervisorAllowedTools: opts.supervisorAllowedTools,
+    supervisorProfile: opts.supervisorProfile,
+    agentProfile: opts.agentProfile,
+    taskAmend: opts.taskAmend,
+    agentMcpServers,
+    redactor,
+    runtime,
+  });
+
+  const result = await supervisor.run(opts.taskContent);
+
+  if (fileStream) {
+    await new Promise((r) => output.end(r));
+    await new Promise((r) => fileStream.end(r));
+  }
+
+  return result.success ? { ok: true } : { ok: false, code: 1, error: "" };
+}

package/src/commands/task-input.js

@@ -0,0 +1,54 @@
+import { composeTaskFromGitHubEvent } from "../events/github.js";
+
+/**
+ * Resolve `--task-file` / `--task-text` / `--task-event` into the task pair the
+ * runner consumes. Exactly one of the three must be set. For `--task-event`,
+ * libharness reads the event payload and extracts both the main task (from the
+ * template that matches `$GITHUB_EVENT_NAME` + `payload.action`) and the
+ * amendment (from `payload.inputs?.prompt`) — so the workflow doesn't need to
+ * wire `--task-amend` separately. For the other two modes, `--task-amend`
+ * works as before.
+ *
+ * @param {object} values - Parsed option values from cli.parse()
+ * @param {import("@forwardimpact/libutil/runtime").Runtime} runtime - Ambient
+ *   collaborators; `fsSync.readFileSync` loads `--task-file`/`--task-event`
+ *   and `proc.env` resolves `GITHUB_EVENT_NAME`.
+ * @returns {{ task: string, amend: string | undefined }}
+ */
+export function resolveTaskContent(values, runtime) {
+  const taskFile = values["task-file"];
+  const taskText = values["task-text"];
+  const taskEvent = values["task-event"];
+
+  const set = [taskFile, taskText, taskEvent].filter(Boolean).length;
+  if (set === 0) {
+    throw new Error(
+      "one of --task-file, --task-text, --task-event is required",
+    );
+  }
+  if (set > 1) {
+    throw new Error(
+      "--task-file, --task-text, --task-event are mutually exclusive",
+    );
+  }
+
+  const amendFlag = values["task-amend"] ?? undefined;
+
+  if (taskFile) {
+    return {
+      task: runtime.fsSync.readFileSync(taskFile, "utf8"),
+      amend: amendFlag,
+    };
+  }
+  if (taskText) {
+    return { task: taskText, amend: amendFlag };
+  }
+
+  const eventName = runtime.proc.env.GITHUB_EVENT_NAME;
+  if (!eventName) {
+    throw new Error("--task-event requires GITHUB_EVENT_NAME to be set");
+  }
+  const payload = JSON.parse(runtime.fsSync.readFileSync(taskEvent, "utf8"));
+  const composed = composeTaskFromGitHubEvent(payload, eventName);
+  return { task: composed.task, amend: amendFlag ?? composed.amend };
+}

package/src/commands/tee.js

@@ -0,0 +1,53 @@
+import { PassThrough } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { isoTimestamp } from "@forwardimpact/libutil";
+import { createTeeWriter } from "../tee-writer.js";
+
+/**
+ * Tee command — stream text output to stdout while optionally saving the raw
+ * NDJSON to a file. Reads stdin line-by-line through the injected runtime and
+ * re-delimits each record with a newline so the TeeWriter's line splitter sees
+ * the same framing the raw byte stream produced.
+ *
+ * Usage: fit-harness tee [output.ndjson] < trace.ndjson
+ *
+ * @param {import("@forwardimpact/libcli").InvocationContext} ctx
+ * @returns {Promise<{ok: boolean, code?: number, error?: string}>}
+ */
+export async function runTeeCommand(ctx) {
+  const runtime = ctx.deps.runtime;
+  const outputPath = ctx.args.output ?? null;
+  const fileStream = outputPath
+    ? runtime.fs.createWriteStream(outputPath)
+    : null;
+
+  // TeeWriter requires a fileStream; when no output file is specified,
+  // use a PassThrough as a no-op sink (NDJSON is not saved).
+  const sink = fileStream ?? new PassThrough();
+  const tee = createTeeWriter({
+    fileStream: sink,
+    textStream: runtime.proc.stdout,
+    mode: "raw",
+    now: () => isoTimestamp(runtime.clock.now()),
+  });
+
+  try {
+    // `runtime.proc.stdin` yields newline-stripped lines; re-append `\n` so the
+    // TeeWriter's `_write` line splitter frames records exactly as it did when
+    // piped the raw byte stream.
+    const lines = (async function* () {
+      for await (const line of runtime.proc.stdin) yield `${line}\n`;
+    })();
+    await pipeline(lines, tee);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, code: 1, error: error.message };
+  } finally {
+    if (fileStream) {
+      await new Promise((resolve, reject) => {
+        fileStream.end(() => resolve());
+        fileStream.on("error", reject);
+      });
+    }
+  }
+}