aidp 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 15737cc2920d4af142a562df51e1acd5951625e836584f62dca3d30f7eb51a81
+  data.tar.gz: a8243c124ab94cc09f775088cbb62faf6f6fa558f3c6a78bbf52b455d3b446f5
+SHA512:
+  metadata.gz: db054e792e7c69e22ea2ccda883674e9045febe6907e7d8a9ffc925db952c98e253303d883b3dbb744b079255ea554b66448bdd3eaf6ce0a60130c09ddac6868
+  data.tar.gz: 4ebe66fadbdef39a5ddad1df6fb7790b86a16a0fef306636b00b7154dc5191c403763484d1448b21c89daf0c5f22c9a39cda1bc7fe2668e632b817951a4d9a3a

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bart Agapinan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,210 @@
+# AI Dev Pipeline (aidp) - Ruby Gem
+
+A portable CLI that automates a complete AI development workflow from idea to implementation using your existing IDE assistants.
+
+## Quick Start
+
+```bash
+# Install the gem
+gem install aidp
+
+# Navigate to your project
+cd /your/project
+
+# Start the workflow
+aidp execute next
+```
+
+## User Workflow
+
+The gem automates a complete development pipeline with **human-in-the-loop gates** at key decision points. Here's the simplest workflow:
+
+### 1. Start Your Project
+
+```bash
+cd /your/project
+aidp status                   # Check current progress
+aidp execute next             # Run the next pending step
+```
+
+### 2. Handle Gate Steps
+
+When you reach a **gate step** (PRD, Architecture, Tasks, Implementation), the AI will:
+
+1. **Generate questions** in a file (e.g., `PRD_QUESTIONS.md`) if it needs more information
+2. **Create the main output** (e.g., `docs/PRD.md`)
+3. **Wait for your approval** before proceeding
+
+**Your actions at gates:**
+
+```bash
+# Review the generated files
+cat PRD_QUESTIONS.md          # Check if AI needs more information
+cat docs/PRD.md              # Review the output
+
+# If PRD_QUESTIONS.md exists, answer the questions:
+# Edit the questions file directly with your answers
+nano PRD_QUESTIONS.md         # Add your answers below each question
+
+# Re-run the step to use your answers
+aidp execute prd              # AI will read your answers and complete the step
+
+# Once satisfied with the output, approve and continue
+aidp approve current          # Mark the step complete
+aidp execute next             # Continue to next step
+```
+
+### 3. Continue the Pipeline
+
+For non-gate steps, the AI runs automatically:
+
+```bash
+aidp execute next             # Run next step automatically
+aidp status                   # Check progress
+```
+
+### 4. Complete the Workflow
+
+The pipeline includes 15 steps total:
+
+- **Gates**: PRD, Architecture, Tasks, Implementation (require approval)
+- **Auto**: NFRs, ADRs, Domains, Contracts, Threat Model, Test Plan, Scaffolding, Static Analysis, Observability, Delivery, Docs Portal, Post-Release
+
+## Key Commands
+
+```bash
+aidp status                   # Show progress of all steps
+aidp execute next             # Run next pending step
+aidp approve current          # Approve current gate step
+aidp detect                   # See which AI provider will be used
+aidp execute <step>           # Run specific step (e.g., prd, arch, tasks)
+aidp approve <step>           # Approve specific step
+aidp reset                    # Reset all progress (start over)
+```
+
+## AI Providers
+
+The gem automatically detects and uses the best available AI provider:
+
+- **Cursor CLI** (`cursor-agent`) - Preferred
+- **Claude CLI** (`claude`/`claude-code`) - Fallback
+- **Gemini CLI** (`gemini`/`gemini-cli`) - Fallback
+
+### Override Provider
+
+```bash
+AIDP_PROVIDER=anthropic aidp execute next
+AIDP_LLM_CMD=/usr/local/bin/claude aidp execute next
+```
+
+## File-Based Interaction
+
+At gate steps, the AI creates files for interaction instead of requiring real-time chat:
+
+- **Questions files**: `PRD_QUESTIONS.md`, `ARCH_QUESTIONS.md`, `TASKS_QUESTIONS.md`, `IMPL_QUESTIONS.md` - Contains questions if AI needs more information
+- **Output files**: `docs/PRD.md`, `docs/Architecture.md` - Review and edit as needed
+- **Progress tracking**: `.aidp-progress.yml` - Tracks completion status
+
+### Answering Questions
+
+When the AI creates a questions file, follow these steps:
+
+1. **Edit the file directly**: Add your answers below each question in the file
+2. **Re-run the step**: The AI will read your answers and complete the step
+3. **Approve when satisfied**: Mark the step complete and continue
+
+The questions file is only created when the AI needs additional information beyond what it can infer from your project structure and existing files. Your answers are preserved for future reference.
+
+## Debug and Logging
+
+```bash
+# Enable debug output to see AI provider communication
+AIDP_DEBUG=1 aidp execute next
+
+# Log to a file for debugging
+AIDP_LOG_FILE=aidp.log aidp execute next
+
+# Combine both for full debugging
+AIDP_DEBUG=1 AIDP_LOG_FILE=aidp.log aidp execute next
+```
+
+## Workflow Example
+
+Here's a typical session:
+
+```bash
+# 1. Start the workflow
+aidp execute next
+# → Creates docs/PRD.md and PRD_QUESTIONS.md
+
+# 2. Review the questions (if any)
+cat PRD_QUESTIONS.md
+# → If questions exist, edit the file with your answers, then re-run
+
+# 3. Review the PRD
+cat docs/PRD.md
+# → Edit if needed
+
+# 4. Approve and continue
+aidp approve current
+aidp execute next
+# → Creates docs/NFRs.md automatically
+
+# 5. Continue through gates
+aidp execute next
+# → Creates docs/Architecture.md and ARCH_QUESTIONS.md
+# → Repeat review/approve cycle
+```
+
+## Development
+
+```bash
+# Install dependencies
+bundle install
+
+# Run tests
+bundle exec rspec
+
+# Run linter
+bundle exec standardrb
+
+# Auto-fix linting issues
+bundle exec standardrb --fix
+
+# Build gem
+bundle exec rake build
+```
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and conventional commit guidelines.
+
+## Pipeline Steps
+
+The gem automates a complete 15-step development pipeline:
+
+### Gate Steps (Require Approval)
+
+- **PRD** → Product Requirements Document (`docs/PRD.md`)
+- **Architecture** → System architecture and ADRs (`docs/Architecture.md`)
+- **Tasks** → Implementation tasks and backlog (`tasks/backlog.yaml`)
+- **Implementation** → Implementation strategy and guidance (`docs/ImplementationGuide.md`)
+
+### Automatic Steps
+
+- **NFRs** → Non-Functional Requirements (`docs/NFRs.md`)
+- **ADRs** → Architecture Decision Records (`docs/adr/`)
+- **Domains** → Domain decomposition (`docs/DomainCharters/`)
+- **Contracts** → API/Event contracts (`contracts/`)
+- **Threat Model** → Security analysis (`docs/ThreatModel.md`)
+- **Test Plan** → Testing strategy (`docs/TestPlan.md`)
+- **Scaffolding** → Project structure guidance (`docs/ScaffoldingGuide.md`)
+- **Static Analysis** → Code quality tools (`docs/StaticAnalysis.md`)
+- **Observability** → Monitoring and SLOs (`docs/Observability.md`)
+- **Delivery** → Deployment strategy (`docs/DeliveryPlan.md`)
+- **Docs Portal** → Documentation portal (`docs/DocsPortalPlan.md`)
+- **Post-Release** → Post-release analysis (`docs/PostReleaseReport.md`)
+
+## Manual Workflow (Alternative)
+
+The gem packages markdown prompts that can also be used directly with Cursor or any LLM. See the `templates/` directory for the individual prompt files that can be run manually.

data/bin/aidp

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'aidp'
+Aidp::Shared::CLI.start(ARGV)

data/lib/aidp/analyze/agent_personas.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Aidp
+  module Analyze
+    # Defines AI agent personas for analyze mode
+    class AgentPersonas
+      PERSONAS = {
+        "Repository Analyst" => {
+          "name" => "Repository Analyst",
+          "description" => "Expert in analyzing version control data, code evolution patterns, and repository metrics. Specializes in identifying hotspots, technical debt, and code quality trends over time.",
+          "expertise" => ["Git analysis", "Code metrics", "Temporal patterns", "Hotspot identification"],
+          "tools" => ["Code Maat", "Git log analysis", "Statistical analysis"]
+        },
+        "Architecture Analyst" => {
+          "name" => "Architecture Analyst",
+          "description" => "Senior architect with deep understanding of software architecture patterns, design principles, and system design. Focuses on structural analysis, dependency mapping, and architectural recommendations.",
+          "expertise" => ["System architecture", "Design patterns", "Dependency analysis", "Scalability assessment"],
+          "tools" => ["Architecture diagrams", "Dependency graphs", "Pattern recognition"]
+        },
+        "Test Analyst" => {
+          "name" => "Test Analyst",
+          "description" => "Quality assurance expert specializing in test coverage analysis, testing strategies, and test infrastructure assessment. Identifies testing gaps and recommends improvements.",
+          "expertise" => ["Test coverage", "Testing strategies", "Test infrastructure", "Quality metrics"],
+          "tools" => ["Coverage analysis", "Test frameworks", "Quality assessment"]
+        },
+        "Functionality Analyst" => {
+          "name" => "Functionality Analyst",
+          "description" => "Business analyst and domain expert who understands application functionality, business logic, and feature mapping. Analyzes code from a functional perspective.",
+          "expertise" => ["Business logic", "Feature analysis", "Domain modeling", "Functional requirements"],
+          "tools" => ["Feature mapping", "Business logic analysis", "Domain understanding"]
+        },
+        "Documentation Analyst" => {
+          "name" => "Documentation Analyst",
+          "description" => "Technical writer and documentation specialist who evaluates documentation quality, completeness, and effectiveness. Recommends documentation improvements.",
+          "expertise" => ["Documentation quality", "Technical writing", "Information architecture", "User experience"],
+          "tools" => ["Documentation analysis", "Content assessment", "Readability metrics"]
+        },
+        "Static Analysis Expert" => {
+          "name" => "Static Analysis Expert",
+          "description" => "Code quality specialist with expertise in static analysis tools, code review practices, and quality metrics. Identifies code quality issues and tooling opportunities.",
+          "expertise" => ["Static analysis", "Code quality", "Tool integration", "Quality metrics"],
+          "tools" => ["Linters", "Static analyzers", "Quality assessment tools"]
+        },
+        "Refactoring Specialist" => {
+          "name" => "Refactoring Specialist",
+          "description" => "Refactoring expert who identifies refactoring opportunities, assesses risks, and provides step-by-step refactoring plans. Focuses on improving code maintainability.",
+          "expertise" => ["Refactoring techniques", "Risk assessment", "Code improvement", "Maintainability"],
+          "tools" => ["Refactoring tools", "Impact analysis", "Risk assessment"]
+        }
+      }.freeze
+
+      def self.get_persona(name)
+        PERSONAS[name]
+      end
+
+      def self.list_personas
+        PERSONAS.keys
+      end
+
+      def self.get_expertise(name)
+        persona = get_persona(name)
+        persona ? persona["expertise"] : []
+      end
+
+      def self.get_tools(name)
+        persona = get_persona(name)
+        persona ? persona["tools"] : []
+      end
+    end
+  end
+end