android2harmony 0.1.7 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/src/agent-render/backend.js

@@ -0,0 +1,323 @@
+import { spawn } from "node:child_process";
+import { extractJsonBlock } from "./output-parse.js";
+// Promise-based spawn wrapper so the event loop is NOT blocked while a
+// backend subprocess (opencode, minutes per call) runs; the status writer
+// and other concurrent workers keep responding. Windows needs shell: true.
+export function spawnAsync(command, args, options) {
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let spawnError;
+    let settled = false;
+    const child = spawn(command, [...args], {
+      cwd: options.cwd,
+      shell: options.shell,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    const settle = (status) => {
+      if (settled) return;
+      settled = true;
+      resolve({ status, stdout, stderr, error: spawnError });
+    };
+    child.on("error", (err) => {
+      spawnError = err;
+    });
+    child.on("close", (code) => {
+      settle(code);
+    });
+    child.stdin.on("error", () => {});
+    if (options.input !== undefined) child.stdin.write(options.input, "utf8");
+    child.stdin.end();
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+  });
+}
+export function extractSessionId(stderr) {
+  return stderr.match(/message=created id=(ses_\S+)/)?.[1];
+}
+function opencodeCommand(opts, executable) {
+  const args = [
+    "run",
+    "--agent",
+    opts.agentName,
+    "--pure",
+    "--dir",
+    opts.cwd,
+    "--format",
+    "json",
+    "--auto",
+  ];
+  if (opts.sessionId !== undefined) args.push("--session", opts.sessionId);
+  return { command: executable, args, input: opts.prompt };
+}
+async function runCommand(spec, opts, spawnFn) {
+  const result = await spawnFn(spec.command, spec.args, {
+    input: spec.input,
+    cwd: opts.cwd,
+    shell: process.platform === "win32",
+  });
+  const stderr = result.stderr;
+  const sessionId = extractSessionId(stderr) ?? opts.sessionId;
+  if (result.status !== 0) {
+    return {
+      status: "error",
+      errorReason: "execution-failed",
+      error: stderr || result.error?.message || "backend process failed",
+      stdout: result.stdout,
+      stderr,
+      sessionId,
+    };
+  }
+  try {
+    return {
+      status: "ok",
+      output: extractJsonBlock(result.stdout),
+      stdout: result.stdout,
+      stderr,
+      sessionId,
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      errorReason: "json-decode-error",
+      error: error instanceof Error ? error.message : String(error),
+      stdout: result.stdout,
+      stderr,
+      sessionId,
+    };
+  }
+}
+export function createOpencodeBackend(options = {}) {
+  const spawnFn = options.spawnFn ?? spawnAsync;
+  const executable = options.executable ?? "opencode";
+  return {
+    run: (opts) =>
+      runOpencodeCommand(opencodeCommand(opts, executable), opts, spawnFn),
+  };
+}
+// `--agent <name>` loads `.claude/agents/<name>.md` frontmatter when the host
+// provides that optional profile. Since ADR-0005's 2026-07-25 revision unified the
+// shell-mode claude backend with the subagent-mode protocol, `opts.prompt` is
+// now the filesystem path to a task.md file — not the full inline prompt.
+// `--output-format json` wraps the final message in a JSON envelope that
+// carries duration_ms / num_turns / total_cost_usd / modelUsage / session_id
+// — the real validated result still lives in output.json on disk, these stats
+// are purely observational (telemetry / debugging).
+function claudeCommand(opts, executable) {
+  const args = [
+    "-p",
+    "--output-format",
+    "json",
+    "--permission-mode",
+    "bypassPermissions",
+    "--agent",
+    opts.agentName,
+  ];
+  if (opts.sessionId !== undefined) args.push("--resume", opts.sessionId);
+  // taskPath passed as the positional argument; no stdin needed
+  return { command: executable, args, input: opts.prompt };
+}
+function parseEnvelopeStats(stdout) {
+  try {
+    const envelope = JSON.parse(stdout);
+    const sessionId = envelope.session_id;
+    if (!sessionId) return undefined;
+    return {
+      durationMs: envelope.duration_ms ?? 0,
+      durationApiMs: envelope.duration_api_ms ?? 0,
+      numTurns: envelope.num_turns ?? 0,
+      totalCostUsd: envelope.total_cost_usd ?? 0,
+      modelUsage: envelope.modelUsage ?? {},
+      sessionId,
+    };
+  } catch {
+    return undefined;
+  }
+}
+async function runClaudeCommand(spec, opts, spawnFn) {
+  const result = await spawnFn(spec.command, spec.args, {
+    input: spec.input,
+    cwd: opts.cwd,
+    shell: process.platform === "win32",
+  });
+  const stderr = result.stderr;
+  if (result.status !== 0) {
+    return {
+      status: "error",
+      errorReason: "execution-failed",
+      error: stderr || result.error?.message || "backend process failed",
+      stdout: result.stdout,
+      stderr,
+    };
+  }
+  // Success: the real validated result lives in output.json on disk, written
+  // and finalized by the subprocess via reqgen-selfcheck.mjs. Parse the JSON
+  // envelope from stdout purely for telemetry / debugging stats.
+  const stats = parseEnvelopeStats(result.stdout);
+  return { status: "ok", stdout: result.stdout, stderr, stats };
+}
+function parseOpencodeNdjson(stdout) {
+  const lines = stdout.split("\n");
+  const textParts = [];
+  let sessionId;
+  let startTs;
+  let finishTs;
+  let tokens;
+  let cost;
+  for (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const evt = JSON.parse(line);
+      sessionId = sessionId ?? evt.sessionID;
+      if (evt.type === "step_start") startTs = evt.timestamp;
+      if (evt.type === "step_finish") {
+        finishTs = evt.timestamp;
+        tokens = evt.part?.tokens;
+        cost = evt.part?.cost;
+      }
+      if (evt.type === "text" && evt.part?.text) {
+        textParts.push(evt.part.text);
+      }
+    } catch {
+      /* skip unparseable lines */
+    }
+  }
+  const text = textParts.join("").trim();
+  if (!sessionId) return { text };
+  const durationMs =
+    startTs !== undefined && finishTs !== undefined ? finishTs - startTs : 0;
+  return {
+    stats: {
+      durationMs,
+      durationApiMs: 0, // opencode doesn't report api-time separately
+      numTurns: 0, // opencode doesn't report turn count
+      totalCostUsd: cost ?? 0,
+      modelUsage: tokens
+        ? {
+            inputTokens: tokens.input,
+            outputTokens: tokens.output,
+            totalTokens: tokens.total,
+            reasoningTokens: tokens.reasoning ?? 0,
+            cacheWriteTokens: tokens.cache?.write ?? 0,
+            cacheReadTokens: tokens.cache?.read ?? 0,
+          }
+        : {},
+      sessionId,
+    },
+    text,
+  };
+}
+async function runOpencodeCommand(spec, opts, spawnFn) {
+  const result = await spawnFn(spec.command, spec.args, {
+    input: spec.input,
+    cwd: opts.cwd,
+    shell: process.platform === "win32",
+  });
+  const stderr = result.stderr;
+  if (result.status !== 0) {
+    return {
+      status: "error",
+      errorReason: "execution-failed",
+      error: stderr || result.error?.message || "backend process failed",
+      stdout: result.stdout,
+      stderr,
+    };
+  }
+  // Success: the real validated result lives in output.json on disk.
+  // Parse NDJSON from stdout purely for telemetry / debugging stats.
+  const { stats } = parseOpencodeNdjson(result.stdout);
+  return { status: "ok", stdout: result.stdout, stderr, stats };
+}
+/** Legacy claude backend (--mode shell-legacy): inline-prompt on stdin,
+ * JSON block extracted from the --output-format json envelope — the
+ * pre-normalize behaviour where this process does its own validation
+ * instead of delegating it to the subprocess's self-check/finalize loop. */
+async function runClaudeCommandLegacy(spec, opts, spawnFn) {
+  const result = await spawnFn(spec.command, spec.args, {
+    input: spec.input,
+    cwd: opts.cwd,
+    shell: process.platform === "win32",
+  });
+  const stderr = result.stderr;
+  if (result.status !== 0) {
+    return {
+      status: "error",
+      errorReason: "execution-failed",
+      error: stderr || result.error?.message || "backend process failed",
+      stdout: result.stdout,
+      stderr,
+      sessionId: opts.sessionId,
+    };
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(result.stdout);
+  } catch (error) {
+    return {
+      status: "error",
+      errorReason: "json-decode-error",
+      error: `claude --output-format json did not return valid JSON: ${error instanceof Error ? error.message : String(error)}`,
+      stdout: result.stdout,
+      stderr,
+      sessionId: opts.sessionId,
+    };
+  }
+  const sessionId = envelope.session_id ?? opts.sessionId;
+  if (envelope.is_error === true || typeof envelope.result !== "string") {
+    return {
+      status: "error",
+      errorReason: "execution-failed",
+      error:
+        envelope.result ??
+        `claude session ended with subtype=${envelope.subtype ?? "unknown"}`,
+      stdout: result.stdout,
+      stderr,
+      sessionId,
+    };
+  }
+  try {
+    const stats = parseEnvelopeStats(result.stdout);
+    return {
+      status: "ok",
+      output: extractJsonBlock(envelope.result),
+      stdout: result.stdout,
+      stderr,
+      sessionId,
+      stats,
+    };
+  } catch (error) {
+    return {
+      status: "error",
+      errorReason: "json-decode-error",
+      error: error instanceof Error ? error.message : String(error),
+      stdout: result.stdout,
+      stderr,
+      sessionId,
+    };
+  }
+}
+export function createClaudeBackend(options = {}) {
+  const spawnFn = options.spawnFn ?? spawnAsync;
+  const executable = options.executable ?? "claude";
+  const runFn = options.legacy ? runClaudeCommandLegacy : runClaudeCommand;
+  return {
+    run: (opts) => runFn(claudeCommand(opts, executable), opts, spawnFn),
+  };
+}
+/** Custom backend: any executable that reads the prompt on stdin and answers
+ * with a fenced ```json block on stdout. */
+export function createCommandBackend(executable, options = {}) {
+  const spawnFn = options.spawnFn ?? spawnAsync;
+  return {
+    run: (opts) =>
+      runCommand(
+        { command: executable, args: [], input: opts.prompt },
+        opts,
+        spawnFn,
+      ),
+  };
+}