@devobsessed/code-captain 0.0.3

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@devobsessed/code-captain",
+  "version": "0.0.3",
+  "description": "Unified AI Development Agent System with intelligent change detection",
+  "type": "module",
+  "bin": {
+    "code-captain": "bin/install.js"
+  },
+  "scripts": {
+    "manifest": "node scripts/build-manifest.js",
+    "dry-run": "npm publish --dry-run",
+    "test": "echo \"(no tests yet)\""
+  },
+  "keywords": [
+    "ai",
+    "development",
+    "agent",
+    "cursor",
+    "copilot",
+    "windsurf",
+    "claude",
+    "automation"
+  ],
+  "author": "DevObsessed",
+  "contributors": [
+    "Brad Risse <brad.risse@devobsessed.com>"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "boxen": "~7.0.0",
+    "chalk": "~5.3.0",
+    "cross-spawn": "~7.0.3",
+    "fs-extra": "~11.1.1",
+    "inquirer": "~9.2.7",
+    "node-fetch": "~3.3.1",
+    "ora": "~7.0.1"
+  },
+  "files": [
+    "bin/",
+    "cursor/",
+    "copilot/",
+    "windsurf/",
+    "claude-code/",
+    "manifest.json",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devobsessed/code-captain.git"
+  },
+  "bugs": {
+    "url": "https://github.com/devobsessed/code-captain/issues"
+  },
+  "homepage": "https://github.com/devobsessed/code-captain#readme"
+}

package/windsurf/README.md

@@ -0,0 +1,254 @@
+# Code Captain for Windsurf
+
+> **Codeium's AI-powered development environment with custom workflow integration**
+
+Windsurf provides advanced AI capabilities with custom workflow integration, built-in context management, and intelligent code coordination.
+
+## 🚀 Installation
+
+### Automatic Installation (Recommended)
+
+```bash
+npx @devobsessed/code-captain
+```
+
+The installer will detect Windsurf and install to:
+- `.windsurf/` - Custom workflows and rules
+- `.code-captain/` - Complete workflow system
+
+### Manual Installation
+
+```bash
+# Clone or download the windsurf/ directory contents to .windsurf/
+cp -r windsurf/ .windsurf/
+cp -r .code-captain/ .
+```
+
+## 🎯 Workflow Integration
+
+Code Captain in Windsurf uses custom workflow files that integrate with Windsurf's AI system:
+
+### Available Workflows
+Located in `.windsurf/workflows/`:
+
+- **`initialize.md`** - Project setup and analysis
+- **`create-spec.md`** - Feature specification creation
+- **`create-adr.md`** - Architecture Decision Records
+- **`execute-task.md`** - Test-driven development
+- **`explain-code.md`** - Code explanation with diagrams
+- **`status.md`** - Project status analysis
+- **`edit-spec.md`** - Specification modification
+- **`new-command.md`** - Custom command creation
+
+### Workflow Rules
+Located in `.windsurf/rules/`:
+
+- **`cc.md`** - Core Code Captain rules and guidelines
+
+## 🛠️ Available Workflows
+
+### 📋 Project Setup & Analysis
+- **Initialize Project** - Comprehensive project analysis and documentation setup
+- **Product Planning** - Strategic product planning with roadmap generation
+- **Technical Research** - Systematic 4-phase research methodology
+- **Custom Commands** - Create domain-specific workflow extensions
+
+### 📝 Requirements & Planning
+- **Feature Specifications** - Detailed specs with technical implementation details
+- **Architecture Decisions** - ADRs with systematic research and alternatives analysis
+- **Code Explanations** - Visual diagrams with comprehensive technical analysis
+- **Specification Editing** - Contract-first approach to specification modifications
+
+### ⚙️ Implementation
+- **Test-Driven Development** - Systematic TDD workflow with progress tracking
+- **Project Status** - Comprehensive status analysis with actionable recommendations
+- **Code Cleanup** - Incremental improvements following the Boy Scout Rule
+
+## 🔄 Workflow Examples
+
+### Project Initialization
+
+1. **Open Windsurf** and navigate to your project
+2. **Reference the initialize workflow**: `.windsurf/workflows/initialize.md`
+3. **Follow the systematic process** for project analysis
+4. **Review generated documentation** in `.code-captain/docs/`
+
+### Feature Development
+
+1. **Research Phase**
+   - Use `.windsurf/workflows/create-adr.md` for architectural decisions
+   - Reference research methodology from workflows
+
+2. **Specification Phase**
+   - Follow `.windsurf/workflows/create-spec.md`
+   - Generate comprehensive feature specifications
+
+3. **Implementation Phase**
+   - Use `.windsurf/workflows/execute-task.md`
+   - Follow TDD methodology with progress tracking
+
+4. **Status Monitoring**
+   - Reference `.windsurf/workflows/status.md`
+   - Get comprehensive project health analysis
+
+### Code Understanding
+
+1. **Code Explanation**
+   - Use `.windsurf/workflows/explain-code.md`
+   - Generate visual diagrams and technical analysis
+
+2. **Incremental Improvements**
+   - Follow best practices from `.windsurf/rules/cc.md`
+   - Apply small, focused improvements
+
+## 📁 File Organization
+
+Windsurf integration creates this structure:
+
+```
+.windsurf/
+├── workflows/
+│   ├── initialize.md
+│   ├── create-spec.md
+│   ├── create-adr.md
+│   ├── execute-task.md
+│   ├── explain-code.md
+│   ├── status.md
+│   ├── edit-spec.md
+│   └── new-command.md
+└── rules/
+    └── cc.md
+
+.code-captain/
+├── commands/              # Reference documentation
+├── docs/                  # Generated documentation
+├── research/              # Technical research reports
+├── decision-records/      # Architecture Decision Records
+├── specs/                 # Feature specifications
+│   └── YYYY-MM-DD-feature/
+│       ├── spec.md
+│       ├── user-stories/
+│       └── tasks.md
+└── cc.md                 # Complete reference guide
+```
+
+## 🎯 Windsurf-Specific Features
+
+### Custom Workflow Integration
+- **Workflow-based execution** aligned with Windsurf's AI coordination
+- **Context-aware processing** using Windsurf's advanced context management
+- **Intelligent file organization** with automatic workspace awareness
+
+### Advanced AI Coordination
+- **Multi-step workflow execution** with AI guidance
+- **Context preservation** across workflow phases
+- **Intelligent tool selection** based on workflow requirements
+
+### Built-in Best Practices
+- **Critical thinking guidelines** from `windsurf/rules/cc.md`
+- **Systematic approaches** to complex development tasks
+- **Quality-focused workflows** with verification steps
+
+## 🚀 Advanced Usage
+
+### Custom Workflow Creation
+
+Create new workflows in `.windsurf/workflows/`:
+
+```markdown
+# Custom Workflow
+
+## Overview
+[Describe workflow purpose and capabilities]
+
+## Process
+[Detail step-by-step workflow execution]
+
+## Tool Integration
+[Specify Windsurf tool coordination]
+
+## Output Organization
+[Define file structure and locations]
+```
+
+### Rule Customization
+
+Enhance `.windsurf/rules/cc.md` with team-specific guidelines:
+
+```markdown
+## Team-Specific Rules
+
+### Code Standards
+[Define team coding standards]
+
+### Review Process
+[Specify review requirements]
+
+### Documentation Standards
+[Define documentation expectations]
+```
+
+### Workflow Chaining
+
+Chain workflows for complex development processes:
+
+1. **Initialize** → **Research** → **Create ADR**
+2. **Create Spec** → **Execute Task** → **Status Check**
+3. **Explain Code** → **Swab** → **Status Update**
+
+## 🔧 Configuration
+
+### Windsurf Settings
+Configure Windsurf to optimize Code Captain integration:
+
+- **Enable advanced context management**
+- **Configure AI coordination preferences**
+- **Set up workspace awareness**
+
+### Project-Specific Rules
+Customize `.windsurf/rules/cc.md` for your project:
+
+- **Domain-specific guidelines**
+- **Technology-specific patterns**
+- **Team collaboration standards**
+
+## 📊 Workflow Reference
+
+| Workflow | Purpose | Output Location |
+|----------|---------|-----------------|
+| `initialize` | Project analysis & setup | `.code-captain/docs/` |
+| `create-spec` | Feature specification | `.code-captain/specs/` |
+| `execute-task` | TDD implementation | Source code + tests |
+| `create-adr` | Architecture decisions | `.code-captain/decision-records/` |
+| `status` | Project health analysis | Terminal output |
+
+## 🛠️ Troubleshooting
+
+### Workflows Not Executing Properly
+**Problem**: Windsurf doesn't follow workflow steps correctly  
+**Solution**: Ensure workflow files are in `.windsurf/workflows/` and reference them explicitly
+
+### Context Issues
+**Problem**: AI loses context during workflow execution  
+**Solution**: Break complex workflows into smaller steps and verify context preservation
+
+### File Organization Problems
+**Problem**: Generated files appear in wrong locations  
+**Solution**: Check `.code-captain/` folder structure and verify workflow output specifications
+
+## 🤝 Contributing
+
+Windsurf-specific contributions:
+
+1. **Workflow Enhancement** - Improve AI coordination and workflow efficiency
+2. **Rule Development** - Add domain-specific rules and guidelines
+3. **Documentation** - Create Windsurf-specific examples and patterns
+4. **Integration** - Enhance Windsurf AI coordination capabilities
+
+---
+
+**Ready to supercharge your Windsurf development?**
+
+1. **Install:** `npx @devobsessed/code-captain`
+2. **Reference:** `.windsurf/workflows/initialize.md`
+3. **Begin:** Project initialization workflow 

package/windsurf/rules/cc.md

@@ -0,0 +1,5 @@
+---
+trigger: always_on
+---
+
+some content

package/windsurf/workflows/create-adr.md

@@ -0,0 +1,331 @@
+---
+description: Create comprehensive Architecture Decision Records with systematic analysis and structured documentation
+---
+
+# Create ADR Workflow
+
+## Overview
+Create comprehensive Architecture Decision Records (ADRs) that systematically document architectural decisions with clear rationale, alternatives considered, and consequences through structured analysis and review process.
+
+## When to Use
+- Making significant architectural decisions affecting system structure
+- Documenting technology choices with vendor lock-in or high switching costs
+- Recording decisions contrary to team expectations or industry standards
+- Capturing complex trade-offs between competing approaches
+- Establishing architectural patterns and standards for team consistency
+
+## Prerequisites
+
+**MANDATORY:** This workflow automatically executes research if no relevant research exists.
+
+Process:
+1. Check for existing research on the decision topic
+2. If no research found: **automatically execute** complete research workflow
+3. Only proceed with ADR creation after research is completed
+
+## Implementation Steps
+
+### Step 1: Check for Existing Research and Auto-Execute if Missing
+
+Use `find_by_name` to search for related research:
+```bash
+find .code-captain/research -name "*[topic]*" -type f
+```
+
+Use `list_dir` to explore research directory structure.
+
+If no relevant research found:
+```
+❌ No existing research found for this architectural decision.
+
+🔄 AUTOMATICALLY EXECUTING RESEARCH WORKFLOW FIRST...
+
+Reading .code-captain/commands/research.md and executing complete research process...
+```
+
+**Execute research workflow automatically:**
+- Use `view_file` to read research workflow documentation
+- Execute 4-phase research methodology:
+  - Phase 1: Define Research Scope
+  - Phase 2: Initial Discovery  
+  - Phase 3: Deep Dive Analysis
+  - Phase 4: Synthesis and Recommendations
+- Use `write_to_file` to create research document
+- **ONLY CONTINUE** with ADR creation after research is completed
+
+### Step 2: Analyze Decision Context and Current State
+
+**Analysis Actions:**
+
+1. **Understand current architectural patterns:**
+   - Use `codebase_search` with queries:
+     - "What architectural patterns are currently in use?"
+     - "How are similar decisions handled in the codebase?"
+     - "What dependencies and integrations exist?"
+
+2. **Find existing ADRs:**
+   - Use `find_by_name` to locate existing ADRs in `.code-captain/decision-records/`
+   - Use `list_dir` to explore system structure
+
+3. **Gather decision context:**
+   - Identify decision stakeholders and concerns
+   - Determine specific decision needed and urgency
+   - Document current architectural context
+
+### Step 3: Define Decision Scope and Criteria
+
+**Actions:**
+1. Define the specific architectural decision requiring documentation
+2. Identify driving forces and constraints:
+   - Business requirements and goals
+   - Technical constraints and limitations
+   - Performance, security, scalability requirements
+   - Team skills and organizational capabilities
+   - Timeline and budget constraints
+3. Establish decision criteria and priorities
+4. Determine decision maker(s) and approval process
+5. Set boundaries for decision scope
+
+### Step 4: Research Alternatives and Evaluate Options
+
+**Research Actions:**
+
+1. **Leverage existing research (if found in Step 1):**
+   - Use `view_file` to review research documents
+   - Extract key insights, alternatives, and recommendations
+   - Identify gaps needing additional investigation
+
+2. **Conduct additional web research:**
+   - Use `search_web` for:
+     - "[technology/pattern] architectural approaches"
+     - "[decision area] best practices"
+     - "[technology] vs [alternative] comparison"
+     - "[pattern] pros and cons"
+
+3. **Use `codebase_search` to understand current implementation**
+
+4. **Document alternative options:**
+   - Current state/status quo option
+   - Industry standard approaches
+   - Innovative or emerging alternatives
+   - Hybrid approaches
+
+**Evaluation Framework:**
+For each alternative, evaluate:
+- Technical feasibility and complexity
+- Performance and scalability implications
+- Security and compliance considerations
+- Development effort and timeline
+- Long-term maintenance and evolution
+- Risk assessment and mitigation strategies
+
+### Step 5: Document ADR with Decision Rationale
+
+**Preparation:**
+
+1. **Get current date:**
+   ```bash
+   date +%Y-%m-%d
+   ```
+
+2. **Determine ADR number:**
+   - Check existing ADRs in `.code-captain/decision-records/`
+   - Use sequential numbering (0001, 0002, etc.)
+
+3. **Create ADR using `write_to_file`:**
+
+4. **After completion, create memory of the decision:**
+   Ask Cascade: "Please create a memory of this architectural decision: [brief summary of the chosen option and key rationale]"
+
+## ADR Template
+
+```markdown
+# NNNN. [Decision Title]
+
+**Date:** [Current date]
+**Status:** [Proposed/Accepted/Deprecated/Superseded]
+**Deciders:** [Names or roles of decision makers]
+**Technical Story:** [Brief reference to related requirement]
+
+## Context and Problem Statement
+
+[Describe the architectural problem requiring decision. Include business context, technical context, and driving forces.]
+
+### Driving Forces
+- **Business Driver 1:** [e.g., Need to support 10x user growth]
+- **Technical Driver 2:** [e.g., Current monolith becoming unmaintainable]
+- **Organizational Driver 3:** [e.g., Team scaling requires better separation]
+
+### Assumptions
+- [Any assumptions made during decision process]
+- [External dependencies assumed to remain stable]
+
+## Decision Drivers
+
+[Key factors influencing this decision, in order of importance]
+- **Driver 1:** [e.g., Scalability requirements]
+- **Driver 2:** [e.g., Team autonomy and development velocity]
+- **Driver 3:** [e.g., Technology stack modernization]
+
+## Considered Options
+
+### Option 1: [Name, e.g., "Maintain Current Monolithic Architecture"]
+
+**Description:** [Brief description]
+
+**Pros:**
+- [Positive aspect 1]
+- [Positive aspect 2]
+
+**Cons:**
+- [Negative aspect 1]
+- [Negative aspect 2]
+
+**Effort:** [Implementation effort assessment]
+**Risk:** [Risk level and key risks]
+
+### Option 2: [Name, e.g., "Migrate to Microservices Architecture"]
+
+**Description:** [Brief description]
+
+**Pros:**
+- [Positive aspect 1]
+- [Positive aspect 2]
+
+**Cons:**
+- [Negative aspect 1]
+- [Negative aspect 2]
+
+**Effort:** [Implementation effort assessment]
+**Risk:** [Risk level and key risks]
+
+### Option 3: [Name, e.g., "Hybrid Modular Monolith Approach"]
+
+**Description:** [Brief description]
+
+**Pros:**
+- [Positive aspect 1]
+- [Positive aspect 2]
+
+**Cons:**
+- [Negative aspect 1]
+- [Negative aspect 2]
+
+**Effort:** [Implementation effort assessment]
+**Risk:** [Risk level and key risks]
+
+## Decision Outcome
+
+**Chosen Option:** [Selected option with brief rationale]
+
+### Rationale
+[Detailed explanation of why this option was selected. Reference decision drivers and how this option best addresses them.]
+
+### Confirmation
+[How will we know this decision is working? What metrics will we monitor?]
+
+## Consequences
+
+### Positive Consequences
+- [Positive outcome 1 - improvements this enables]
+- [Positive outcome 2 - capabilities this provides]
+- [Positive outcome 3 - risks this mitigates]
+
+### Negative Consequences
+- [Negative outcome 1 - complexities this introduces]
+- [Negative outcome 2 - trade-offs this requires]
+- [Negative outcome 3 - new risks this creates]
+
+### Mitigation Strategies
+- [Strategy 1 for addressing negative consequences]
+- [Strategy 2 for managing introduced complexities]
+
+## Implementation Notes
+
+### Prerequisites
+- [What needs to be in place before implementing]
+- [Dependencies that must be resolved first]
+
+### Implementation Steps
+1. [Step 1 - immediate actions required]
+2. [Step 2 - follow-up activities]
+3. [Step 3 - validation and monitoring setup]
+
+### Success Criteria
+- [Measurable criteria for successful implementation]
+- [Timeline for achieving implementation milestones]
+
+## Follow-up Actions
+- [Action item 1 with owner and timeline]
+- [Action item 2 with owner and timeline]
+- [Review date for evaluating decision effectiveness]
+
+## References
+- [Link to related ADRs]
+- [Prior research documents from .code-captain/research/]
+- [External documentation, articles, or research]
+- [Code repositories or examples]
+
+## Related Decisions
+- [ADR-XXXX: Related decision that influences this one]
+- [ADR-YYYY: Decision that this supersedes or is superseded by]
+```
+
+## Best Practices
+
+### Decision Scope and Focus
+- Focus on one significant architectural decision per ADR
+- Clearly separate problem from potential solutions
+- Include sufficient context for future readers
+- Document decision even if it seems obvious
+- Consider both technical and business implications
+
+### Alternatives Analysis
+- Always include "do nothing" or "status quo" option
+- Research industry standards and best practices
+- Consider short-term and long-term implications
+- Include effort and risk assessments for each option
+- Seek diverse perspectives and expert opinions
+
+### Decision Documentation
+- Use clear, jargon-free language for new team members
+- Include relevant diagrams, code examples, or architectural sketches
+- Reference external sources and supporting documentation
+- Document both positive and negative consequences honestly
+- Plan for decision review and potential revision
+
+### Stakeholder Engagement
+- Involve all teams affected by architectural decision
+- Allow time for thoughtful review and feedback
+- Document dissenting opinions and how they were addressed
+- Ensure decision makers have sufficient context and time
+- Follow up on implementation and measure success
+
+## Windsurf Tools Used
+
+- `find_by_name`: Locate existing research and ADRs
+- `list_dir`: Explore directory structures
+- `view_file`: Read existing documentation and research
+- `write_to_file`: Create ADR document
+- `codebase_search`: Understand current architectural patterns
+- `search_web`: Research alternatives and best practices
+- `run_command`: Get current date and system information
+
+## Windsurf Features Used
+
+- **Memories**: After completing the ADR, ask Cascade to "create a memory of the architectural decision and its rationale" for future reference
+
+## Common Pitfalls to Avoid
+
+- Rushing to document without proper analysis
+- Making decisions without stakeholder input
+- Failing to research alternative approaches thoroughly
+- Not considering long-term consequences
+- Writing ADRs too technical for business stakeholders
+- Not updating ADR status when decisions change
+- Creating ADRs for trivial decisions
+- Not linking ADRs to related architectural documentation
+
+---
+
+*📐 Architecture decisions shape the future. Document them well.*