aiwcli 0.9.0

package/dist/templates/cc-native/_cc-native/plan-review.config.json

@@ -0,0 +1,76 @@
+{
+  "planReview": {
+    "enabled": true,
+    "reviewers": {
+      "codex": {
+        "enabled": true,
+        "model": "o4-mini",
+        "timeout": 120
+      },
+      "gemini": {
+        "enabled": false,
+        "model": "",
+        "timeout": 120
+      }
+    },
+    "blockOnFail": false,
+    "display": {
+      "maxIssues": 12,
+      "maxMissingSections": 12,
+      "maxQuestions": 12
+    }
+  },
+  "agentReview": {
+    "enabled": true,
+    "timeout": 120,
+    "blockOnFail": true,
+    "maxTurns": 3,
+    "orchestrator": {
+      "enabled": true,
+      "model": "haiku",
+      "timeout": 30,
+      "maxTurns": 6
+    },
+    "legacyMode": false,
+    "reviewIterations": {
+      "simple": 1,
+      "medium": 1,
+      "high": 2
+    },
+    "earlyExitOnAllPass": true,
+    "display": {
+      "maxIssues": 12,
+      "maxMissingSections": 12,
+      "maxQuestions": 12
+    }
+  },
+  "agentSelection": {
+    "simple": { "min": 3, "max": 3 },
+    "medium": { "min": 8, "max": 8 },
+    "high": { "min": 12, "max": 12 },
+    "fallbackCount": 3
+  },
+  "agentDefaults": {
+    "model": "sonnet"
+  },
+  "complexityCategories": [
+    "code", "infrastructure", "documentation",
+    "life", "business", "design", "research"
+  ],
+  "sanitization": {
+    "maxSessionIdLength": 32,
+    "maxTitleLength": 50
+  },
+  "planContext": {
+    "enabled": true,
+    "offerClarifyingQuestions": true
+  },
+  "stuckDetection": {
+    "enabled": true,
+    "errorThreshold": 3,
+    "fileEditThreshold": 4,
+    "testFailureThreshold": 3,
+    "cooldown": 10,
+    "maxSuggestions": 3
+  }
+}

package/dist/templates/cc-native/_cc-native/scripts/aggregate_agents.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Aggregate Agents - Auto-detect agent configurations from frontmatter.
+
+Reads all agent markdown files from .claude/agents/ and extracts their
+YAML frontmatter to provide agent configuration for the hook system.
+
+Used by cc-native-plan-review.py to auto-detect available agents
+instead of requiring manual config.json entries.
+
+Note: Uses simple YAML parsing without external dependencies.
+"""
+
+import re
+from pathlib import Path
+from typing import Any
+
+
+def parse_simple_yaml(yaml_str: str) -> dict[str, Any]:
+    """Parse simple YAML frontmatter without external dependencies.
+
+    Supports:
+    - Key: value pairs
+    - Lists (using - item syntax)
+    - Boolean values (true/false)
+    - Nested lists under keys
+
+    Args:
+        yaml_str: YAML string to parse
+
+    Returns:
+        Parsed dict
+    """
+    result: dict[str, Any] = {}
+    current_key = None
+    current_list: list[str] | None = None
+
+    for line in yaml_str.split('\n'):
+        # Skip empty lines
+        if not line.strip():
+            continue
+
+        # Check if this is a list item (starts with -)
+        list_match = re.match(r'^(\s*)-\s+(.+)$', line)
+        if list_match:
+            indent = len(list_match.group(1))
+            value = list_match.group(2).strip()
+            if current_key and indent > 0:
+                if current_list is None:
+                    current_list = []
+                    result[current_key] = current_list
+                current_list.append(value)
+            continue
+
+        # Check if this is a key: value pair
+        kv_match = re.match(r'^(\w+):\s*(.*)$', line)
+        if kv_match:
+            key = kv_match.group(1)
+            value = kv_match.group(2).strip()
+            current_key = key
+            current_list = None
+
+            if value:
+                # Parse the value
+                if value.lower() == 'true':
+                    result[key] = True
+                elif value.lower() == 'false':
+                    result[key] = False
+                elif value.isdigit():
+                    result[key] = int(value)
+                else:
+                    result[key] = value
+            # If no value, it might be followed by a list
+
+    return result
+
+
+def extract_frontmatter(content: str) -> dict[str, Any] | None:
+    """Extract YAML frontmatter from markdown content.
+
+    Args:
+        content: Raw markdown file content
+
+    Returns:
+        Parsed frontmatter as dict, or None if no valid frontmatter found
+    """
+    match = re.match(r'^---\s*\n(.*?)\n---\s*\n', content, re.DOTALL)
+    if not match:
+        return None
+    try:
+        return parse_simple_yaml(match.group(1))
+    except Exception:
+        return None
+
+
+def aggregate_agents(agents_dir: Path | None = None) -> list[dict[str, Any]]:
+    """Read all agent files and return aggregated metadata.
+    
+    Scans the agents directory for .md files, extracts frontmatter from each,
+    and returns a list of agent configurations.
+    
+    Args:
+        agents_dir: Path to agents directory. If None, uses default
+                   .claude/agents relative to project root.
+                   
+    Returns:
+        List of agent configuration dicts with fields:
+        - name: Agent identifier (lowercase)
+        - description: Full description for Task tool
+        - model: Claude model (haiku/sonnet/opus)
+        - focus: Brief focus for orchestrator
+        - enabled: Whether agent is available
+        - categories: Work categories for filtering
+        - tools: Available tools
+    """
+    if agents_dir is None:
+        # Default to .claude/agents/cc-native relative to this script's location
+        # Script is at: _cc-native/scripts/aggregate_agents.py
+        # Agents are at: .claude/agents/cc-native/
+        script_dir = Path(__file__).parent
+        agents_dir = script_dir.parent.parent / ".claude" / "agents" / "cc-native"
+
+    agents = []
+
+    if not agents_dir.exists():
+        return agents
+
+    for file in agents_dir.glob("*.md"):
+        try:
+            content = file.read_text(encoding="utf-8")
+            frontmatter = extract_frontmatter(content)
+            if frontmatter and frontmatter.get("name"):
+                # Ensure categories is always a list
+                if "categories" not in frontmatter:
+                    frontmatter["categories"] = ["code"]
+                elif isinstance(frontmatter["categories"], str):
+                    frontmatter["categories"] = [frontmatter["categories"]]
+                agents.append(frontmatter)
+        except Exception:
+            # Skip files that can't be read or parsed
+            continue
+
+    return agents
+
+
+if __name__ == "__main__":
+    import json
+    import sys
+    
+    agents = aggregate_agents()
+    json.dump(agents, sys.stdout, indent=2)

package/dist/templates/cc-native/_cc-native/workflows/fresh-perspective.md

@@ -0,0 +1,134 @@
+# Fresh Perspective Workflow
+
+## Purpose
+
+Combat **code bias**—the tendency to anchor problem-solving to existing patterns when you can see the current implementation. This workflow provides an unbiased perspective by:
+
+1. Extracting only the essential problem context (stripping implementation details)
+2. Sending that abstracted context to an agent with NO file access
+3. Receiving first-principles analysis unclouded by "how it's currently done"
+
+## When to Use
+
+- When you feel stuck going in circles
+- Before starting a large implementation (sanity check)
+- When incremental fixes aren't working
+- When you suspect you might be over-engineering
+- When you want validation of your approach from a fresh viewpoint
+
+## Process
+
+### Step 1: Explain the Code Bias Problem
+
+Before extracting context, briefly explain to the user:
+
+> **Why Fresh Perspective?**
+>
+> When we see existing code, we unconsciously anchor to current patterns. This makes us likely to propose incremental improvements rather than potentially better approaches. The Fresh Perspective agent has NO access to your codebase—it can only see an abstracted problem description. This intentional blindness helps surface solutions you might not consider because you're "too close" to the current implementation.
+
+### Step 2: Extract Context (Using context-extractor Agent)
+
+Invoke the `context-extractor` agent (model: haiku, tools: none) to extract abstracted context from the recent conversation.
+
+**Prompt for context-extractor:**
+```
+Review the conversation context and extract the following into JSON format:
+- problem: What is being solved (abstract, no code references)
+- stack: Technologies and frameworks in use
+- constraints: Hard constraints that cannot change
+- success_criteria: How success will be measured
+
+Strip all implementation details, file names, function names, and code snippets.
+Preserve only the problem essence.
+```
+
+### Step 3: User Reviews Extracted Context
+
+Present the extracted context to the user using AskUserQuestion:
+
+**Header:** "Context Check"
+**Question:** "Here's the abstracted context I'll send to the Fresh Perspective agent. Would you like to edit it before proceeding?"
+**Options:**
+- "Looks good, proceed" — Description: "Send this context as-is"
+- "Let me edit it" — Description: "I'll provide corrections or additions"
+
+Display the extracted JSON so the user can see exactly what will be sent:
+
+```
+Extracted Context:
+─────────────────
+Problem: [extracted problem]
+Stack: [extracted stack]
+Constraints: [extracted constraints]
+Success Criteria: [extracted success_criteria]
+```
+
+If user chooses to edit, use AskUserQuestion to gather their corrections.
+
+### Step 4: Invoke Fresh Perspective Agent
+
+Invoke the `fresh-perspective` agent (model: sonnet, tools: none) with ONLY the reviewed context.
+
+**Critical:** The fresh-perspective agent has `tools: ""` which means it cannot read any files. This is intentional—do not attempt to provide additional context.
+
+**Prompt for fresh-perspective:**
+```
+Analyze this problem from first principles and provide your perspective:
+
+{reviewed_context_json}
+
+Remember: You have NO access to the codebase. Approach this as if designing from scratch.
+Provide structured output with: Understanding, Proposed Approach, Key Design Decisions,
+Suggested Patterns, Questions to Consider, and Comparison Points.
+```
+
+### Step 5: Display Advisory Output
+
+Present the Fresh Perspective analysis with a clear disclaimer:
+
+```markdown
+# Fresh Perspective Analysis
+
+> **Advisory Only:** This analysis was generated without seeing your code.
+> Use your judgment on what applies to your specific situation.
+
+[Agent's structured output here]
+
+---
+
+**Next Steps:**
+- Compare these suggestions against your current implementation
+- Consider the questions raised before proceeding
+- Decide which insights apply to your specific context
+```
+
+### Step 6: Save Artifact
+
+Write the analysis to: `_output/cc-native/fresh-perspective/{YYYY-MM-DD}/{HHmmss}-analysis.md`
+
+Include:
+- Timestamp
+- Extracted context (what was sent)
+- Full agent response
+- User's original problem description (if different from extracted)
+
+## Output Files
+
+All artifacts go to `_output/cc-native/fresh-perspective/`:
+- `{date}/{timestamp}-analysis.md` — Complete analysis record
+
+## Success Criteria
+
+- [ ] Context was successfully abstracted (no code references leaked)
+- [ ] User reviewed and approved the context before agent invocation
+- [ ] Fresh Perspective agent provided structured analysis
+- [ ] Output clearly marked as advisory
+- [ ] Artifact saved for future reference
+
+## Relationship with Other Workflows
+
+| Workflow | When | Focus |
+|----------|------|-------|
+| **Fresh Perspective** | When stuck, before big implementations | Alternative approaches, first principles |
+| Skeptic Review | During plan review | Problem-solution alignment, assumptions |
+| Plan Review | After writing plan | Quality, completeness, issues |

package/dist/templates/cc-native/_cc-native/workflows/specdev.md

@@ -0,0 +1,9 @@
+Read this spec and interview me in detail using the AskUserQuestionTool about literally anything: 
+- Technical implementation
+- UI & UX
+- Concerns
+- Tradeoffs, etc. 
+
+But make sure the questions are not obvious
+
+Be very in-depth and continue interviewing me continually until it's complete, then write the spec to the file.

package/dist/types/exit-codes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Exit codes for AI Workflow CLI commands.
+ * Used consistently across all commands for scripting and automation.
+ */
+export declare const EXIT_CODES: {
+    readonly SUCCESS: 0;
+    readonly GENERAL_ERROR: 1;
+    readonly INVALID_USAGE: 2;
+    readonly ENVIRONMENT_ERROR: 3;
+};
+export type ExitCode = (typeof EXIT_CODES)[keyof typeof EXIT_CODES];

package/dist/types/exit-codes.js

@@ -0,0 +1,10 @@
+/**
+ * Exit codes for AI Workflow CLI commands.
+ * Used consistently across all commands for scripting and automation.
+ */
+export const EXIT_CODES = {
+    SUCCESS: 0,
+    GENERAL_ERROR: 1,
+    INVALID_USAGE: 2,
+    ENVIRONMENT_ERROR: 3,
+};

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shared type definitions for AI Workflow CLI.
+ * Re-exports all types from this module.
+ */
+export { EXIT_CODES, type ExitCode } from './exit-codes.js';

package/dist/types/index.js

@@ -0,0 +1,7 @@
+/**
+ * Shared type definitions for AI Workflow CLI.
+ * Re-exports all types from this module.
+ */
+// Exit code constants and types
+export { EXIT_CODES } from './exit-codes.js';
+// Future type re-exports will be added here as the codebase grows