aiwcli 0.10.3 → 0.11.1

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/agent.ts

@@ -0,0 +1,275 @@
+/**
+ * Agent-based plan reviewer with multi-provider support.
+ * Routes to Claude or Codex CLI based on agent.provider field.
+ * See cc-native-plan-review-spec.md §4.10
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
+import { getInternalSubprocessEnv, findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { parseCliOutput } from "../cli-output-parser.js";
+import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
+import { debugLog, debugRaw } from "../debug.js";
+import type { AgentConfig, ReviewerResult, ReviewOptions } from "../types.js";
+import { AGENT_REVIEW_PROMPT_PREFIX } from "../types.js";
+import { makeResult } from "./types.js";
+import type { Reviewer } from "./types.js";
+
+/**
+ * Agent reviewer — runs a CLI instance with a custom persona.
+ */
+export class AgentReviewer implements Reviewer {
+  constructor(private agent: AgentConfig) {}
+
+  async review(
+    plan: string,
+    schema: Record<string, unknown>,
+    options: ReviewOptions,
+  ): Promise<ReviewerResult> {
+    return runAgentReview(
+      plan,
+      this.agent,
+      schema,
+      options.timeout,
+      options.context_path,
+      options.session_name ?? "unknown",
+    );
+  }
+}
+
+/**
+ * Run a single agent to review the plan.
+ * Routes to provider-specific implementation based on agent.provider.
+ * Never throws — returns error ReviewerResult on failure.
+ */
+export async function runAgentReview(
+  plan: string,
+  agent: AgentConfig,
+  schema: Record<string, unknown>,
+  timeout: number,
+  contextPath?: string,
+  sessionName = "unknown",
+): Promise<ReviewerResult> {
+  if (agent.provider === "codex") {
+    return runAgentReviewCodex(plan, agent, schema, timeout, contextPath, sessionName);
+  }
+  // Default: Claude (existing implementation)
+  return runAgentReviewClaude(plan, agent, schema, timeout, contextPath, sessionName);
+}
+
+/**
+ * Run a single Claude Code agent to review the plan.
+ */
+async function runAgentReviewClaude(
+  plan: string,
+  agent: AgentConfig,
+  schema: Record<string, unknown>,
+  timeout: number,
+  contextPath?: string,
+  sessionName = "unknown",
+): Promise<ReviewerResult> {
+  const claudePath = findExecutable("claude");
+  if (!claudePath) {
+    logWarn(agent.name, "Claude CLI not found on PATH");
+    return makeResult(agent.name, false, "skip", {}, "", "claude CLI not found on PATH");
+  }
+
+  logDebug(agent.name, `Found Claude CLI at: ${claudePath}`);
+
+  const prompt = `IMMEDIATELY call StructuredOutput with your review of the plan below.
+Do NOT output any text before calling StructuredOutput.
+
+PLAN:
+<<<
+${plan}
+>>>
+`;
+
+  const schemaJson = JSON.stringify(schema);
+  const cmdArgs = [
+    "--model", agent.model,
+    "--output-format", "json",
+    "--json-schema", schemaJson,
+    "--max-turns", "3",
+    "--setting-sources", "",
+    "-p",
+  ];
+
+  if (agent.system_prompt) {
+    const fullPrompt = AGENT_REVIEW_PROMPT_PREFIX + "\n\n---\n\n" + agent.system_prompt;
+    cmdArgs.push("--system-prompt", fullPrompt);
+  }
+
+  logInfo(agent.name, `Running Claude with model: ${agent.model}, timeout: ${timeout}s`);
+
+  const env = getInternalSubprocessEnv();
+
+  const result = await execFileAsync(claudePath, cmdArgs, {
+    input: prompt,
+    timeout: timeout * 1000,
+    env: env as Record<string, string>,
+    maxBuffer: 10 * 1024 * 1024,
+    shell: process.platform === "win32",
+  });
+
+  if (result.killed || result.signal === "SIGTERM") {
+    logWarn(agent.name, `Claude TIMEOUT after ${timeout}s`);
+    return makeResult(agent.name, false, "error", {}, "", `${agent.name} timed out after ${timeout}s`);
+  }
+
+  const raw = result.stdout.trim();
+  const err = result.stderr.trim();
+
+  if (!raw && !err && result.exitCode !== 0) {
+    logError(agent.name, `Process exited with code ${result.exitCode} and no output`);
+    return makeResult(agent.name, false, "error", {}, "", `${agent.name} failed to run (exit ${result.exitCode})`);
+  }
+
+  logDebug(agent.name, `Exit code: ${result.exitCode}`);
+  logDebug(agent.name, `stdout length: ${raw.length} chars`);
+  if (err) logDebug(agent.name, `stderr: ${err.slice(0, 500)}`);
+
+  // Debug logging
+  if (contextPath) {
+    debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stdout", raw);
+    if (err) {
+      debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stderr", err);
+    }
+    debugLog(contextPath, sessionName, `agent:${agent.name}`, "subprocess_info", {
+      exit_code: result.exitCode,
+      stdout_len: raw.length,
+      stderr_len: err.length,
+      model: agent.model,
+      provider: "claude",
+      timeout,
+    });
+  }
+
+  if (raw) logDebug(agent.name, `stdout preview: ${raw.slice(0, 500)}`);
+
+  const obj = parseCliOutput(raw, ["verdict", "summary"]);
+
+  if (contextPath) {
+    debugLog(contextPath, sessionName, `agent:${agent.name}`, "parsed_result", {
+      parsed_keys: obj ? Object.keys(obj) : null,
+      verdict: obj?.verdict ?? null,
+      has_summary: obj ? Boolean(obj.summary) : false,
+      issues_count: obj && Array.isArray(obj.issues) ? (obj.issues as unknown[]).length : 0,
+    });
+  }
+
+  if (obj) {
+    logInfo(agent.name, `Parsed JSON successfully, verdict: ${obj.verdict ?? "N/A"}`);
+  } else {
+    logWarn(agent.name, "Failed to parse JSON from output");
+  }
+
+  const [ok, verdict, norm] = coerceToReview(
+    obj as Record<string, unknown> | null,
+    "Retry or check agent configuration.",
+  );
+
+  return makeResult(agent.name, ok, verdict, norm, raw, err);
+}
+
+/**
+ * Run a single Codex CLI agent to review the plan.
+ * Adapts the codex.ts reviewer pattern for agent-based review with persona.
+ */
+async function runAgentReviewCodex(
+  plan: string,
+  agent: AgentConfig,
+  schema: Record<string, unknown>,
+  timeout: number,
+  contextPath?: string,
+  sessionName = "unknown",
+): Promise<ReviewerResult> {
+  const codexPath = findExecutable("codex");
+  if (!codexPath) {
+    logWarn(agent.name, "Codex CLI not found on PATH, skipping");
+    return makeResult(agent.name, false, "skip", {}, "", "codex CLI not found on PATH");
+  }
+
+  // Codex has no --system-prompt flag, so we prepend the agent persona to stdin.
+  const fullPrompt = [
+    AGENT_REVIEW_PROMPT_PREFIX,
+    "---",
+    agent.system_prompt || "",
+    "---",
+    `Return ONLY a JSON object matching this schema:\n${JSON.stringify(schema)}`,
+    "",
+    "PLAN:",
+    "<<<",
+    plan,
+    ">>>",
+  ].join("\n\n");
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `codex-agent-${agent.name}-`));
+
+  try {
+    const schemaPath = path.join(tmpDir, "schema.json");
+    const outPath = path.join(tmpDir, "output.json");
+    fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
+
+    const cmdArgs = ["exec", "--sandbox", "read-only"];
+    if (agent.model) cmdArgs.push("--model", agent.model);
+    cmdArgs.push("--output-schema", schemaPath, "-o", outPath, "-");
+
+    logInfo(agent.name, `Running Codex with model: ${agent.model}, timeout: ${timeout}s`);
+
+    const result = await execFileAsync(codexPath, cmdArgs, {
+      input: fullPrompt,
+      timeout: timeout * 1000,
+      maxBuffer: 10 * 1024 * 1024,
+      shell: process.platform === "win32",
+    });
+
+    if (result.killed || result.signal === "SIGTERM") {
+      logWarn(agent.name, `Codex TIMEOUT after ${timeout}s`);
+      return makeResult(agent.name, false, "error", {}, "", `${agent.name} (codex) timed out after ${timeout}s`);
+    }
+
+    if (!result.stdout && !result.stderr && !fs.existsSync(outPath) && result.exitCode !== 0) {
+      logError(agent.name, `Codex exited with code ${result.exitCode} and no output`);
+      return makeResult(agent.name, false, "error", {}, "", `${agent.name} (codex) failed (exit ${result.exitCode})`);
+    }
+
+    // Read output: prefer temp file, fallback to stdout
+    let raw = "";
+    if (fs.existsSync(outPath)) {
+      raw = fs.readFileSync(outPath, "utf-8");
+    }
+    const err = result.stderr.trim();
+
+    // Debug logging
+    if (contextPath) {
+      debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stdout", raw || result.stdout);
+      if (err) debugRaw(contextPath, sessionName, `agent:${agent.name}`, "stderr", err);
+      debugLog(contextPath, sessionName, `agent:${agent.name}`, "subprocess_info", {
+        exit_code: result.exitCode,
+        stdout_len: (raw || result.stdout).length,
+        stderr_len: err.length,
+        model: agent.model,
+        provider: "codex",
+        timeout,
+      });
+    }
+
+    // Parse output
+    const obj = parseJsonMaybe(raw) ?? parseJsonMaybe(result.stdout);
+    const [ok, verdict, norm] = coerceToReview(
+      obj,
+      "Retry or check Codex CLI auth/config.",
+    );
+
+    return makeResult(agent.name, ok, verdict, norm, raw || result.stdout, err);
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch (e) {
+      logDebug(agent.name, `Failed to cleanup temp dir ${tmpDir}: ${e}`);
+    }
+  }
+}

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/codex.ts

@@ -0,0 +1,130 @@
+/**
+ * Codex CLI plan reviewer.
+ * Runs Codex in non-interactive mode with read-only sandbox.
+ * See cc-native-plan-review-spec.md §4.11
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
+import { findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
+import { REVIEW_PROMPT_PREFIX } from "../types.js";
+import type { ReviewerResult, ReviewOptions } from "../types.js";
+import { makeResult } from "./types.js";
+import type { Reviewer } from "./types.js";
+
+/**
+ * Codex reviewer — runs codex exec --sandbox read-only.
+ */
+export class CodexReviewer implements Reviewer {
+  private settings: Record<string, unknown>;
+
+  constructor(settings: Record<string, unknown>) {
+    this.settings = settings;
+  }
+
+  async review(
+    plan: string,
+    schema: Record<string, unknown>,
+    options: ReviewOptions,
+  ): Promise<ReviewerResult> {
+    return runCodexReview(plan, schema, this.settings);
+  }
+}
+
+/**
+ * Run Codex CLI to review the plan.
+ * Never throws — returns error ReviewerResult on failure.
+ */
+export async function runCodexReview(
+  plan: string,
+  schema: Record<string, unknown>,
+  settings: Record<string, unknown>,
+): Promise<ReviewerResult> {
+  const codexSettings =
+    ((settings.reviewers as Record<string, unknown> | undefined)?.codex as
+      | Record<string, unknown>
+      | undefined) ?? {};
+  const timeout = (codexSettings.timeout as number) ?? 120;
+  const model = (codexSettings.model as string) ?? "";
+
+  const codexPath = findExecutable("codex");
+  if (!codexPath) {
+    logWarn("codex", "CLI not found on PATH");
+    return makeResult("codex", false, "skip", {}, "", "codex CLI not found on PATH");
+  }
+
+  logDebug("codex", `Found CLI at: ${codexPath}`);
+
+  const prompt = `${REVIEW_PROMPT_PREFIX}
+Return ONLY a JSON object that matches this JSON Schema:
+${JSON.stringify(schema)}
+
+PLAN:
+<<<
+${plan}
+>>>
+`;
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "codex-review-"));
+
+  try {
+    const schemaPath = path.join(tmpDir, "schema.json");
+    const outPath = path.join(tmpDir, "codex_review.json");
+
+    fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), "utf-8");
+
+    const cmdArgs = ["exec", "--sandbox", "read-only"];
+
+    if (model) {
+      cmdArgs.push("--model", model);
+    }
+
+    cmdArgs.push("--output-schema", schemaPath, "-o", outPath, "-");
+
+    logDebug("codex", `Running command: codex ${cmdArgs.join(" ")}`);
+
+    const result = await execFileAsync(codexPath, cmdArgs, {
+      input: prompt,
+      timeout: timeout * 1000,
+      maxBuffer: 10 * 1024 * 1024,
+      shell: process.platform === "win32",
+    });
+
+    if (result.killed || result.signal === "SIGTERM") {
+      logWarn("codex", `TIMEOUT after ${timeout}s`);
+      return makeResult("codex", false, "error", {}, "", `codex timed out after ${timeout}s`);
+    }
+
+    if (!result.stdout && !result.stderr && !fs.existsSync(outPath) && result.exitCode !== 0) {
+      logError("codex", `Process exited with code ${result.exitCode} and no output`);
+      return makeResult("codex", false, "error", {}, "", `codex failed to run (exit ${result.exitCode})`);
+    }
+
+    logDebug("codex", `Exit code: ${result.exitCode}`);
+
+    let raw = "";
+    if (fs.existsSync(outPath)) {
+      raw = fs.readFileSync(outPath, "utf-8");
+    }
+
+    const obj = parseJsonMaybe(raw) ?? parseJsonMaybe(result.stdout);
+    const [ok, verdict, norm] = coerceToReview(
+      obj,
+      "Retry or check CLI auth/config.",
+    );
+
+    const err = result.stderr.trim();
+    return makeResult("codex", ok, verdict, norm, raw || result.stdout, err);
+  } finally {
+    // Clean up temp directory
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+      // Best effort cleanup
+    }
+  }
+}
+

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/gemini.ts

@@ -0,0 +1,107 @@
+/**
+ * Gemini CLI plan reviewer.
+ * Runs Gemini CLI in YOLO mode (auto-approve).
+ * See cc-native-plan-review-spec.md §4.12
+ */
+
+import { logDebug, logInfo, logWarn, logError } from "../../../_shared/lib-ts/base/logger.js";
+import { findExecutable, execFileAsync } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { parseJsonMaybe, coerceToReview } from "../json-parser.js";
+import type { ReviewerResult, ReviewOptions } from "../types.js";
+import { makeResult } from "./types.js";
+import type { Reviewer } from "./types.js";
+
+/**
+ * Gemini reviewer — runs gemini -y -p <instruction>.
+ */
+export class GeminiReviewer implements Reviewer {
+  private settings: Record<string, unknown>;
+
+  constructor(settings: Record<string, unknown>) {
+    this.settings = settings;
+  }
+
+  async review(
+    plan: string,
+    schema: Record<string, unknown>,
+    options: ReviewOptions,
+  ): Promise<ReviewerResult> {
+    return runGeminiReview(plan, schema, this.settings);
+  }
+}
+
+/**
+ * Run Gemini CLI to review the plan.
+ * Never throws — returns error ReviewerResult on failure.
+ */
+export async function runGeminiReview(
+  plan: string,
+  schema: Record<string, unknown>,
+  settings: Record<string, unknown>,
+): Promise<ReviewerResult> {
+  const geminiSettings =
+    ((settings.reviewers as Record<string, unknown> | undefined)?.gemini as
+      | Record<string, unknown>
+      | undefined) ?? {};
+  const timeout = (geminiSettings.timeout as number) ?? 120;
+  const model = (geminiSettings.model as string) ?? "";
+
+  const geminiPath = findExecutable("gemini");
+  if (!geminiPath) {
+    logWarn("gemini", "CLI not found on PATH");
+    return makeResult("gemini", false, "skip", {}, "", "gemini CLI not found on PATH");
+  }
+
+  logDebug("gemini", `Found CLI at: ${geminiPath}`);
+
+  const instruction = `
+
+Review the PLAN above as a senior staff software engineer. Focus on:
+- missing steps, unclear assumptions, edge cases
+- security/privacy concerns
+- testing/rollout/rollback completeness
+- operational concerns (observability, failure modes)
+
+Return ONLY a JSON object that matches this JSON Schema (no markdown, no code fences):
+${JSON.stringify(schema)}
+`;
+
+  const cmdArgs = ["-y", "-p", instruction];
+
+  if (model) {
+    cmdArgs.push("--model", model);
+  }
+
+  logDebug("gemini", "Running command: gemini -y -p <instruction>");
+
+  const result = await execFileAsync(geminiPath, cmdArgs, {
+    input: plan,
+    timeout: timeout * 1000,
+    maxBuffer: 10 * 1024 * 1024,
+    shell: process.platform === "win32",
+  });
+
+  if (result.killed || result.signal === "SIGTERM") {
+    logWarn("gemini", `TIMEOUT after ${timeout}s`);
+    return makeResult("gemini", false, "error", {}, "", `gemini timed out after ${timeout}s`);
+  }
+
+  if (!result.stdout && !result.stderr && result.exitCode !== 0) {
+    logError("gemini", `Process exited with code ${result.exitCode}`);
+    return makeResult("gemini", false, "error", {}, "", `gemini failed to run (exit ${result.exitCode})`);
+  }
+
+  logDebug("gemini", `Exit code: ${result.exitCode}`);
+
+  const raw = result.stdout.trim();
+  const err = result.stderr.trim();
+
+  const obj = parseJsonMaybe(raw);
+  const [ok, verdict, norm] = coerceToReview(
+    obj,
+    "Retry or check CLI auth/config.",
+  );
+
+  return makeResult("gemini", ok, verdict, norm, raw, err);
+}
+

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Reviewers package — re-exports all reviewer implementations.
+ * See cc-native-plan-review-spec.md §4.9
+ */
+
+export { AgentReviewer, runAgentReview } from "./agent.js";
+export { CodexReviewer, runCodexReview } from "./codex.js";
+export { GeminiReviewer, runGeminiReview } from "./gemini.js";
+export type { Reviewer, ReviewerResult, ReviewOptions } from "./types.js";
+export { makeResult } from "./types.js";

package/dist/templates/cc-native/_cc-native/lib-ts/reviewers/types.ts

@@ -0,0 +1,23 @@
+/**
+ * Reviewer interface and options for plan review implementations.
+ * See cc-native-plan-review-spec.md §4.9
+ */
+
+import type { ReviewData,  ReviewerResult,  Verdict } from "../types.js";
+
+// Re-export for convenience
+
+
+/** Create a standard ReviewerResult. Shared by all reviewer implementations. */
+export function makeResult(
+  name: string,
+  ok: boolean,
+  verdict: Verdict,
+  data: Record<string, unknown> | ReviewData,
+  raw: string,
+  err: string,
+): ReviewerResult {
+  return { name, ok, verdict, data: data as Record<string, unknown>, raw, err };
+}
+
+export {type Reviewer, type ReviewerResult, type ReviewOptions} from "../types.js";