@monoes/monomindcli 1.6.0

package/.claude/commands/sparc.md

@@ -0,0 +1,166 @@
+---
+name: sparc
+description: Execute SPARC methodology workflows with Monomind
+---
+
+# ⚡️ 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__monomind__sparc_mode {
+  mode: "sparc",
+  task_description: "build complete authentication system"
+}
+
+// Run a specific mode
+mcp__monomind__sparc_mode {
+  mode: "architect",
+  task_description: "design API structure"
+}
+
+// TDD workflow
+mcp__monomind__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 monomind sparc "build complete authentication system"
+
+# Run a specific mode
+npx monomind sparc run architect "design API structure"
+npx monomind sparc run tdd "implement user service"
+
+# Execute full TDD workflow
+npx monomind sparc tdd "implement user authentication"
+
+# List all modes with details
+npx monomind sparc modes --verbose
+
+# For alpha features
+npx monomind@alpha sparc run <mode> "your task"
+```
+
+### Option 3: Local Installation
+```bash
+# If monomind is installed locally
+./monomind sparc "build complete authentication system"
+./monomind 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__monomind__memory_usage {
+  action: "store",
+  key: "spec_auth",
+  value: "OAuth2 + JWT requirements",
+  namespace: "spec"
+}
+
+// Store architectural decisions
+mcp__monomind__memory_usage {
+  action: "store",
+  key: "arch_decisions",
+  value: "Microservices with API Gateway",
+  namespace: "architecture"
+}
+```
+
+### Using NPX CLI (Fallback)
+```bash
+# Store specifications
+npx monomind memory store "spec_auth" "OAuth2 + JWT requirements" --namespace spec
+
+# Store architectural decisions
+./monomind memory store "arch_api" "RESTful microservices design" --namespace arch
+
+# Query previous work
+./monomind memory query "authentication" --limit 10
+
+# Export project memory
+./monomind memory export sparc-project-backup.json
+```
+
+## Advanced Swarm Mode
+
+For complex tasks requiring multiple agents with timeout-free execution:
+```bash
+# Development swarm with monitoring
+./monomind swarm "Build e-commerce platform" --strategy development --monitor --review
+
+# Background optimization swarm
+./monomind swarm "Optimize system performance" --strategy optimization --background
+
+# Distributed research swarm
+./monomind swarm "Analyze market trends" --strategy research --distributed --ui
+```
+
+## Non-Interactive Mode
+
+For CI/CD integration and automation:
+```bash
+./monomind sparc run code "implement API" --non-interactive
+./monomind 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 `/monomind-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
+monomind stream-chain pipeline <type> [options]
+```
+
+## Available Pipelines
+
+### analysis
+Code analysis and improvement pipeline.
+
+```bash
+monomind 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
+monomind 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
+monomind 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
+monomind 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
+monomind stream-chain pipeline analysis
+```
+
+### Refactor with Extended Timeout
+```bash
+monomind stream-chain pipeline refactor --timeout 60
+```
+
+### Verbose Test Generation
+```bash
+monomind stream-chain pipeline test --verbose
+```
+
+### Performance Optimization
+```bash
+monomind 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 `.monomind/config.json`:
+
+```json
+{
+  "streamChain": {
+    "pipelines": {
+      "security": {
+        "name": "Security Audit Pipeline",
+        "prompts": [
+          "Scan for security vulnerabilities",
+          "Prioritize by severity",
+          "Generate fixes"
+        ]
+      }
+    }
+  }
+}
+```
+
+Then run:
+```bash
+monomind 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
+monomind 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
+monomind stream-chain run \
+  "Write a function" \
+  "Add tests for it"
+```
+
+### Complex Workflow
+```bash
+monomind 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
+monomind 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 Monomind.
+
+## 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__monomind__swarm_init({
+  "topology": "mesh",
+  "maxAgents": 6,
+  "strategy": "adaptive"
+})
+
+// Orchestrate analysis task
+mcp__monomind__task_orchestrate({
+  "task": "analyze system performance",
+  "strategy": "parallel",
+  "priority": "medium"
+})
+```
+
+### Using CLI (Fallback)
+`npx monomind swarm "analyze system performance" --strategy analysis`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn analysis agents
+mcp__monomind__agent_spawn({
+  "type": "analyst",
+  "name": "Data Collector",
+  "capabilities": ["metrics", "logging", "monitoring"]
+})
+
+mcp__monomind__agent_spawn({
+  "type": "analyst",
+  "name": "Pattern Analyzer",
+  "capabilities": ["pattern-recognition", "anomaly-detection"]
+})
+
+mcp__monomind__agent_spawn({
+  "type": "documenter",
+  "name": "Report Generator",
+  "capabilities": ["reporting", "visualization"]
+})
+
+mcp__monomind__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__monomind__performance_report({
+  "format": "detailed",
+  "timeframe": "24h"
+})
+
+// Identify bottlenecks
+mcp__monomind__bottleneck_analyze({
+  "component": "api",
+  "metrics": ["response-time", "throughput"]
+})
+
+// Pattern recognition
+mcp__monomind__pattern_recognize({
+  "data": performanceData,
+  "patterns": ["anomaly", "trend", "cycle"]
+})
+```
+
+## Status Monitoring
+```javascript
+// Monitor analysis progress
+mcp__monomind__task_status({
+  "taskId": "analysis-task-001"
+})
+
+// Get analysis results
+mcp__monomind__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__monomind__swarm_init({
+  "topology": "hierarchical",
+  "maxAgents": 8,
+  "strategy": "balanced"
+})
+
+// Orchestrate development task
+mcp__monomind__task_orchestrate({
+  "task": "build feature X",
+  "strategy": "parallel",
+  "priority": "high"
+})
+```
+
+### Using CLI (Fallback)
+`npx monomind swarm "build feature X" --strategy development`
+
+## Agent Roles
+
+### Agent Spawning with MCP
+```javascript
+// Spawn development agents
+mcp__monomind__agent_spawn({
+  "type": "architect",
+  "name": "System Designer",
+  "capabilities": ["system-design", "api-design"]
+})
+
+mcp__monomind__agent_spawn({
+  "type": "coder",
+  "name": "Frontend Developer",
+  "capabilities": ["react", "typescript", "ui"]
+})
+
+mcp__monomind__agent_spawn({
+  "type": "coder",
+  "name": "Backend Developer",
+  "capabilities": ["nodejs", "api", "database"]
+})
+
+mcp__monomind__agent_spawn({
+  "type": "specialist",
+  "name": "Database Expert",
+  "capabilities": ["sql", "nosql", "optimization"]
+})
+
+mcp__monomind__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__monomind__swarm_status({
+  "swarmId": "development-swarm"
+})
+
+// Monitor agent performance
+mcp__monomind__agent_metrics({
+  "agentId": "architect-001"
+})
+
+// Real-time monitoring
+mcp__monomind__swarm_monitor({
+  "swarmId": "development-swarm",
+  "interval": 5000
+})
+```
+
+## Error Handling
+```javascript
+// Enable fault tolerance
+mcp__monomind__daa_fault_tolerance({
+  "agentId": "all",
+  "strategy": "auto-recovery"
+})
+```