aiwcli 0.9.0

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

@@ -0,0 +1,273 @@
+"""
+CC-Native Plan Orchestrator Module.
+
+Analyzes plan complexity and selects appropriate reviewers.
+"""
+
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+# Import from parent lib
+_lib_dir = Path(__file__).resolve().parent
+sys.path.insert(0, str(_lib_dir))
+
+from utils import OrchestratorResult, eprint, parse_json_maybe
+from reviewers.base import AgentConfig, OrchestratorConfig
+
+
+# ---------------------------
+# Constants
+# ---------------------------
+
+DEFAULT_AGENT_SELECTION: Dict[str, Any] = {
+    "simple": {"min": 3, "max": 3},
+    "medium": {"min": 8, "max": 8},
+    "high": {"min": 12, "max": 12},
+    "fallbackCount": 3,
+}
+
+DEFAULT_COMPLEXITY_CATEGORIES: List[str] = [
+    "code",
+    "infrastructure",
+    "documentation",
+    "life",
+    "business",
+    "design",
+    "research",
+]
+
+ORCHESTRATOR_SCHEMA: Dict[str, Any] = {
+    "type": "object",
+    "properties": {
+        "complexity": {"type": "string", "enum": ["simple", "medium", "high"]},
+        "category": {"type": "string", "enum": DEFAULT_COMPLEXITY_CATEGORIES},
+        "selectedAgents": {"type": "array", "items": {"type": "string"}},
+        "reasoning": {"type": "string"},
+        "skipReason": {"type": "string"},
+    },
+    "required": ["complexity", "category", "selectedAgents", "reasoning"],
+    "additionalProperties": False,
+}
+
+
+# ---------------------------
+# Output Parsing
+# ---------------------------
+
+def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
+    """Parse Claude CLI JSON output, handling various formats.
+
+    Claude CLI can output in several formats:
+    - Direct structured_output dict
+    - Assistant message with StructuredOutput tool use
+    - List of events with assistant messages
+
+    Args:
+        raw: Raw stdout from Claude CLI
+
+    Returns:
+        Parsed JSON dict or None if parsing failed
+    """
+    try:
+        result = json.loads(raw)
+        if isinstance(result, dict):
+            if "structured_output" in result:
+                eprint("[orchestrator:parse] Found structured_output in root dict")
+                return result["structured_output"]
+            if result.get("type") == "assistant":
+                message = result.get("message", {})
+                content = message.get("content", [])
+                for item in content:
+                    if isinstance(item, dict) and item.get("name") == "StructuredOutput":
+                        eprint("[orchestrator:parse] Found StructuredOutput in assistant message content")
+                        return item.get("input", {})
+                eprint("[orchestrator:parse] Assistant message found but no StructuredOutput tool use in content")
+        elif isinstance(result, list):
+            eprint(f"[orchestrator:parse] Received list of {len(result)} events, searching for assistant message")
+            for i, event in enumerate(result):
+                if not isinstance(event, dict):
+                    continue
+                if event.get("type") == "assistant":
+                    message = event.get("message", {})
+                    content = message.get("content", [])
+                    for item in content:
+                        if isinstance(item, dict) and item.get("name") == "StructuredOutput":
+                            eprint(f"[orchestrator:parse] Found StructuredOutput in event[{i}] assistant message")
+                            return item.get("input", {})
+            eprint("[orchestrator:parse] No StructuredOutput found in any assistant message in event list")
+    except json.JSONDecodeError as e:
+        eprint(f"[orchestrator:parse] JSON decode error: {e}")
+    except Exception as e:
+        eprint(f"[orchestrator:parse] Unexpected error during structured parsing: {e}")
+
+    # Fallback to heuristic extraction
+    eprint("[orchestrator:parse] No structured output found, falling back to heuristic JSON extraction")
+    return parse_json_maybe(raw)
+
+
+# ---------------------------
+# Orchestrator
+# ---------------------------
+
+def run_orchestrator(
+    plan: str,
+    agent_library: List[AgentConfig],
+    config: OrchestratorConfig,
+    settings: Dict[str, Any],
+) -> OrchestratorResult:
+    """Run the orchestrator agent to analyze plan complexity and select reviewers.
+
+    Args:
+        plan: The plan content to analyze
+        agent_library: List of available agents
+        config: Orchestrator configuration (model, timeout, max_turns)
+        settings: Agent review settings (agentSelection, complexityCategories)
+
+    Returns:
+        OrchestratorResult with complexity, category, and selected agents
+    """
+    eprint("[orchestrator] Starting plan analysis...")
+
+    selection = settings.get("agentSelection", DEFAULT_AGENT_SELECTION)
+    categories = settings.get("complexityCategories", DEFAULT_COMPLEXITY_CATEGORIES)
+    fallback_count = selection.get("fallbackCount", 2)
+
+    claude_path = shutil.which("claude")
+    if claude_path is None:
+        eprint("[orchestrator] Claude CLI not found on PATH, falling back to medium complexity")
+        return OrchestratorResult(
+            complexity="medium",
+            category="code",
+            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            reasoning="Orchestrator skipped - Claude CLI not found",
+            error="claude CLI not found on PATH",
+        )
+
+    eprint(f"[orchestrator] Found Claude CLI at: {claude_path}")
+
+    # Build agent list for prompt
+    agent_list = "\n".join([
+        f"- {a.name}: {a.focus} (categories: {', '.join(a.categories)})"
+        for a in agent_library if a.enabled
+    ])
+    category_list = "/".join(categories)
+    simple_range = f"{selection.get('simple', {}).get('min', 0)}-{selection.get('simple', {}).get('max', 0)}"
+    medium_range = f"{selection.get('medium', {}).get('min', 1)}-{selection.get('medium', {}).get('max', 2)}"
+    high_range = f"{selection.get('high', {}).get('min', 2)}-{selection.get('high', {}).get('max', 4)}"
+
+    prompt = f"""IMPORTANT: Analyze this plan and output your decision immediately using StructuredOutput. Do NOT ask questions.
+
+You are a plan orchestrator. Analyze the plan below and determine:
+1. Complexity level (simple/medium/high)
+2. Category ({category_list})
+3. Which agents (if any) should review this plan
+
+Available agents:
+{agent_list}
+
+Rules:
+- simple complexity = {simple_range} agents (CLI review sufficient)
+- medium complexity = {medium_range} agents
+- high complexity = {high_range} agents
+- Only select agents whose categories match the plan category
+- Non-technical plans (life, business) typically need 0 code-focused agents
+
+Analyze and call StructuredOutput with your decision now.
+
+PLAN:
+<<<
+{plan}
+>>>
+"""
+
+    schema_json = json.dumps(ORCHESTRATOR_SCHEMA, ensure_ascii=False)
+
+    cmd_args = [
+        claude_path,
+        "--agent", "plan-orchestrator",
+        "--model", config.model,
+        "--permission-mode", "bypassPermissions",
+        "--output-format", "json",
+        "--max-turns", str(config.max_turns),
+        "--json-schema", schema_json,
+        "--settings", "{}",
+    ]
+
+    eprint(f"[orchestrator] Running with model: {config.model}, timeout: {config.timeout}s")
+
+    try:
+        p = subprocess.run(
+            cmd_args,
+            input=prompt,
+            text=True,
+            capture_output=True,
+            timeout=config.timeout,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except subprocess.TimeoutExpired:
+        eprint(f"[orchestrator] TIMEOUT after {config.timeout}s, falling back to medium complexity")
+        return OrchestratorResult(
+            complexity="medium",
+            category="code",
+            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            reasoning="Orchestrator timed out - defaulting to medium complexity",
+            error=f"Orchestrator timed out after {config.timeout}s",
+        )
+    except Exception as ex:
+        eprint(f"[orchestrator] EXCEPTION: {ex}, falling back to medium complexity")
+        return OrchestratorResult(
+            complexity="medium",
+            category="code",
+            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            reasoning=f"Orchestrator failed: {ex}",
+            error=str(ex),
+        )
+
+    eprint(f"[orchestrator] Exit code: {p.returncode}")
+
+    raw = (p.stdout or "").strip()
+    if p.stderr:
+        eprint(f"[orchestrator] stderr: {p.stderr[:300]}")
+
+    obj = _parse_claude_output(raw)
+    if not obj:
+        eprint("[orchestrator] Failed to parse output, falling back to medium complexity")
+        return OrchestratorResult(
+            complexity="medium",
+            category="code",
+            selected_agents=[a.name for a in agent_library if a.enabled][:fallback_count],
+            reasoning="Orchestrator output could not be parsed",
+            error="Failed to parse orchestrator output",
+        )
+
+    # Extract and validate fields
+    complexity = obj.get("complexity", "medium")
+    if complexity not in ("simple", "medium", "high"):
+        complexity = "medium"
+
+    category = obj.get("category", "code")
+    if category not in categories:
+        category = "code"
+
+    selected_agents = obj.get("selectedAgents", [])
+    if not isinstance(selected_agents, list):
+        selected_agents = []
+
+    reasoning = str(obj.get("reasoning", "")).strip() or "No reasoning provided"
+    skip_reason = obj.get("skipReason")
+
+    eprint(f"[orchestrator] Result: complexity={complexity}, category={category}, agents={selected_agents}")
+    eprint(f"[orchestrator] Reasoning: {reasoning}")
+
+    return OrchestratorResult(
+        complexity=complexity,
+        category=category,
+        selected_agents=selected_agents,
+        reasoning=reasoning,
+        skip_reason=skip_reason if skip_reason else None,
+    )

package/dist/templates/cc-native/_cc-native/lib/reviewers/__init__.py

@@ -0,0 +1,28 @@
+"""CC-Native Plan Reviewers Module.
+
+Provides CLI and agent-based plan review implementations.
+"""
+
+from .base import (
+    ReviewerResult,
+    REVIEW_SCHEMA,
+    REVIEW_PROMPT_PREFIX,
+    AGENT_REVIEW_PROMPT_PREFIX,
+    AgentConfig,
+    OrchestratorConfig,
+)
+from .codex import run_codex_review
+from .gemini import run_gemini_review
+from .agent import run_agent_review
+
+__all__ = [
+    "ReviewerResult",
+    "REVIEW_SCHEMA",
+    "REVIEW_PROMPT_PREFIX",
+    "AGENT_REVIEW_PROMPT_PREFIX",
+    "AgentConfig",
+    "OrchestratorConfig",
+    "run_codex_review",
+    "run_gemini_review",
+    "run_agent_review",
+]

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

@@ -0,0 +1,164 @@
+"""
+CC-Native Agent Reviewer Module.
+
+Runs Claude Code agents to review plans.
+"""
+
+import json
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+# Import from parent lib
+_lib_dir = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(_lib_dir))
+
+from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from .base import AgentConfig, AGENT_REVIEW_PROMPT_PREFIX
+
+
+def _parse_claude_output(raw: str) -> Optional[Dict[str, Any]]:
+    """Parse Claude CLI JSON output, handling various formats.
+
+    Claude CLI can output in several formats:
+    - Direct structured_output dict
+    - Assistant message with StructuredOutput tool use
+    - List of events with assistant messages
+
+    Args:
+        raw: Raw stdout from Claude CLI
+
+    Returns:
+        Parsed JSON dict or None if parsing failed
+    """
+    try:
+        result = json.loads(raw)
+        if isinstance(result, dict):
+            if "structured_output" in result:
+                eprint("[parse] Found structured_output in root dict")
+                return result["structured_output"]
+            if result.get("type") == "assistant":
+                message = result.get("message", {})
+                content = message.get("content", [])
+                for item in content:
+                    if isinstance(item, dict) and item.get("name") == "StructuredOutput":
+                        eprint("[parse] Found StructuredOutput in assistant message content")
+                        return item.get("input", {})
+                eprint("[parse] Assistant message found but no StructuredOutput tool use in content")
+        elif isinstance(result, list):
+            eprint(f"[parse] Received list of {len(result)} events, searching for assistant message")
+            for i, event in enumerate(result):
+                if not isinstance(event, dict):
+                    continue
+                if event.get("type") == "assistant":
+                    message = event.get("message", {})
+                    content = message.get("content", [])
+                    for item in content:
+                        if isinstance(item, dict) and item.get("name") == "StructuredOutput":
+                            eprint(f"[parse] Found StructuredOutput in event[{i}] assistant message")
+                            return item.get("input", {})
+            eprint("[parse] No StructuredOutput found in any assistant message in event list")
+    except json.JSONDecodeError as e:
+        eprint(f"[parse] JSON decode error: {e}")
+    except Exception as e:
+        eprint(f"[parse] Unexpected error during structured parsing: {e}")
+
+    # Fallback to heuristic extraction with required field validation
+    eprint("[parse] No structured output found, falling back to heuristic JSON extraction")
+    return parse_json_maybe(raw, require_fields=["verdict", "summary"])
+
+
+def run_agent_review(
+    plan: str,
+    agent: AgentConfig,
+    schema: Dict[str, Any],
+    timeout: int,
+    max_turns: int = 3,
+) -> ReviewerResult:
+    """Run a single Claude Code agent to review the plan.
+
+    Args:
+        plan: The plan content to review
+        agent: Agent configuration (name, model, etc.)
+        schema: JSON schema for the review output
+        timeout: Timeout in seconds
+        max_turns: Maximum agent turns
+
+    Returns:
+        ReviewerResult with the review output
+    """
+    claude_path = shutil.which("claude")
+    if claude_path is None:
+        eprint(f"[{agent.name}] Claude CLI not found on PATH")
+        return ReviewerResult(
+            name=agent.name,
+            ok=False,
+            verdict="skip",
+            data={},
+            raw="",
+            err="claude CLI not found on PATH",
+        )
+
+    eprint(f"[{agent.name}] Found Claude CLI at: {claude_path}")
+
+    prompt = f"""{AGENT_REVIEW_PROMPT_PREFIX}
+
+PLAN:
+<<<
+{plan}
+>>>
+"""
+
+    schema_json = json.dumps(schema, ensure_ascii=False)
+    cmd_args = [
+        claude_path,
+        "--agent", agent.name,
+        "--model", agent.model,
+        "--permission-mode", "bypassPermissions",
+        "--output-format", "json",
+        "--max-turns", str(max_turns),
+        "--json-schema", schema_json,
+        "--settings", "{}",
+    ]
+
+    eprint(f"[{agent.name}] Running with model: {agent.model}, timeout: {timeout}s, max-turns: {max_turns}")
+
+    try:
+        p = subprocess.run(
+            cmd_args,
+            input=prompt,
+            text=True,
+            capture_output=True,
+            timeout=timeout,
+            encoding="utf-8",
+            errors="replace",
+        )
+    except subprocess.TimeoutExpired:
+        eprint(f"[{agent.name}] TIMEOUT after {timeout}s")
+        return ReviewerResult(agent.name, False, "error", {}, "", f"{agent.name} timed out after {timeout}s")
+    except Exception as ex:
+        eprint(f"[{agent.name}] EXCEPTION: {ex}")
+        return ReviewerResult(agent.name, False, "error", {}, "", f"{agent.name} failed to run: {ex}")
+
+    eprint(f"[{agent.name}] Exit code: {p.returncode}")
+    eprint(f"[{agent.name}] stdout length: {len(p.stdout or '')} chars")
+    if p.stderr:
+        eprint(f"[{agent.name}] stderr: {p.stderr[:500]}")
+
+    raw = (p.stdout or "").strip()
+    err = (p.stderr or "").strip()
+
+    if raw:
+        eprint(f"[{agent.name}] stdout preview: {raw[:500]}")
+
+    obj = _parse_claude_output(raw)
+    if obj:
+        eprint(f"[{agent.name}] Parsed JSON successfully, verdict: {obj.get('verdict', 'N/A')}")
+    else:
+        eprint(f"[{agent.name}] Failed to parse JSON from output")
+
+    ok, verdict, norm = coerce_to_review(obj, "Retry or check agent configuration.")
+
+    return ReviewerResult(agent.name, ok, verdict, norm, raw, err)

package/dist/templates/cc-native/_cc-native/lib/reviewers/base.py

@@ -0,0 +1,89 @@
+"""
+CC-Native Reviewers Base Module.
+
+Provides shared constants and types for plan reviewers.
+"""
+
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List
+
+# Import from parent lib
+_lib_dir = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(_lib_dir))
+
+from utils import ReviewerResult, REVIEW_SCHEMA
+
+# Re-export for convenience
+__all__ = [
+    "ReviewerResult",
+    "REVIEW_SCHEMA",
+    "REVIEW_PROMPT_PREFIX",
+    "AGENT_REVIEW_PROMPT_PREFIX",
+    "AgentConfig",
+    "OrchestratorConfig",
+]
+
+
+# ---------------------------
+# Agent Configuration
+# ---------------------------
+
+@dataclass
+class AgentConfig:
+    """Configuration for a Claude Code review agent."""
+    name: str
+    model: str = "sonnet"
+    focus: str = ""
+    enabled: bool = True
+    categories: List[str] = field(default_factory=lambda: ["code"])
+    description: str = ""
+    tools: str = ""
+
+
+@dataclass
+class OrchestratorConfig:
+    """Configuration for the plan orchestrator."""
+    enabled: bool = True
+    model: str = "haiku"
+    timeout: int = 30
+    max_turns: int = 3
+
+
+# ---------------------------
+# Shared Review Prompt Text
+# ---------------------------
+
+REVIEW_PROMPT_PREFIX = """You are a senior staff software engineer acting as a strict plan reviewer.
+
+Review the PLAN below. Focus on:
+- missing steps, unclear assumptions, edge cases
+- security/privacy concerns
+- testing/rollout/rollback completeness
+- operational concerns (observability, failure modes)
+"""
+
+AGENT_REVIEW_PROMPT_PREFIX = """# SINGLE-TURN PLAN REVIEW
+
+## CRITICAL: ONE TURN ONLY
+You have exactly ONE response to complete this review. Do NOT attempt multi-step workflows, context queries, or phased analysis. Analyze the plan and output your review immediately.
+
+## YOUR TASK
+Review the plan below from your area of expertise. Then call StructuredOutput with your assessment.
+
+## REQUIRED OUTPUT (all fields must have content)
+Call StructuredOutput with:
+- **verdict**: "pass" (no concerns), "warn" (some concerns), or "fail" (critical issues)
+- **summary**: 2-3 sentences with your overall assessment and key findings (REQUIRED)
+- **issues**: Array of concerns found. Format each as:
+  {"severity": "high/medium/low", "category": "...", "issue": "...", "suggested_fix": "..."}
+- **missing_sections**: Topics the plan should address but doesn't
+- **questions**: Things that need clarification before implementation
+
+## IMPORTANT RULES
+1. A "warn" verdict MUST include at least one issue explaining why
+2. Summary MUST explain your reasoning, not just "looks good" or empty
+3. Focus on your expertise area (architecture, security, performance, etc.)
+4. Output StructuredOutput NOW - no other tools, no questions, no delays
+"""

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

@@ -0,0 +1,119 @@
+"""
+CC-Native Codex Reviewer Module.
+
+Runs Codex CLI to review plans.
+"""
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, Dict
+
+# Import from parent lib
+_lib_dir = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(_lib_dir))
+
+from utils import ReviewerResult, eprint, parse_json_maybe, coerce_to_review
+from .base import REVIEW_PROMPT_PREFIX
+
+
+def run_codex_review(
+    plan: str,
+    schema: Dict[str, Any],
+    settings: Dict[str, Any],
+) -> ReviewerResult:
+    """Run Codex CLI to review the plan.
+
+    Args:
+        plan: The plan content to review
+        schema: JSON schema for the review output
+        settings: Codex reviewer settings (timeout, model)
+
+    Returns:
+        ReviewerResult with the review output
+    """
+    codex_settings = settings.get("reviewers", {}).get("codex", {})
+    timeout = codex_settings.get("timeout", 120)
+    model = codex_settings.get("model", "")
+
+    codex_path = shutil.which("codex")
+    if codex_path is None:
+        eprint("[codex] CLI not found on PATH")
+        return ReviewerResult(
+            name="codex",
+            ok=False,
+            verdict="skip",
+            data={},
+            raw="",
+            err="codex CLI not found on PATH",
+        )
+
+    eprint(f"[codex] Found CLI at: {codex_path}")
+
+    prompt = f"""{REVIEW_PROMPT_PREFIX}
+Return ONLY a JSON object that matches this JSON Schema:
+{json.dumps(schema, ensure_ascii=False)}
+
+PLAN:
+<<<
+{plan}
+>>>
+"""
+
+    with tempfile.TemporaryDirectory() as td:
+        td_path = Path(td)
+        schema_path = td_path / "schema.json"
+        out_path = td_path / "codex_review.json"
+
+        schema_path.write_text(json.dumps(schema, indent=2), encoding="utf-8")
+
+        cmd = [
+            codex_path,
+            "exec",
+            "--full-auto",
+            "--sandbox",
+            "read-only",
+            "--output-schema",
+            str(schema_path),
+            "-o",
+            str(out_path),
+            "-",
+        ]
+
+        if model:
+            cmd.insert(2, "--model")
+            cmd.insert(3, model)
+
+        eprint(f"[codex] Running command: {' '.join(cmd)}")
+
+        try:
+            p = subprocess.run(
+                cmd,
+                input=prompt,
+                text=True,
+                capture_output=True,
+                timeout=timeout,
+                encoding='utf-8',
+                errors='replace',
+            )
+        except subprocess.TimeoutExpired:
+            eprint(f"[codex] TIMEOUT after {timeout}s")
+            return ReviewerResult("codex", False, "error", {}, "", f"codex timed out after {timeout}s")
+        except Exception as ex:
+            eprint(f"[codex] EXCEPTION: {ex}")
+            return ReviewerResult("codex", False, "error", {}, "", f"codex failed to run: {ex}")
+
+        eprint(f"[codex] Exit code: {p.returncode}")
+
+        raw = ""
+        if out_path.exists():
+            raw = out_path.read_text(encoding="utf-8", errors="replace")
+
+        obj = parse_json_maybe(raw) or parse_json_maybe(p.stdout)
+        ok, verdict, norm = coerce_to_review(obj, "Retry or check CLI auth/config.")
+
+        err = (p.stderr or "").strip()
+        return ReviewerResult("codex", ok, verdict, norm, raw or p.stdout, err)