diff --git a/.claude/rules/command-routing.md b/.claude/rules/command-routing.md index 34e09c0..81cbc5b 100644 --- a/.claude/rules/command-routing.md +++ b/.claude/rules/command-routing.md @@ -1,6 +1,6 @@ # Dynamic Command Routing Rules -This file defines intelligent routing logic for selecting optimal commands from **214+ commands across 25 categories**. +This file defines intelligent routing logic for selecting optimal commands from **234 commands across 27 categories**. ## Smart Routing Configuration @@ -104,11 +104,23 @@ CLASSIFICATION_TRIGGERS: prd_generation: true parallel_implementation: true quality_validation: true + + decision_frameworks: + keywords: ["decide", "trade-off", "prioritize", "analyze decision", "first principles", "80/20", "root cause", "mental model"] + route_to: /consider:* commands + + skill_management: + keywords: ["skill", "create skill", "audit skill", "heal skill", "skill authoring"] + route_to: /create-agent-skill OR /audit-skill OR /heal-skill + + context_management: + keywords: ["context", "prime", "load context", "project context"] + route_to: /context:* commands ``` --- -## Complete Command Reference (214+ Commands) +## Complete Command Reference (234 Commands) ### /sc:* - SuperClaude Commands (26 commands) Meta-routing and high-level operations. @@ -142,6 +154,27 @@ Meta-routing and high-level operations. | `/sc:troubleshoot` | Debugging | "fix", "debug", "error", "broken" | | `/sc:workflow` | Workflow generation | "workflow", "process", "pipeline" | +#### Root-Level Commands (15 commands) +Direct commands without namespace prefix. + +| Command | Purpose | Use When | +|---------|---------|----------| +| `/create-plan` | Plan creation | "create plan", "plan project" | +| `/create-prompt` | Prompt creation | "create prompt", "new prompt" | +| `/create-hook` | Hook creation | "create hook", "new hook" | +| `/create-subagent` | Subagent creation | "create agent", "new agent" | +| `/create-agent-skill` | Skill creation | "create skill", "new skill" | +| `/debug` | Debug mode | "debug", "investigate issue" | +| `/run-plan` | Execute plan | "run plan", "execute plan" | +| `/run-prompt` | Execute prompt | "run prompt" | +| `/whats-next` | Next steps | "what's next", "continue work" | +| `/check-todos` | Check todos | "check todos", "show todos" | +| `/add-to-todos` | Add todo | "add todo" | +| `/heal-skill` | Fix skills | "heal skill", "fix skill" | +| `/audit-skill` | Audit skill | "audit skill" | +| `/audit-slash-command` | Audit command | "audit command" | +| `/audit-subagent` | Audit agent | "audit agent" | + --- ### /sparc:* - SPARC Methodology (18 commands) @@ -522,6 +555,53 @@ System-level operations. --- +### /consider:* - Decision Frameworks (12 commands) +Mental models and decision-making frameworks. + +| Command | Purpose | Use When | +|---------|---------|----------| +| `/consider:first-principles` | Break down to fundamentals | "first principles", "fundamental" | +| `/consider:second-order` | Consequences of consequences | "second order", "ripple effects" | +| `/consider:opportunity-cost` | What you give up | "opportunity cost", "trade-off" | +| `/consider:pareto` | 80/20 analysis | "pareto", "80/20" | +| `/consider:eisenhower-matrix` | Urgent/important matrix | "eisenhower", "prioritize" | +| `/consider:inversion` | Solve backwards | "inversion", "reverse" | +| `/consider:occams-razor` | Simplest explanation | "occam", "simplest" | +| `/consider:5-whys` | Root cause drilling | "5 whys", "root cause" | +| `/consider:swot` | Strengths/weaknesses | "swot", "strengths" | +| `/consider:10-10-10` | Time horizon decisions | "10-10-10", "time horizon" | +| `/consider:one-thing` | Highest leverage action | "one thing", "focus" | +| `/consider:via-negativa` | Improve by removing | "via negativa", "remove" | + +--- + +### /context:* - Context Management (3 commands) +Project context and priming. + +| Command | Purpose | Use When | +|---------|---------|----------| +| `/context:create` | Create context | "create context" | +| `/context:update` | Update context | "update context" | +| `/context:prime` | Prime context | "prime", "load context" | + +--- + +### Skills Integration (8 skills) +Skills are invoked via the Skill tool for specialized guidance. + +| Skill | Trigger Keywords | Purpose | +|-------|-----------------|---------| +| `agent-sandboxes` | "sandbox", "isolated", "e2b" | E2B sandbox operations | +| `create-agent-skills` | "create skill", "skill authoring" | Skill creation guidance | +| `create-hooks` | "create hook", "hook config" | Hook development | +| `create-meta-prompts` | "meta prompt", "prompt pipeline" | Multi-stage prompts | +| `create-plans` | "create plan", "project plan" | Hierarchical planning | +| `create-slash-commands` | "create command", "slash command" | Command development | +| `create-subagents` | "create agent", "subagent" | Agent configuration | +| `debug-like-expert` | "deep debug", "root cause analysis" | Expert debugging methodology | + +--- + ## Routing Algorithm ```yaml @@ -579,3 +659,9 @@ When uncertain which command to use: | "Check status" | `/monitoring:status` | `/swarm:swarm-status` | | "What's next" | `/pm:next` | `/pm:status` | | "Not sure..." | `/sc:brainstorm` | `/sparc:innovator` | +| "First principles" | `/consider:first-principles` | `/consider:5-whys` | +| "Trade-off analysis" | `/consider:opportunity-cost` | `/consider:swot` | +| "Prioritize tasks" | `/consider:eisenhower-matrix` | `/consider:pareto` | +| "Create skill" | `/create-agent-skill` | Skill tool | +| "Create hook" | `/create-hook` | Skill tool | +| "Load context" | `/context:prime` | `/sc:load` | diff --git a/README.md b/README.md index 74b196b..ea555d7 100644 --- a/README.md +++ b/README.md @@ -10,6 +10,26 @@ This project demonstrates advanced integration of five powerful frameworks to create a development environment where AI agents collaborate systematically, maintain perfect context across sessions, and deliver production-ready code through proven methodologies. +## The C(RAID) Paradigm + +**Evolve operates on C(RAID)** - an evolution of CI/CD designed specifically for autonomous AI development: + +``` +Traditional CI/CD: Code -> Build -> Test -> Deploy +C(RAID): Research -> Analysis -> Integration -> Deployment -> (feedback) -> Research +``` + +| Traditional CI/CD | C(RAID) Paradigm | +|-------------------|------------------| +| Starts with code (human wrote it) | Starts with research (AI must understand first) | +| Human-driven development cycles | AI-driven autonomous cycles | +| Integration happens AFTER development | Research and Analysis PRECEDE coding | +| Deployment is the end goal | Deployment feeds back into Research | + +**C(RAID) + SPARC**: C(RAID) defines the continuous operational paradigm (outer loop), while SPARC provides the systematic execution methodology (inner loop). Together they enable truly autonomous development at scale. + +> **[Read the full C(RAID) Paradigm documentation](docs/paradigm/index.rst)** + ## Why This Matters **Traditional AI development**: Ad-hoc prompts, lost context, inconsistent quality diff --git a/claudedocs/01-architecture/CORE_ARCHITECTURE.md b/claudedocs/01-architecture/CORE_ARCHITECTURE.md index 0173f8b..fa38d49 100644 --- a/claudedocs/01-architecture/CORE_ARCHITECTURE.md +++ b/claudedocs/01-architecture/CORE_ARCHITECTURE.md @@ -101,23 +101,65 @@ Main configuration file loaded by Claude Code CLI: ``` .claude/ -├── commands/ # Custom slash commands -│ └── sc/ # SuperClaude command namespace -│ ├── research.md -│ ├── implement.md -│ └── test.md +├── agents/ # Specialized agent definitions (54+) +│ ├── analysis/ # Code analysis agents +│ ├── architecture/ # System design agents +│ ├── consensus/ # Distributed consensus agents +│ ├── core/ # Core agents (coder, reviewer, tester, etc.) +│ ├── development/ # Development specialists +│ ├── devops/ # CI/CD and infrastructure agents +│ ├── flow-nexus/ # Cloud platform agents +│ ├── github/ # GitHub integration agents +│ ├── goal/ # Goal-oriented planning agents +│ ├── hive-mind/ # Collective intelligence agents +│ ├── optimization/ # Performance optimization agents +│ ├── sparc/ # SPARC methodology agents +│ ├── swarm/ # Swarm coordination agents +│ └── testing/ # Testing specialists +├── commands/ # Slash commands (214+ across 25 categories) +│ ├── agents/ # Agent management commands +│ ├── analysis/ # Analysis commands +│ ├── automation/ # Workflow automation +│ ├── consider/ # Decision framework commands +│ ├── flow-nexus/ # Cloud platform commands +│ ├── github/ # GitHub operations +│ ├── hive-mind/ # Collective intelligence commands +│ ├── hooks/ # Hook configuration commands +│ ├── monitoring/ # System monitoring +│ ├── optimization/ # Performance optimization +│ ├── pair/ # Pair programming commands +│ ├── pm/ # Project management (CCPM) +│ ├── sc/ # SuperClaude meta commands +│ ├── sparc/ # SPARC methodology commands +│ ├── swarm/ # Swarm coordination commands +│ ├── ui/ # UI/frontend commands +│ └── workflows/ # Workflow templates +├── context/ # Project context files +├── helpers/ # Shell utilities +├── prds/ # Product requirements (CCPM) +├── router/ # Command routing configuration ├── rules/ # Operational rules │ ├── agent-coordination.md -│ ├── path-standards.md -│ └── github-operations.md -├── helpers/ # Shell utilities -│ ├── setup-mcp.sh -│ ├── github-setup.sh -│ └── checkpoint-manager.sh -├── prds/ # Product requirements -├── epics/ # Epic management (gitignored) -├── context/ # Project context -└── statusline/ # Status line config +│ ├── command-routing.md +│ ├── github-operations.md +│ └── path-standards.md +├── sessions/ # Session persistence +├── skills/ # Reusable skill definitions +│ ├── agent-sandboxes/ # E2B sandbox operations +│ ├── create-agent-skills/ +│ ├── create-hooks/ +│ ├── create-meta-prompts/ +│ ├── create-plans/ +│ ├── create-slash-commands/ +│ ├── create-subagents/ +│ ├── debug-like-expert/ +│ └── expertise/ # Domain expertise (iOS, macOS) +├── statusline/ # Status line config +├── superclaude/ # SuperClaude framework files +├── tools/ # Custom tool definitions +├── ccpm.config # CCPM configuration +├── settings.json # Claude Code settings +└── statusline-command.sh # Status line shell script ``` ### 2. SPARC Methodology Engine diff --git a/claudedocs/03-vision/CRAID_PARADIGM.md b/claudedocs/03-vision/CRAID_PARADIGM.md new file mode 100644 index 0000000..babe6b3 --- /dev/null +++ b/claudedocs/03-vision/CRAID_PARADIGM.md @@ -0,0 +1,406 @@ +# C(RAID): The Autonomous Development Paradigm + +**The foundational paradigm shift that enables truly autonomous AI development.** + +--- + +## Executive Summary + +**C(RAID)** stands for **Continuous Research, Analysis, Integration, Deployment** - an evolution of the traditional CI/CD paradigm designed specifically for autonomous LLM-based software development. + +While traditional CI/CD assumes human developers write code and then integrate it, C(RAID) recognizes that in autonomous AI development, **research and analysis must precede and continuously inform the development process**. + +``` +Traditional CI/CD: Code → Build → Test → Deploy +C(RAID): Research → Analysis → Integration → Deployment → (feedback) → Research +``` + +This isn't just an extension - it's a fundamental reconceptualization of how software gets built when AI agents are the primary developers. + +--- + +## The Paradigm Shift + +### Why CI/CD Falls Short for Autonomous Development + +Traditional **CI/CD (Continuous Integration / Continuous Deployment)** was designed for human-driven development: + +| Traditional CI/CD | Assumption | +|-------------------|------------| +| **Continuous Integration** | Humans write code, then integrate it | +| **Continuous Deployment** | Code is tested and deployed automatically | +| **Starting Point** | Code already exists (human wrote it) | +| **Knowledge Source** | Human expertise and documentation | + +This model assumes the hard problem is **integration and deployment** - getting code from multiple developers to work together and reach production reliably. + +### C(RAID): A New Starting Point + +Autonomous LLM-based development inverts this: + +| C(RAID) | Reality | +|---------|---------| +| **Continuous Research** | AI agents must gather knowledge before coding | +| **Continuous Analysis** | Requirements extraction and architecture matching | +| **Continuous Integration** | Multi-agent parallel implementation | +| **Continuous Deployment** | Automated validation with human gates | +| **Starting Point** | A concept, question, or research source | +| **Knowledge Source** | Web research, documentation, pattern recognition | + +**The hard problem becomes research and analysis** - understanding WHAT to build and HOW to build it correctly. + +--- + +## The Four Pillars of C(RAID) + +```mermaid +flowchart LR + subgraph CRAID["C(RAID) Continuous Cycle"] + R["🔬 Research"] + A["📊 Analysis"] + I["🔧 Integration"] + D["🚀 Deployment"] + end + + R -->|Insights| A + A -->|Specifications| I + I -->|Artifacts| D + D -->|Feedback & Metrics| R + + style R fill:#e3f2fd,stroke:#1976d2 + style A fill:#fff3e0,stroke:#f57c00 + style I fill:#e8f5e9,stroke:#388e3c + style D fill:#fce4ec,stroke:#c2185b +``` + +### 🔬 Continuous Research (CR) + +**Purpose:** Autonomous knowledge gathering and pattern recognition + +**What happens:** +- AI agents research concepts from multiple sources (videos, papers, blogs, documentation) +- Multi-hop investigation follows related concepts +- Pattern recognition identifies successful implementations +- Technology trends are monitored and analyzed + +**Key agents:** `researcher`, `deep-research-agent` + +**Output:** Structured knowledge ready for requirement extraction + +**Traditional equivalent:** A developer reading documentation and researching approaches (but done continuously and at scale) + +--- + +### 📊 Continuous Analysis (CA) + +**Purpose:** Automated requirement extraction and architecture validation + +**What happens:** +- Research findings are transformed into specifications +- Existing architecture patterns are matched to requirements +- Quality and security implications are assessed +- Feasibility and complexity are estimated + +**Key agents:** `specification`, `code-analyzer`, `planner`, `goal-planner` + +**Output:** Product Requirements Documents (PRDs), architecture decisions, task decomposition + +**Traditional equivalent:** Product management and technical design (but automated and consistent) + +--- + +### 🔧 Continuous Integration (CI - Evolved) + +**Purpose:** Multi-agent parallel implementation with intelligent coordination + +**What happens:** +- Tasks are distributed to specialized agents +- Agents work in parallel on isolated Git worktrees +- Coordination happens through commits and shared memory +- TDD practices ensure quality at the unit level + +**Key agents:** `coder`, `backend-dev`, `mobile-dev`, `tester`, `reviewer` + +**Output:** Working code with tests in isolated branches + +**Traditional equivalent:** Development team sprint work (but parallelized and conflict-free) + +--- + +### 🚀 Continuous Deployment (CD - Enhanced) + +**Purpose:** Automated validation with human approval gates + +**What happens:** +- Multi-agent code review (5+ specialized reviewers) +- Automated security scanning and performance benchmarking +- Progressive deployment (staging → production) +- Metrics collection feeds back to Research phase + +**Key agents:** `production-validator`, `release-manager`, `security-manager`, `performance-benchmarker` + +**Output:** Production deployment with rollback capability + +**Traditional equivalent:** DevOps pipeline (but with AI-driven validation and feedback loops) + +--- + +## C(RAID) vs SPARC: Complementary Frameworks + +C(RAID) and SPARC are not competing frameworks - they operate at different levels of abstraction. + +```mermaid +flowchart TB + subgraph Outer["C(RAID) - Operational Paradigm (Outer Loop)"] + direction LR + CR["Continuous
Research"] --> CA["Continuous
Analysis"] + CA --> CI["Continuous
Integration"] + CI --> CD["Continuous
Deployment"] + CD -.->|Feedback| CR + end + + subgraph Inner["SPARC - Execution Methodology (Inner Loop)"] + direction LR + S["Specification"] --> P["Pseudocode"] + P --> Ar["Architecture"] + Ar --> Re["Refinement"] + Re --> Co["Completion"] + end + + CI -->|"Executes via"| Inner + Inner -->|"Produces for"| CD + + style Outer fill:#e8eaf6,stroke:#3f51b5 + style Inner fill:#fff8e1,stroke:#ffc107 +``` + +### SPARC: The Inner Loop (Execution) + +**SPARC** (Specification, Pseudocode, Architecture, Refinement, Completion) answers: +> "How do I build ONE thing systematically?" + +SPARC provides the discipline for each individual development cycle: +- **Specification** → What exactly are we building? +- **Pseudocode** → What's the algorithm/approach? +- **Architecture** → How does it fit the system? +- **Refinement** → TDD implementation with quality gates +- **Completion** → Integration and deployment validation + +### C(RAID): The Outer Loop (Operations) + +**C(RAID)** answers: +> "How does development CONTINUOUSLY evolve?" + +C(RAID) provides the operational framework that spans multiple SPARC cycles: +- **Research** → What SHOULD we build next? +- **Analysis** → Is this the right approach? +- **Integration** → Execute SPARC to build it +- **Deployment** → Get it to production, gather feedback + +### The Relationship + +``` +C(RAID) Cycle 1: + Research → "New caching approach from YouTube video" + Analysis → "PRD: Distributed cache with consistent hashing" + Integration → [SPARC: Spec→Pseudo→Arch→Refine→Complete] + Deployment → Production, collect metrics + ↓ +C(RAID) Cycle 2: + Research → "Metrics show cache misses, research solutions" + Analysis → "PRD: Add cache warming strategy" + Integration → [SPARC: Spec→Pseudo→Arch→Refine→Complete] + Deployment → Production, metrics improve + ↓ +C(RAID) Cycle 3: ... +``` + +--- + +## C(RAID) in Practice: The Evolve Framework + +The Evolve framework implements C(RAID) through its autonomous pipeline: + +| C(RAID) Phase | Evolve Pipeline Phase | Duration | Key Tools | +|---------------|----------------------|----------|-----------| +| **Continuous Research** | Phase 1: Concept Extraction | 3-5 min | `/sc:research`, Tavily, WebFetch | +| **Continuous Analysis** | Phase 2: PRD Generation | 15-20 min | `/pm:prd-new`, `/sparc:architect` | +| **Continuous Integration** | Phase 3-4: Decomposition + Implementation | 2-5 hours | `/swarm:development`, `/sparc:coder` | +| **Continuous Deployment** | Phase 5: Validation & Deployment | 45 min | `/github:code-review-swarm`, `/github:pr-manager` | + +### Agent Mapping + +```mermaid +flowchart TB + subgraph Research["Continuous Research"] + R1["researcher"] + R2["deep-research-agent"] + end + + subgraph Analysis["Continuous Analysis"] + A1["specification"] + A2["code-analyzer"] + A3["planner"] + A4["goal-planner"] + end + + subgraph Integration["Continuous Integration"] + I1["coder"] + I2["backend-dev"] + I3["mobile-dev"] + I4["tester"] + I5["reviewer"] + end + + subgraph Deployment["Continuous Deployment"] + D1["production-validator"] + D2["release-manager"] + D3["security-manager"] + D4["cicd-engineer"] + end + + Research --> Analysis --> Integration --> Deployment + Deployment -.->|"Metrics feed back"| Research +``` + +--- + +## Benefits of C(RAID) + +### For Autonomous Development + +1. **Research-First Approach** + - Decisions are informed by current best practices + - Patterns are discovered, not assumed + - Technology choices are evidence-based + +2. **Continuous Learning** + - Deployment metrics inform research priorities + - Successful patterns are recognized and reused + - Failures trigger investigation cycles + +3. **Parallel Execution** + - Multiple agents work simultaneously + - File-level isolation prevents conflicts + - 3-8 agents achieve 2.8-4.4x speedup + +4. **Human-in-the-Loop** + - Approval gates at critical decisions + - Humans focus on strategy, not implementation + - AI handles routine validation + +### Measured Improvements + +| Metric | Traditional | C(RAID) | Improvement | +|--------|-------------|---------|-------------| +| Concept → Working Code | 20-30 hours | 5-6 hours | **3.5-5.2x faster** | +| Code Coverage | 65% | 87% | **+22%** | +| Bug Rate | 0.8/100 LOC | 0.3/100 LOC | **-62%** | +| Human Intervention | 100% | <10% | **90% reduction** | + +--- + +## The Feedback Loop: What Makes C(RAID) "Continuous" + +The key insight of C(RAID) is that **deployment is not the end** - it's the beginning of the next research cycle. + +```mermaid +flowchart TB + subgraph Cycle1["Development Cycle"] + R1["Research
'New caching approach'"] + A1["Analysis
'PRD: Distributed cache'"] + I1["Integration
'Implement via SPARC'"] + D1["Deployment
'Production release'"] + end + + subgraph Feedback["Continuous Feedback"] + M["Metrics Collection"] + P["Performance Analysis"] + U["User Feedback"] + end + + subgraph Cycle2["Next Cycle"] + R2["Research
'Investigate cache misses'"] + end + + R1 --> A1 --> I1 --> D1 + D1 --> M + M --> P + P --> U + U --> R2 + + style Feedback fill:#f3e5f5,stroke:#7b1fa2 +``` + +**Examples of feedback-driven research:** + +- Cache miss rate high → Research cache warming strategies +- Performance degradation → Research optimization techniques +- Security vulnerability discovered → Research mitigation patterns +- User complaints about UX → Research design patterns + +--- + +## Implementing C(RAID) in Your Workflow + +### Quick Start + +```bash +# C(RAID) Cycle Example + +# 1. Continuous Research +/sc:research "https://www.youtube.com/watch?v=example" --research --think-hard + +# 2. Continuous Analysis +/pm:prd-new my-feature --source .claude/context/research.json +# Human reviews and approves PRD + +# 3. Continuous Integration +/pm:epic-oneshot my-feature --sync-github +/swarm:development --epic my-feature --agents 5 + +# 4. Continuous Deployment +/github:code-review-swarm --pr my-feature --reviewers 5 +/github:pr-manager merge my-feature --auto-deploy staging +# Human approves production deployment + +# Metrics collection begins, feeding next Research cycle +``` + +### Command Reference + +| C(RAID) Phase | Primary Commands | +|---------------|------------------| +| Research | `/sc:research`, `/automation:ai-pipeline:extract` | +| Analysis | `/pm:prd-new`, `/sparc:architect`, `/sc:design` | +| Integration | `/swarm:development`, `/sparc:coder`, `/pm:issue-start` | +| Deployment | `/github:code-review-swarm`, `/github:pr-manager` | + +--- + +## Conclusion + +C(RAID) represents the recognition that autonomous AI development requires a fundamentally different operational paradigm than human-driven development. + +**Traditional CI/CD** optimizes for integrating and deploying human-written code. + +**C(RAID)** optimizes for the complete autonomous development lifecycle: +- **Researching** what to build +- **Analyzing** how to build it +- **Integrating** the implementation +- **Deploying** with validation +- **Learning** from production feedback + +Combined with SPARC methodology for disciplined execution, C(RAID) provides the foundation for truly autonomous, continuously improving software development at scale. + +--- + +**See Also:** +- [Autonomous Pipeline Architecture](../01-architecture/autonomous-pipeline-architecture.md) +- [SPARC Methodology](../../.claude/agents/sparc/) +- [Agent Coordination Rules](../../.claude/rules/agent-coordination.md) +- [Command Routing Reference](../../.claude/rules/command-routing.md) + +--- + +**Navigate**: [← Vision](../03-vision/) | [Architecture →](../01-architecture/) diff --git a/claudedocs/03-vision/README.md b/claudedocs/03-vision/README.md index bf72fc9..e3e609b 100644 --- a/claudedocs/03-vision/README.md +++ b/claudedocs/03-vision/README.md @@ -2,28 +2,38 @@ **Purpose**: Strategic vision, concepts, and future direction for the project. +## The C(RAID) Paradigm + +**The foundational paradigm shift that enables truly autonomous AI development.** + +C(RAID) - Continuous Research, Analysis, Integration, Deployment - represents an evolution of traditional CI/CD designed specifically for autonomous LLM-based development. While CI/CD assumes human developers write code first, C(RAID) recognizes that AI agents must **research and analyze** before they can build effectively. + +> **See**: [CRAID_PARADIGM.md](./CRAID_PARADIGM.md) for the complete paradigm documentation. + ## Contents +- **CRAID_PARADIGM.md** - The C(RAID) paradigm: Continuous Research, Analysis, Integration, Deployment - **PROJECT_VISION.md** - Overall project vision and strategic direction ## What Belongs Here +- ✅ Paradigm-level conceptual frameworks (C(RAID)) - ✅ Strategic vision documents - ✅ Innovation proposals and concepts - ✅ Future direction planning -- ✅ Conceptual frameworks - ✅ Long-term strategic goals ### What Doesn't Belong -- ❌ Tactical feature planning (→ 04-planning/features/) -- ❌ Current implementation (→ 05-implementation/) -- ❌ Research findings (→ 02-research/) +- ❌ Tactical feature planning (-> 04-planning/features/) +- ❌ Current implementation (-> 05-implementation/) +- ❌ Research findings (-> 02-research/) ## Vision Themes Key strategic themes for the project: +- **C(RAID) Paradigm** - Continuous Research, Analysis, Integration, Deployment for autonomous AI development - **Multi-framework Integration** - Unified SuperClaude + CCPM + Claude Flow + Constitutional AI - **AI-Native Development** - Optimized for AI agent collaboration -- **Systematic Quality** - SPARC methodology and TDD practices +- **Systematic Quality** - SPARC methodology (inner execution loop) + C(RAID) (outer operational loop) - **Scalable Architecture** - Modular, maintainable, extensible --- diff --git a/docs/architecture/autonomous-pipeline-architecture.md b/docs/architecture/autonomous-pipeline-architecture.md index f630517..cef91e7 100644 --- a/docs/architecture/autonomous-pipeline-architecture.md +++ b/docs/architecture/autonomous-pipeline-architecture.md @@ -47,6 +47,23 @@ This document defines a comprehensive autonomous pipeline that transforms **rese --- +## C(RAID) Context + +This autonomous pipeline implements the **C(RAID) paradigm** - Continuous Research, Analysis, Integration, Deployment: + +| C(RAID) Phase | Pipeline Phase | Duration | Key Agents | +|---------------|----------------|----------|------------| +| **Continuous Research** | Phase 1: Concept Extraction | 3-5 min | researcher, deep-research-agent | +| **Continuous Analysis** | Phase 2: PRD Generation | 15-20 min | specification, planner, goal-planner | +| **Continuous Integration** | Phase 3-4: Decomposition + Implementation | 2-5 hours | coder, tester, task-orchestrator | +| **Continuous Deployment** | Phase 5: Validation & Deployment | 45 min | production-validator, reviewer | + +The pipeline represents one complete C(RAID) cycle. Deployment metrics and user feedback trigger the next Research phase, creating a continuous improvement loop. + +> **See Also**: [The C(RAID) Paradigm](../paradigm/index.rst) for the full paradigm documentation. + +--- + ## 1. Pipeline Overview ### 1.1 Five-Phase Autonomous Workflow diff --git a/docs/conf.py b/docs/conf.py index b7ad9c8..ebba12b 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -27,6 +27,30 @@ # MyST-Parser configuration - enable all features myst_fence_as_directive = ["mermaid"] # Render ```mermaid blocks as Mermaid diagrams +# Mermaid configuration for dark theme compatibility +mermaid_init_js = """ +mermaid.initialize({ + startOnLoad: true, + theme: 'dark', + themeVariables: { + lineColor: '#8B949E', + primaryTextColor: '#C9D1D9', + primaryColor: '#238636', + primaryBorderColor: '#30363D', + secondaryColor: '#161B22', + tertiaryColor: '#21262D', + edgeLabelBackground: '#21262D', + clusterBkg: '#161B22', + clusterBorder: '#30363D', + nodeTextColor: '#C9D1D9' + }, + flowchart: { + curve: 'basis', + useMaxWidth: true + } +}); +""" + myst_enable_extensions = [ "amsmath", "colon_fence", diff --git a/docs/index.rst b/docs/index.rst index c1d3e66..addcc6b 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -3,6 +3,12 @@ Evolve: Autonomous AI Development Framework **An integrated framework combining SuperClaude behavioral modes, CCPM project management, and Claude Flow orchestration to enable truly autonomous, systematic software development at scale.** +.. toctree:: + :maxdepth: 2 + :caption: The Paradigm + + paradigm/index + .. toctree:: :maxdepth: 2 :caption: Getting Started diff --git a/docs/paradigm/index.rst b/docs/paradigm/index.rst new file mode 100644 index 0000000..98d6c7e --- /dev/null +++ b/docs/paradigm/index.rst @@ -0,0 +1,9 @@ +The C(RAID) Paradigm +==================== + +**C(RAID)** - Continuous Research, Analysis, Integration, Deployment - represents the foundational paradigm shift that enables truly autonomous AI development. + +This paradigm extends traditional CI/CD to include the research and analysis phases that are essential for autonomous LLM-based development, where AI agents must understand WHAT to build before they can build it. + +.. include:: ../../claudedocs/03-vision/CRAID_PARADIGM.md + :parser: myst_parser.sphinx_