aiwcli 0.10.3 → 0.11.1

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

@@ -0,0 +1,120 @@
+/**
+ * CC-Native plan review library — package entry point.
+ * Re-exports the public API from all modules.
+ */
+
+// Agent aggregation
+export {
+  aggregateAgents,
+  extractBody,
+  extractFrontmatter,
+} from "./aggregate-agents.js";
+
+// Artifacts
+export {
+  buildCombinedJson,
+  buildHighIssuesDocument,
+  buildInlineReviewSummary,
+  extractTopIssuesText,
+  formatCombinedMarkdown,
+  formatReviewMarkdown,
+  generateReviewIndex,
+  writeCombinedArtifacts,
+} from "./artifacts.js";
+
+// CC-native state
+export {
+  getCcNativeState,
+  isPlanAlreadyReviewed,
+  markPlanReviewed,
+  markQuestionsAsked,
+  saveCcNativeState,
+  wasPlanPreviouslyDenied,
+  wasQuestionsAsked,
+} from "./cc-native-state.js";
+
+// CLI output parsing
+export { parseCliOutput } from "./cli-output-parser.js";
+
+// Configuration
+export { getDisplaySettings, loadConfig } from "./config.js";
+
+// Constants & security
+export {
+  ENABLE_PLAN_NOTIFICATIONS,
+  ENABLE_ROBUST_PLAN_WRITES,
+  MAX_ERROR_FILE_SIZE,
+  MAX_PLAN_PATH_LENGTH,
+  MAX_RETRY_ATTEMPTS,
+  MAX_TOTAL_RETRY_TIME_MS,
+  PLANS_DIR,
+  RETRY_BACKOFF_MS,
+  validatePlanPath,
+} from "./constants.js";
+
+// Debug logging
+export { cleanupDebugFolder, debugLog, debugRaw, getDebugDir } from "./debug.js";
+
+// JSON parsing
+export { coerceToReview, parseJsonMaybe } from "./json-parser.js";
+
+// Orchestrator
+export { buildOrchestratorSchema, runOrchestrator } from "./orchestrator.js";
+
+// Reviewers
+export {
+  AgentReviewer,
+  CodexReviewer,
+  GeminiReviewer,
+  runAgentReview,
+  runCodexReview,
+  runGeminiReview,
+} from "./reviewers/index.js";
+
+// Iteration state
+export {
+  DEFAULT_REVIEW_ITERATIONS,
+  deleteState,
+  getIterationState,
+  getStateFilePath,
+  loadState,
+  saveStateToPlan,
+  shouldContinueIterating,
+  updateIterationState,
+} from "./state.js";
+
+// Types & schemas
+export type {
+  AgentConfig,
+  CcNativeState,
+  CombinedReviewResult,
+  ComplexityCategory,
+  DisplaySettings,
+  IterationEntry,
+  IterationState,
+  OrchestratorConfig,
+  OrchestratorResult,
+  PlanReviewConfig,
+  PlanReviewState,
+  QuestionsAskedState,
+  ReviewData,
+  ReviewDecision,
+  ReviewDecisionResult,
+  Reviewer,
+  ReviewerResult,
+  ReviewIssue,
+  ReviewOptions,
+  Verdict,
+} from "./types.js";
+
+export {
+  AGENT_REVIEW_PROMPT_PREFIX,
+  DEFAULT_DISPLAY,
+  DEFAULT_SANITIZATION,
+  ORCHESTRATOR_SCHEMA,
+  REVIEW_PROMPT_PREFIX,
+  REVIEW_SCHEMA,
+} from "./types.js";
+
+// Verdict aggregation
+export { computeReviewDecision, worstVerdict } from "./verdict.js";

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

@@ -0,0 +1,168 @@
+/**
+ * JSON parsing utilities for LLM responses.
+ * See cc-native-plan-review-spec.md §4.10-4.11
+ */
+
+import type { ReviewData, Verdict } from "./types.js";
+import { logDebug, logWarn } from "../../_shared/lib-ts/base/logger.js";
+
+/**
+ * Try strict JSON parse. If that fails, attempt to extract the first {...} block.
+ *
+ * @param text - Raw text that may contain JSON
+ * @param requireFields - Optional list of field names to check for
+ * @returns Parsed dict or null if parsing failed entirely
+ */
+export function parseJsonMaybe(
+  text: string,
+  requireFields?: string[],
+): null | Record<string, unknown> {
+  const trimmed = text.trim();
+  if (!trimmed) return null;
+
+  let obj: null | Record<string, unknown> = null;
+  let parseMethod: null | string = null;
+
+  // Strict parse
+  try {
+    const parsed: unknown = JSON.parse(trimmed);
+    if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+      obj = parsed as Record<string, unknown>;
+      parseMethod = "strict";
+    }
+  } catch {
+    // Fall through to heuristic
+  }
+
+  // Heuristic: try to extract a JSON object substring
+  if (obj === null) {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start !== -1 && end !== -1 && end > start) {
+      const candidate = trimmed.slice(start, end + 1);
+      try {
+        const parsed: unknown = JSON.parse(candidate);
+        if (
+          parsed !== null &&
+          typeof parsed === "object" &&
+          !Array.isArray(parsed)
+        ) {
+          obj = parsed as Record<string, unknown>;
+          parseMethod = "heuristic";
+          logDebug(
+            "parse",
+            `Used heuristic extraction (chars ${start}-${end})`,
+          );
+        }
+      } catch {
+        logDebug(
+          "parse",
+          `Heuristic extraction failed for candidate at chars ${start}-${end}`,
+        );
+        return null;
+      }
+    }
+  }
+
+  // Validate required fields if parsed
+  if (obj && requireFields) {
+    const missing = requireFields.filter((f) => !(f in obj!) || !obj![f]);
+    if (missing.length > 0) {
+      logWarn(
+        "parse",
+        `Parsed JSON (${parseMethod}) missing/empty fields: ${JSON.stringify(missing)}`,
+      );
+      logDebug("parse", `Keys present: ${JSON.stringify(Object.keys(obj))}`);
+      // Heuristic extraction grabbed the wrong object — reject it.
+      // Strict parse still returns partial objects (caller handles defaults).
+      if (parseMethod === "heuristic") {
+        logWarn("parse", "Rejecting heuristic result due to missing required fields");
+        return null;
+      }
+    }
+  }
+
+  return obj;
+}
+
+/**
+ * Validate/normalize parsed JSON to ReviewData shape with safe defaults.
+ *
+ * @param obj - Parsed JSON object (possibly null)
+ * @param defaultFixMsg - Default suggested_fix message for error case
+ * @returns Tuple of [ok, verdict, normalizedData]
+ */
+export function coerceToReview(
+  obj: null | Record<string, unknown>,
+  defaultFixMsg = "Retry or check configuration.",
+): [boolean, Verdict, ReviewData] {
+  if (!obj) {
+    logWarn("coerce", "No object provided to coerceToReview");
+    return [
+      false,
+      "error",
+      {
+        verdict: "fail",
+        summary: "No structured output returned.",
+        summary_source: "default",
+        issues: [
+          {
+            severity: "high",
+            category: "tooling",
+            issue: "Reviewer returned no JSON.",
+            suggested_fix: defaultFixMsg,
+          },
+        ],
+        missing_sections: [],
+        questions: [],
+      },
+    ];
+  }
+
+  const rawVerdict = obj.verdict;
+  let verdict: Verdict;
+  if (rawVerdict === "pass" || rawVerdict === "warn" || rawVerdict === "fail") {
+    verdict = rawVerdict;
+  } else {
+    logWarn(
+      "coerce",
+      `Invalid or missing verdict '${String(rawVerdict)}', defaulting to 'warn'`,
+    );
+    verdict = "warn";
+  }
+
+  // Log when fields are being defaulted
+  const summaryRaw = String(obj.summary ?? "").trim();
+  if (!summaryRaw) {
+    logWarn(
+      "coerce",
+      "summary missing or empty from parsed output, using default",
+    );
+    logDebug("coerce", `Raw object keys: ${JSON.stringify(Object.keys(obj))}`);
+    logDebug(
+      "coerce",
+      `verdict=${obj.verdict}, issues_count=${Array.isArray(obj.issues) ? (obj.issues as unknown[]).length : 0}`,
+    );
+  }
+
+  if (!obj.issues) {
+    logDebug("coerce", "issues array empty or missing");
+  }
+
+  const norm: ReviewData = {
+    verdict,
+    summary: summaryRaw || "No summary provided.",
+    summary_source: summaryRaw ? "reviewer" : "default",
+    issues: Array.isArray(obj.issues)
+      ? (obj.issues as ReviewData["issues"])
+      : [],
+    missing_sections: Array.isArray(obj.missing_sections)
+      ? (obj.missing_sections as string[])
+      : [],
+    questions: Array.isArray(obj.questions)
+      ? (obj.questions as string[])
+      : [],
+  };
+
+  return [true, verdict, norm];
+}

package/dist/templates/cc-native/_cc-native/lib-ts/nul

@@ -0,0 +1,3 @@
+FINDSTR: Cannot open I:/
+FINDSTR: Cannot open \.py
+FINDSTR: Cannot open reviewers*.ts

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

@@ -0,0 +1,250 @@
+/**
+ * Plan orchestrator — analyzes complexity and selects reviewer agents.
+ * See cc-native-plan-review-spec.md §4.8
+ */
+
+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 type { AgentConfig, OrchestratorConfig, OrchestratorResult, ComplexityCategory } from "./types.js";
+import { ORCHESTRATOR_SCHEMA } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const DEFAULT_AGENT_SELECTION: Record<string, unknown> = {
+  simple: { min: 3, max: 3 },
+  medium: { min: 8, max: 8 },
+  high: { min: 12, max: 12 },
+  fallbackCount: 3,
+};
+
+const DEFAULT_COMPLEXITY_CATEGORIES = [
+  "code",
+  "infrastructure",
+  "documentation",
+  "life",
+  "business",
+  "design",
+  "research",
+];
+
+// ---------------------------------------------------------------------------
+// Schema Builder
+// ---------------------------------------------------------------------------
+
+/**
+ * Build orchestrator JSON schema with enum-constrained agent names.
+ */
+export function buildOrchestratorSchema(
+  validAgentNames: string[],
+  categories: string[],
+): Record<string, unknown> {
+  const itemsSchema: Record<string, unknown> = { type: "string" };
+  if (validAgentNames.length > 0) {
+    itemsSchema.enum = validAgentNames;
+  }
+
+  return {
+    type: "object",
+    properties: {
+      complexity: { type: "string", enum: ["simple", "medium", "high"] },
+      category: { type: "string", enum: categories },
+      selectedAgents: {
+        type: "array",
+        items: itemsSchema,
+      },
+      reasoning: { type: "string" },
+      skipReason: { type: "string" },
+    },
+    required: ["complexity", "category", "selectedAgents", "reasoning"],
+    additionalProperties: false,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Orchestrator
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the orchestrator agent to analyze plan complexity and select reviewers.
+ * Never throws — returns fallback OrchestratorResult on failure.
+ */
+export async function runOrchestrator(
+  plan: string,
+  agentLibrary: AgentConfig[],
+  config: OrchestratorConfig,
+  settings: Record<string, unknown>,
+  mandatoryNames?: Set<string>,
+): Promise<OrchestratorResult> {
+  logInfo("orchestrator", "Starting plan analysis...");
+
+  const mandatory = mandatoryNames ?? new Set<string>();
+  const selection = (settings.agentSelection as Record<string, unknown>) ?? DEFAULT_AGENT_SELECTION;
+  const categories = (settings.complexityCategories as string[]) ?? DEFAULT_COMPLEXITY_CATEGORIES;
+  const fallbackCount = (selection.fallbackCount as number) ?? 2;
+
+  // Filter out mandatory agents — they always run
+  const nonMandatory = agentLibrary.filter(
+    (a) => a.enabled && !mandatory.has(a.name),
+  );
+  const validNames = nonMandatory.map((a) => a.name);
+
+  logDebug("orchestrator", `Mandatory agents (always run): ${[...mandatory].sort().join(", ")}`);
+  logDebug("orchestrator", `Non-mandatory agents for selection: ${validNames.join(", ")}`);
+
+  const claudePath = findExecutable("claude");
+  if (!claudePath) {
+    logWarn(
+      "orchestrator",
+      "Claude CLI not found on PATH, falling back to medium complexity",
+    );
+    return makeFallback(nonMandatory, fallbackCount, "Orchestrator skipped - Claude CLI not found", "claude CLI not found on PATH");
+  }
+
+  logDebug("orchestrator", `Found Claude CLI at: ${claudePath}`);
+
+  // Build agent list from non-mandatory agents
+  const agentList = nonMandatory
+    .map(
+      (a) =>
+        `- ${a.name} [${a.categories.join(", ")}]\n  Focus: ${a.focus}\n  Expertise: ${a.description}`,
+    )
+    .join("\n");
+  const categoryList = categories.join("/");
+
+  // Compute additional agent counts
+  const mandatoryCount = agentLibrary.filter((a) => mandatory.has(a.name)).length;
+  const simpleAdditional = Math.max(0, ((selection.simple as Record<string, number> | undefined)?.max ?? 3) - mandatoryCount);
+  const mediumAdditional = Math.max(0, ((selection.medium as Record<string, number> | undefined)?.max ?? 8) - mandatoryCount);
+  const highAdditional = Math.max(0, ((selection.high as Record<string, number> | undefined)?.max ?? 12) - mandatoryCount);
+
+  const systemPrompt = `You are a plan orchestrator for code review. Your job is to analyze plans and select appropriate reviewer agents.
+
+You MUST call StructuredOutput immediately with your analysis. Do NOT ask questions or use any other tools.
+
+When selecting agents:
+- Match agent expertise to plan requirements
+- Consider what each agent specializes in
+- Only select agents whose categories match the plan category
+- Fewer agents for simple plans, more for complex plans`;
+
+  const prompt = `Analyze this plan and select appropriate reviewer agents.
+
+Available agents (select ONLY from this list):
+${agentList}
+
+Selection rules (number of ADDITIONAL agents to select from the list above):
+- simple complexity = ${simpleAdditional} agents
+- medium complexity = ${mediumAdditional} agents
+- high complexity = ${highAdditional} agents
+- Only select agents whose categories match the plan category (${categoryList})
+- Non-technical plans (life, business) typically need 0 code-focused agents
+- Note: mandatory agents run separately and are NOT listed above
+
+PLAN:
+<<<
+${plan}
+>>>
+
+Call StructuredOutput now with: complexity, category, selectedAgents, reasoning`;
+
+  const schema =
+    validNames.length > 0
+      ? buildOrchestratorSchema(validNames, categories)
+      : ORCHESTRATOR_SCHEMA;
+  const schemaJson = JSON.stringify(schema);
+
+  const cmdArgs = [
+    "--model", config.model,
+    "--output-format", "json",
+    "--json-schema", schemaJson,
+    "--max-turns", "3",
+    "--setting-sources", "",
+    "--system-prompt", systemPrompt,
+    "-p",
+  ];
+
+  logInfo("orchestrator", `Running with model: ${config.model}, timeout: ${config.timeout}s`);
+
+  const env = getInternalSubprocessEnv();
+
+  const result = await execFileAsync(claudePath, cmdArgs, {
+    input: prompt,
+    timeout: config.timeout * 1000,
+    env: env as Record<string, string>,
+    maxBuffer: 10 * 1024 * 1024,
+    shell: process.platform === "win32",
+  });
+
+  if (result.killed || result.signal === "SIGTERM") {
+    logWarn("orchestrator", `TIMEOUT after ${config.timeout}s, falling back to medium complexity`);
+    return makeFallback(nonMandatory, fallbackCount, "Orchestrator timed out - defaulting to medium complexity", `Orchestrator timed out after ${config.timeout}s`);
+  }
+
+  const raw = result.stdout.trim();
+  if (result.stderr) logDebug("orchestrator", `stderr: ${result.stderr.slice(0, 300)}`);
+
+  if (!raw && !result.stderr && result.exitCode !== 0) {
+    logError("orchestrator", `Process exited with code ${result.exitCode}, falling back to medium complexity`);
+    return makeFallback(nonMandatory, fallbackCount, `Orchestrator failed (exit ${result.exitCode})`, `Exit code ${result.exitCode}`);
+  }
+
+  const obj = parseCliOutput(raw);
+
+  logDebug("orchestrator", `Raw output length: ${raw.length} chars`);
+  if (raw) logDebug("orchestrator", `Raw output (first 500 chars): ${raw.slice(0, 500)}`);
+  logDebug("orchestrator", `Parsed obj: ${JSON.stringify(obj)}`);
+
+  if (!obj) {
+    logWarn("orchestrator", "Failed to parse output, falling back to medium complexity");
+    return makeFallback(nonMandatory, fallbackCount, "Orchestrator output could not be parsed", "Failed to parse orchestrator output");
+  }
+
+  // Extract and validate fields
+  const rawComplexity = String(obj.complexity ?? "medium");
+  const complexity: ComplexityCategory =
+    rawComplexity === "simple" || rawComplexity === "medium" || rawComplexity === "high"
+      ? rawComplexity
+      : "medium";
+
+  let category = (obj.category as string) ?? "code";
+  if (!categories.includes(category)) category = "code";
+
+  let selectedAgents = obj.selectedAgents;
+  if (!Array.isArray(selectedAgents)) selectedAgents = [];
+
+  const reasoning = String(obj.reasoning ?? "").trim() || "No reasoning provided";
+  const skipReason = obj.skipReason as string | undefined;
+
+  logInfo("orchestrator", `Result: complexity=${complexity}, category=${category}, agents=${JSON.stringify(selectedAgents)}`);
+  logDebug("orchestrator", `Reasoning: ${reasoning}`);
+
+  return {
+    complexity,
+    category,
+    selected_agents: selectedAgents as string[],
+    reasoning,
+    skip_reason: skipReason || undefined,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function makeFallback(
+  nonMandatory: AgentConfig[],
+  fallbackCount: number,
+  reasoning: string,
+  error: string,
+): OrchestratorResult {
+  return {
+    complexity: "medium",
+    category: "code",
+    selected_agents: nonMandatory.slice(0, fallbackCount).map((a) => a.name),
+    reasoning,
+    error,
+  };
+}