aiwcli 0.10.2 → 0.11.0

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

@@ -0,0 +1,106 @@
+/**
+ * Gemini CLI plan reviewer.
+ * Runs Gemini CLI in YOLO mode (auto-approve).
+ * See cc-native-plan-review-spec.md §4.12
+ */
+
+import { logDebug, logError, logInfo as _logInfo, logWarn } from "../../../_shared/lib-ts/base/logger.js";
+import { execFileAsync, findExecutable } from "../../../_shared/lib-ts/base/subprocess-utils.js";
+import { coerceToReview, parseJsonMaybe } 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,
+  });
+
+  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";

package/dist/templates/cc-native/_cc-native/lib-ts/state.ts

@@ -0,0 +1,243 @@
+/**
+ * Iteration state management for plan review cycles.
+ * State files are stored adjacent to plan files (e.g., foo.md → foo.state.json).
+ * See cc-native-plan-review-spec.md §4.7
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import { validatePlanPath } from "./constants.js";
+import type { IterationEntry, IterationState } from "./types.js";
+import { atomicWrite } from "../../_shared/lib-ts/base/atomic-write.js";
+import { logError, logInfo, logWarn } from "../../_shared/lib-ts/base/logger.js";
+import { nowIso } from "../../_shared/lib-ts/base/utils.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const STATE_SCHEMA_VERSION = "1.0.0";
+
+const DEFAULT_REVIEW_ITERATIONS: Record<string, number> = {
+  simple: 1,
+  medium: 1,
+  high: 2,
+};
+
+// ---------------------------------------------------------------------------
+// State File Management
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive state file path from plan file path with security validation.
+ * Example: ~/.claude/plans/foo.md → ~/.claude/plans/foo.state.json
+ *
+ * @throws Error if planPath is invalid or insecure
+ */
+export function getStateFilePath(planPath: string): string {
+  const validated = validatePlanPath(planPath);
+  const parsed = path.parse(validated);
+  return path.join(parsed.dir, `${parsed.name}.state.json`);
+}
+
+/**
+ * Load state file with schema validation and migration.
+ */
+export function loadState(planPath: string): null | Record<string, unknown> {
+  try {
+    const stateFile = getStateFilePath(planPath);
+
+    if (!fs.existsSync(stateFile)) {
+      return null;
+    }
+
+    const state = JSON.parse(
+      fs.readFileSync(stateFile, "utf8"),
+    ) as Record<string, unknown>;
+
+    // Handle schema version (backward compatible)
+    const schemaVersion = state.schema_version as string | undefined;
+
+    if (schemaVersion === undefined) {
+      state.schema_version = STATE_SCHEMA_VERSION;
+      logInfo(
+        "state",
+        `Migrated state file to schema v${STATE_SCHEMA_VERSION}`,
+      );
+    } else if (schemaVersion !== STATE_SCHEMA_VERSION) {
+      logWarn(
+        "state",
+        `Schema mismatch (expected ${STATE_SCHEMA_VERSION}, got ${schemaVersion})`,
+      );
+    }
+
+    return state;
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${error}`);
+    } else {
+      logError("state", `Failed to load state: ${error}`);
+    }
+
+    return null;
+  }
+}
+
+/**
+ * Save state file with schema version and validation.
+ * Returns true on success, false on failure.
+ */
+export function saveStateToPlan(
+  planPath: string,
+  state: Record<string, unknown>,
+): boolean {
+  try {
+    const stateFile = getStateFilePath(planPath);
+
+    const stateWithVersion = {
+      schema_version: STATE_SCHEMA_VERSION,
+      ...state,
+    };
+
+    const [success, error] = atomicWrite(
+      stateFile,
+      JSON.stringify(stateWithVersion, null, 2),
+    );
+
+    if (!success) {
+      logError("state", `Failed to save state: ${error}`);
+      return false;
+    }
+
+    return true;
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path: ${error}`);
+    } else {
+      logError("state", String(error));
+    }
+
+    return false;
+  }
+}
+
+/**
+ * Delete state file after successful archive.
+ * Returns true if deleted or didn't exist, false on error.
+ */
+export function deleteState(planPath: string): boolean {
+  try {
+    const stateFile = getStateFilePath(planPath);
+    if (fs.existsSync(stateFile)) {
+      fs.unlinkSync(stateFile);
+      logInfo("state", `Deleted state file: ${stateFile}`);
+    }
+
+    return true;
+  } catch (error: unknown) {
+    if (error instanceof Error && error.message.includes("Invalid plan path")) {
+      logError("state", `SECURITY: Invalid plan path in delete: ${error}`);
+      return false;
+    }
+
+    logWarn("state", `Failed to delete state file: ${error}`);
+    return false;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Iteration State Management
+// ---------------------------------------------------------------------------
+
+/**
+ * Get or initialize iteration state based on complexity.
+ */
+export function getIterationState(
+  state: Record<string, unknown>,
+  complexity: string,
+  config?: Record<string, unknown>,
+): IterationState {
+  if (state.iteration) {
+    return state.iteration as IterationState;
+  }
+
+  // Initialize new iteration state
+  const reviewIterations = { ...DEFAULT_REVIEW_ITERATIONS };
+  if (config) {
+    const overrides = config.reviewIterations as
+      | Record<string, number>
+      | undefined;
+    if (overrides) {
+      Object.assign(reviewIterations, overrides);
+    }
+  }
+
+  return {
+    current: 1,
+    max: reviewIterations[complexity] ?? 1,
+    complexity,
+    history: [],
+  };
+}
+
+/**
+ * Record review result in iteration history and update state.
+ */
+export function updateIterationState(
+  state: Record<string, unknown>,
+  iteration: IterationState,
+  planHash: string,
+  verdict: string,
+): Record<string, unknown> {
+  const entry: IterationEntry = {
+    hash: planHash,
+    verdict,
+    timestamp: nowIso(),
+  };
+
+  iteration.history.push(entry);
+  state.iteration = iteration;
+  return state;
+}
+
+/**
+ * Determine if more review iterations are needed.
+ */
+export function shouldContinueIterating(
+  iteration: IterationState,
+  verdict: string,
+  config?: Record<string, unknown>,
+): boolean {
+  const {current} = iteration;
+  const maxIter = iteration.max;
+
+  // At or past max iterations
+  if (current >= maxIter) {
+    logInfo(
+      "state",
+      `At max iterations (${current}/${maxIter}), no more iterations`,
+    );
+    return false;
+  }
+
+  // Check early exit on all pass
+  let earlyExit = true;
+  if (config) {
+    earlyExit = (config.earlyExitOnAllPass as boolean) ?? true;
+  }
+
+  if (earlyExit && verdict === "pass") {
+    logInfo(
+      "state",
+      "All reviewers passed and earlyExitOnAllPass=true, exiting early",
+    );
+    return false;
+  }
+
+  logInfo(
+    "state",
+    `Continuing to next iteration (${current + 1}/${maxIter}), verdict=${verdict}`,
+  );
+  return true;
+}

package/dist/templates/cc-native/_cc-native/lib-ts/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noFallthroughCasesInSwitch": true,
+    "outDir": "dist",
+    "rootDir": "../..",
+    "declaration": true,
+    "noEmit": true,
+    "types": ["bun-types"],
+    "skipLibCheck": true
+  },
+  "include": ["./**/*.ts", "../../_shared/lib-ts/**/*.ts"],
+  "exclude": ["../../_shared/lib-ts/__tests__/**"]
+}