@monoes/cli 1.0.0

package/.claude/commands/sparc.md

@@ -0,0 +1,166 @@
+---
+name: sparc
+description: Execute SPARC methodology workflows with Monobrain
+---
+
+# ⚡️ SPARC Development Methodology
+
+You are SPARC, the orchestrator of complex workflows. You break down large objectives into delegated subtasks aligned to the SPARC methodology. You ensure secure, modular, testable, and maintainable delivery using the appropriate specialist modes.
+
+## SPARC Workflow
+
+Follow SPARC:
+
+1. Specification: Clarify objectives and scope. Never allow hard-coded env vars.
+2. Pseudocode: Request high-level logic with TDD anchors.
+3. Architecture: Ensure extensible system diagrams and service boundaries.
+4. Refinement: Use TDD, debugging, security, and optimization flows.
+5. Completion: Integrate, document, and monitor for continuous improvement.
+
+Use `new_task` to assign:
+- spec-pseudocode
+
+## Available SPARC Modes
+
+- `/sparc-architect` - 🏗️ Architect
+- `/sparc-code` - 🧠 Auto-Coder
+- `/sparc-tdd` - 🧪 Tester (TDD)
+- `/sparc-debug` - 🪲 Debugger
+- `/sparc-security-review` - 🛡️ Security Reviewer
+- `/sparc-docs-writer` - 📚 Documentation Writer
+- `/sparc-integration` - 🔗 System Integrator
+- `/sparc-post-deployment-monitoring-mode` - 📈 Deployment Monitor
+- `/sparc-refinement-optimization-mode` - 🧹 Optimizer
+- `/sparc-ask` - ❓Ask
+- `/sparc-devops` - 🚀 DevOps
+- `/sparc-tutorial` - 📘 SPARC Tutorial
+- `/sparc-supabase-admin` - 🔐 Supabase Admin
+- `/sparc-spec-pseudocode` - 📋 Specification Writer
+- `/sparc-mcp` - ♾️ MCP Integration
+- `/sparc-sparc` - ⚡️ SPARC Orchestrator
+
+## Quick Start
+
+### Option 1: Using MCP Tools (Preferred in Claude Code)
+```javascript
+// Run SPARC orchestrator (default)
+mcp__monobrain__sparc_mode {
+  mode: "sparc",
+  task_description: "build complete authentication system"
+}
+
+// Run a specific mode
+mcp__monobrain__sparc_mode {
+  mode: "architect",
+  task_description: "design API structure"
+}
+
+// TDD workflow
+mcp__monobrain__sparc_mode {
+  mode: "tdd",
+  task_description: "implement user authentication",
+  options: {workflow: "full"}
+}
+```
+
+### Option 2: Using NPX CLI (Fallback when MCP not available)
+```bash
+# Run SPARC orchestrator (default)
+npx monobrain sparc "build complete authentication system"
+
+# Run a specific mode
+npx monobrain sparc run architect "design API structure"
+npx monobrain sparc run tdd "implement user service"
+
+# Execute full TDD workflow
+npx monobrain sparc tdd "implement user authentication"
+
+# List all modes with details
+npx monobrain sparc modes --verbose
+
+# For alpha features
+npx monobrain@alpha sparc run <mode> "your task"
+```
+
+### Option 3: Local Installation
+```bash
+# If monobrain is installed locally
+./monobrain sparc "build complete authentication system"
+./monobrain sparc run architect "design API structure"
+```
+
+## SPARC Methodology Phases
+
+1. **📋 Specification**: Define requirements, constraints, and acceptance criteria
+2. **🧠 Pseudocode**: Create detailed logic flows and algorithmic planning
+3. **🏗️ Architecture**: Design system structure, APIs, and component boundaries
+4. **🔄 Refinement**: Implement with TDD (Red-Green-Refactor cycle)
+5. **✅ Completion**: Integrate, document, and validate against requirements
+
+## Memory Integration
+
+### Using MCP Tools (Preferred)
+```javascript
+// Store specifications
+mcp__monobrain__memory_usage {
+  action: "store",
+  key: "spec_auth",
+  value: "OAuth2 + JWT requirements",
+  namespace: "spec"
+}
+
+// Store architectural decisions
+mcp__monobrain__memory_usage {
+  action: "store",
+  key: "arch_decisions",
+  value: "Microservices with API Gateway",
+  namespace: "architecture"
+}
+```
+
+### Using NPX CLI (Fallback)
+```bash
+# Store specifications
+npx monobrain memory store "spec_auth" "OAuth2 + JWT requirements" --namespace spec
+
+# Store architectural decisions
+./monobrain memory store "arch_api" "RESTful microservices design" --namespace arch
+
+# Query previous work
+./monobrain memory query "authentication" --limit 10
+
+# Export project memory
+./monobrain memory export sparc-project-backup.json
+```
+
+## Advanced Swarm Mode
+
+For complex tasks requiring multiple agents with timeout-free execution:
+```bash
+# Development swarm with monitoring
+./monobrain swarm "Build e-commerce platform" --strategy development --monitor --review
+
+# Background optimization swarm
+./monobrain swarm "Optimize system performance" --strategy optimization --background
+
+# Distributed research swarm
+./monobrain swarm "Analyze market trends" --strategy research --distributed --ui
+```
+
+## Non-Interactive Mode
+
+For CI/CD integration and automation:
+```bash
+./monobrain sparc run code "implement API" --non-interactive
+./monobrain sparc tdd "user tests" --non-interactive --enable-permissions
+```
+
+## Best Practices
+
+✅ **Modular Design**: Keep files under 500 lines
+✅ **Environment Safety**: Never hardcode secrets or env values
+✅ **Test-First**: Always write tests before implementation
+✅ **Memory Usage**: Store important decisions and context
+✅ **Task Completion**: All tasks should end with `attempt_completion`
+
+See `/monobrain-help` for all available commands.

package/.claude/commands/stream-chain/pipeline.md

@@ -0,0 +1,121 @@
+# stream-chain pipeline
+
+Execute predefined pipelines for common development workflows.
+
+## Usage
+
+```bash
+monobrain stream-chain pipeline <type> [options]
+```
+
+## Available Pipelines
+
+### analysis
+Code analysis and improvement pipeline.
+
+```bash
+monobrain stream-chain pipeline analysis
+```
+
+**Steps:**
+1. Analyze current directory structure and identify main components
+2. Based on analysis, identify potential improvements and issues
+3. Generate detailed report with actionable recommendations
+
+### refactor
+Automated refactoring workflow.
+
+```bash
+monobrain stream-chain pipeline refactor
+```
+
+**Steps:**
+1. Identify code that could benefit from refactoring
+2. Create prioritized refactoring plan with specific changes
+3. Provide refactored code examples for top 3 priorities
+
+### test
+Comprehensive test generation.
+
+```bash
+monobrain stream-chain pipeline test
+```
+
+**Steps:**
+1. Analyze codebase and identify areas lacking test coverage
+2. Design comprehensive test cases for critical functions
+3. Generate unit test implementations with assertions
+
+### optimize
+Performance optimization pipeline.
+
+```bash
+monobrain stream-chain pipeline optimize
+```
+
+**Steps:**
+1. Profile codebase and identify performance bottlenecks
+2. Analyze bottlenecks and suggest optimization strategies
+3. Provide optimized implementations for main issues
+
+## Options
+
+- `--verbose` - Show detailed execution
+- `--timeout <seconds>` - Timeout per step (default: 30)
+- `--debug` - Enable debug mode
+
+## Examples
+
+### Run Analysis Pipeline
+```bash
+monobrain stream-chain pipeline analysis
+```
+
+### Refactor with Extended Timeout
+```bash
+monobrain stream-chain pipeline refactor --timeout 60
+```
+
+### Verbose Test Generation
+```bash
+monobrain stream-chain pipeline test --verbose
+```
+
+### Performance Optimization
+```bash
+monobrain stream-chain pipeline optimize --debug
+```
+
+## Output
+
+Each pipeline generates:
+- Step-by-step execution progress
+- Success/failure status per step
+- Total execution time
+- Summary of results
+
+## Custom Pipelines
+
+Define custom pipelines in `.monobrain/config.json`:
+
+```json
+{
+  "streamChain": {
+    "pipelines": {
+      "security": {
+        "name": "Security Audit Pipeline",
+        "prompts": [
+          "Scan for security vulnerabilities",
+          "Prioritize by severity",
+          "Generate fixes"
+        ]
+      }
+    }
+  }
+}
+```
+
+Then run:
+```bash
+monobrain stream-chain pipeline security
+```

package/.claude/commands/stream-chain/run.md

@@ -0,0 +1,70 @@
+# stream-chain run
+
+Execute a custom stream chain with your own prompts.
+
+## Usage
+
+```bash
+monobrain stream-chain run <prompt1> <prompt2> [...] [options]
+```
+
+Minimum 2 prompts required for chaining.
+
+## Options
+
+- `--verbose` - Show detailed execution information
+- `--timeout <seconds>` - Timeout per step (default: 30)
+- `--debug` - Enable debug mode
+
+## How It Works
+
+Each prompt in the chain receives the complete output from the previous step as context, enabling complex multi-step workflows.
+
+## Examples
+
+### Basic Chain
+```bash
+monobrain stream-chain run \
+  "Write a function" \
+  "Add tests for it"
+```
+
+### Complex Workflow
+```bash
+monobrain stream-chain run \
+  "Analyze the authentication system" \
+  "Identify security vulnerabilities" \
+  "Propose fixes with priority levels" \
+  "Implement the critical fixes" \
+  "Generate tests for the fixes"
+```
+
+### With Options
+```bash
+monobrain stream-chain run \
+  "Complex analysis task" \
+  "Detailed implementation" \
+  --timeout 60 \
+  --verbose
+```
+
+## Context Preservation
+
+The output from each step is injected into the next prompt:
+
+```
+Step 1: "Write a sorting function"
+Output: [function code]
+
+Step 2 receives: "Previous step output:
+[function code]
+
+Next step: Optimize for performance"
+```
+
+## Best Practices
+
+1. **Clear Instructions**: Make each prompt specific
+2. **Logical Flow**: Order prompts in logical sequence
+3. **Appropriate Timeouts**: Increase for complex tasks
+4. **Verification**: Add verification steps in chain

package/.claude/commands/swarm/README.md

@@ -0,0 +1,15 @@
+# Swarm Commands
+
+Commands for swarm operations in Monobrain.
+
+## Available Commands
+
+- [swarm](./swarm.md)
+- [swarm-init](./swarm-init.md)
+- [swarm-spawn](./swarm-spawn.md)
+- [swarm-status](./swarm-status.md)
+- [swarm-monitor](./swarm-monitor.md)
+- [swarm-strategies](./swarm-strategies.md)
+- [swarm-modes](./swarm-modes.md)
+- [swarm-background](./swarm-background.md)
+- [swarm-analysis](./swarm-analysis.md)

package/.claude/commands/swarm/analysis.md

@@ -0,0 +1,95 @@
+# Analysis Swarm Strategy
+
+## Purpose
+Comprehensive analysis through distributed agent coordination.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize analysis swarm
+mcp__monobrain__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Orchestrate analysis task
+mcp__monobrain__task_orchestrate({
+  "task": "analyze system performance",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+```
+
+### Using CLI (Fallback)
+`npx monobrain swarm "analyze system performance" --strategy analysis`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn analysis agents
+mcp__monobrain__agent_spawn({
+  "type": "analyst",
+  "name": "Data Collector",
+  "capabilities": ["metrics", "logging", "monitoring"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "analyst",
+  "name": "Pattern Analyzer",
+  "capabilities": ["pattern-recognition", "anomaly-detection"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "documenter",
+  "name": "Report Generator",
+  "capabilities": ["reporting", "visualization"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "coordinator",
+  "name": "Insight Synthesizer",
+  "capabilities": ["synthesis", "correlation"]
+})
+```
+
+## Coordination Modes
+- Mesh: For exploratory analysis
+- Pipeline: For sequential processing
+- Hierarchical: For complex systems
+
+## Analysis Operations
+```javascript
+// Run performance analysis
+mcp__monobrain__performance_report({
+  "format": "detailed",
+  "timeframe": "24h"
+})
+
+// Identify bottlenecks
+mcp__monobrain__bottleneck_analyze({
+  "component": "api",
+  "metrics": ["response-time", "throughput"]
+})
+
+// Pattern recognition
+mcp__monobrain__pattern_recognize({
+  "data": performanceData,
+  "patterns": ["anomaly", "trend", "cycle"]
+})
+```
+
+## Status Monitoring
+```javascript
+// Monitor analysis progress
+mcp__monobrain__task_status({
+  "taskId": "analysis-task-001"
+})
+
+// Get analysis results
+mcp__monobrain__task_results({
+  "taskId": "analysis-task-001"
+})
+```

package/.claude/commands/swarm/development.md

@@ -0,0 +1,96 @@
+# Development Swarm Strategy
+
+## Purpose
+Coordinated development through specialized agent teams.
+
+## Activation
+
+### Using MCP Tools
+```javascript
+// Initialize development swarm
+mcp__monobrain__swarm_init({
+  "topology": "hierarchical",
+  "maxAgents": 8,
+  "strategy": "balanced"
+})
+
+// Orchestrate development task
+mcp__monobrain__task_orchestrate({
+  "task": "build feature X",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx monobrain swarm "build feature X" --strategy development`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn development agents
+mcp__monobrain__agent_spawn({
+  "type": "architect",
+  "name": "System Designer",
+  "capabilities": ["system-design", "api-design"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "coder",
+  "name": "Frontend Developer",
+  "capabilities": ["react", "typescript", "ui"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "coder",
+  "name": "Backend Developer",
+  "capabilities": ["nodejs", "api", "database"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "specialist",
+  "name": "Database Expert",
+  "capabilities": ["sql", "nosql", "optimization"]
+})
+
+mcp__monobrain__agent_spawn({
+  "type": "tester",
+  "name": "Integration Tester",
+  "capabilities": ["integration", "e2e", "api-testing"]
+})
+```
+
+## Best Practices
+- Use hierarchical mode for large projects
+- Enable parallel execution
+- Implement continuous testing
+- Monitor swarm health regularly
+
+## Status Monitoring
+```javascript
+// Check swarm status
+mcp__monobrain__swarm_status({
+  "swarmId": "development-swarm"
+})
+
+// Monitor agent performance
+mcp__monobrain__agent_metrics({
+  "agentId": "architect-001"
+})
+
+// Real-time monitoring
+mcp__monobrain__swarm_monitor({
+  "swarmId": "development-swarm",
+  "interval": 5000
+})
+```
+
+## Error Handling
+```javascript
+// Enable fault tolerance
+mcp__monobrain__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "auto-recovery"
+})
+```