@monoes/monomindcli 1.8.0 → 1.9.0

package/.claude/commands/sparc/reviewer.md

@@ -1,35 +1,18 @@
+---
+name: sparc:reviewer
+description: Reviewer - Code review using batch file analysis for comprehensive reviews. Security, performance, correctness, and design pattern assessment.
+---
+
 # SPARC Reviewer Mode
 
 ## Purpose
 Code review using batch file analysis for comprehensive reviews.
 
-## Activation
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "reviewer",
-  task_description: "review pull request #123",
-  options: {
-    security_check: true,
-    performance_check: true
-  }
-}
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run reviewer "review pull request #123"
-
-# For alpha features
-npx monomind@alpha sparc run reviewer "review pull request #123"
-```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run reviewer "review pull request #123"
+Skill("sparc:reviewer")
 ```
 
 ## Core Capabilities

package/.claude/commands/sparc/security-review.md

@@ -1,9 +1,9 @@
 ---
-name: sparc-security-review
-description: 🛡️ Security Reviewer - You perform static and dynamic audits to ensure secure code practices. You flag secrets, poor mod...
+name: sparc:security-review
+description: Security Reviewer - You perform static and dynamic audits to ensure secure code practices. You flag secrets, poor modular boundaries, and oversized files.
 ---
 
-# 🛡️ Security Reviewer
+# Security Reviewer
 
 ## Role Definition
 You perform static and dynamic audits to ensure secure code practices. You flag secrets, poor modular boundaries, and oversized files.
@@ -15,66 +15,25 @@ Scan for exposed secrets, env leaks, and monoliths. Recommend mitigations or ref
 - **read**: File reading and viewing
 - **edit**: File modification and creation
 
-## Usage
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "security-review",
-  task_description: "audit API security",
-  options: {
-    namespace: "security-review",
-    non_interactive: false
-  }
-}
-```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run security-review "audit API security"
-
-# For alpha features
-npx monomind@alpha sparc run security-review "audit API security"
-
-# With namespace
-npx monomind sparc run security-review "your task" --namespace security-review
-
-# Non-interactive mode
-npx monomind sparc run security-review "your task" --non-interactive
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run security-review "audit API security"
+Skill("sparc:security-review")
 ```
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
 ```javascript
-// Store mode-specific context
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "security-review_context",
-  value: "important decisions",
-  namespace: "security-review"
-}
+// Store context
+mcp__monomind__memory_store({ key: "security_context", value: "important decisions", namespace: "security" })
 
-// Query previous work
-mcp__monomind__memory_search {
-  pattern: "security-review",
-  namespace: "security-review",
-  limit: 5
-}
+// Search previous work
+mcp__monomind__memory_search({ query: "security", namespace: "security", limit: 5 })
 ```
 
-### Using NPX CLI (Fallback)
 ```bash
-# Store mode-specific context
-npx monomind memory store "security-review_context" "important decisions" --namespace security-review
-
-# Query previous work
-npx monomind memory query "security-review" --limit 5
+# CLI equivalents
+npx monomind memory store "security_context" "important decisions" --namespace security
+npx monomind memory search --query "security" --namespace security
 ```

package/.claude/commands/sparc/sparc-modes.md

@@ -1,174 +1,120 @@
+---
+name: sparc:sparc-modes
+description: SPARC Modes Overview - All 32 SPARC methodology modes with purpose and invocation guide. Entry point for selecting the right specialist mode.
+---
+
 # SPARC Modes Overview
 
-SPARC (Specification, Planning, Architecture, Review, Code) is a comprehensive development methodology with 17 specialized modes, all integrated with MCP tools for enhanced coordination and execution.
+SPARC (Specification, Pseudocode, Architecture, Refinement, Completion) is a development methodology with 32 specialized Claude Code skill modes. Each mode is invoked via `Skill("sparc:<mode>")`.
 
-## Available Modes
+## How to Use SPARC Modes
 
-### Core Orchestration Modes
-- **orchestrator**: Multi-agent task orchestration
-- **swarm-coordinator**: Specialized swarm management
-- **workflow-manager**: Process automation
-- **batch-executor**: Parallel task execution
-
-### Development Modes  
-- **coder**: Autonomous code generation
-- **architect**: System design
-- **reviewer**: Code review
-- **tdd**: Test-driven development
-
-### Analysis and Research Modes
-- **researcher**: Deep research capabilities
-- **analyzer**: Code and data analysis
-- **optimizer**: Performance optimization
-
-### Creative and Support Modes
-- **designer**: UI/UX design
-- **innovator**: Creative problem solving
-- **documenter**: Documentation generation
-- **debugger**: Systematic debugging
-- **tester**: Comprehensive testing
-- **memory-manager**: Knowledge management
-
-## Usage
-
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-// Execute SPARC mode directly
-mcp__monomind__sparc_mode {
-  mode: "<mode>",
-  task_description: "<task>",
-  options: {
-    // mode-specific options
-  }
-}
-
-// Initialize swarm for advanced coordination
-mcp__monomind__swarm_init {
-  topology: "hierarchical",
-  strategy: "auto",
-  maxAgents: 8
-}
-
-// Spawn specialized agents
-mcp__monomind__agent_spawn {
-  type: "<agent-type>",
-  capabilities: ["<capability1>", "<capability2>"]
-}
-
-// Monitor execution
-mcp__monomind__swarm_monitor {
-  swarmId: "current",
-  interval: 5000
-}
+Load any mode in Claude Code:
+```
+Skill("sparc:<mode-name>")
 ```
 
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run <mode> "task description"
-
-# For alpha features
-npx monomind@alpha sparc run <mode> "task description"
-
-# List all modes
-npx monomind sparc modes
+For the SPARC orchestrator (main entry point):
+```
+Skill("sparc:sparc")
+```
 
-# Get help for a mode
-npx monomind sparc help <mode>
 
-# Run with options
-npx monomind sparc run <mode> "task" --parallel --monitor
-```
+## Available Modes
 
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run <mode> "task description"
-```
+### Core Orchestration
+| Mode | Skill | Purpose |
+|------|-------|---------|
+| sparc | `sparc:sparc` | SPARC orchestrator — breaks tasks into delegated subtasks |
+| orchestrator | `sparc:orchestrator` | Multi-agent task coordination |
+| ask | `sparc:ask` | Task formulation guide — choose the right mode |
+| swarm-coordinator | `sparc:swarm-coordinator` | Specialized swarm management |
+| workflow-manager | `sparc:workflow-manager` | Process automation |
+| batch-executor | `sparc:batch-executor` | Parallel task execution |
+
+### Development
+| Mode | Skill | Purpose |
+|------|-------|---------|
+| code | `sparc:code` | Auto-coder: clean modular implementation |
+| coder | `sparc:coder` | Batch file code generation |
+| architect | `sparc:architect` | System design and API contracts |
+| spec-pseudocode | `sparc:spec-pseudocode` | Requirements and pseudocode specs |
+| tdd | `sparc:tdd` | Test-driven development cycle |
+| integration | `sparc:integration` | Merge outputs into production system |
+| devops | `sparc:devops` | CI/CD, deployment, infrastructure |
+| supabase-admin | `sparc:supabase-admin` | Supabase DB, auth, storage management |
+| mcp | `sparc:mcp` | External API and MCP integration |
+
+### Review and Quality
+| Mode | Skill | Purpose |
+|------|-------|---------|
+| reviewer | `sparc:reviewer` | Code review: correctness, security, patterns |
+| security-review | `sparc:security-review` | Security audit: secrets, exposure, CVEs |
+| tester | `sparc:tester` | Comprehensive testing (unit, E2E, perf) |
+| debugger | `sparc:debugger` | Systematic debugging with TodoWrite |
+| debug | `sparc:debug` | Runtime bug isolation and fix |
+
+### Analysis and Research
+| Mode | Skill | Purpose |
+|------|-------|---------|
+| researcher | `sparc:researcher` | Deep research with WebSearch/WebFetch |
+| analyzer | `sparc:analyzer` | Code and data analysis with batch ops |
+| optimizer | `sparc:optimizer` | Performance optimization cycle |
+| post-deployment-monitoring-mode | `sparc:post-deployment-monitoring-mode` | Production observability |
+| refinement-optimization-mode | `sparc:refinement-optimization-mode` | Refactor and optimize |
+
+### Creative and Support
+| Mode | Skill | Purpose |
+|------|-------|---------|
+| designer | `sparc:designer` | UI/UX design and component architecture |
+| innovator | `sparc:innovator` | Creative problem solving |
+| documenter | `sparc:documenter` | Batch documentation generation |
+| docs-writer | `sparc:docs-writer` | Markdown docs and guides |
+| memory-manager | `sparc:memory-manager` | Knowledge management |
+| tutorial | `sparc:tutorial` | SPARC onboarding and education |
 
 ## Common Workflows
 
 ### Full Development Cycle
-
-#### Using MCP Tools (Preferred)
-```javascript
-// 1. Initialize development swarm
-mcp__monomind__swarm_init {
-  topology: "hierarchical",
-  maxAgents: 12
-}
-
-// 2. Architecture design
-mcp__monomind__sparc_mode {
-  mode: "architect",
-  task_description: "design microservices"
-}
-
-// 3. Implementation
-mcp__monomind__sparc_mode {
-  mode: "coder",
-  task_description: "implement services"
-}
-
-// 4. Testing
-mcp__monomind__sparc_mode {
-  mode: "tdd",
-  task_description: "test all services"
-}
-
-// 5. Review
-mcp__monomind__sparc_mode {
-  mode: "reviewer",
-  task_description: "review implementation"
-}
 ```
-
-#### Using NPX CLI (Fallback)
-```bash
-# 1. Architecture design
-npx monomind sparc run architect "design microservices"
-
-# 2. Implementation
-npx monomind sparc run coder "implement services"
-
-# 3. Testing
-npx monomind sparc run tdd "test all services"
-
-# 4. Review
-npx monomind sparc run reviewer "review implementation"
+1. Skill("sparc:spec-pseudocode")  → define requirements
+2. Skill("sparc:architect")         → design system
+3. Skill("sparc:code")              → implement
+4. Skill("sparc:tdd")               → test-driven
+5. Skill("sparc:security-review")   → security audit
+6. Skill("sparc:integration")       → integrate
+7. Skill("sparc:docs-writer")       → document
+8. Skill("sparc:devops")            → deploy
+9. Skill("sparc:post-deployment-monitoring-mode") → monitor
 ```
 
 ### Research and Innovation
+```
+1. Skill("sparc:researcher")   → gather information
+2. Skill("sparc:innovator")    → propose solutions
+3. Skill("sparc:architect")    → design approach
+4. Skill("sparc:documenter")   → document findings
+```
 
-#### Using MCP Tools (Preferred)
-```javascript
-// 1. Research phase
-mcp__monomind__sparc_mode {
-  mode: "researcher",
-  task_description: "research best practices"
-}
-
-// 2. Innovation
-mcp__monomind__sparc_mode {
-  mode: "innovator",
-  task_description: "propose novel solutions"
-}
-
-// 3. Documentation
-mcp__monomind__sparc_mode {
-  mode: "documenter",
-  task_description: "document findings"
-}
+### Bug Fix
+```
+1. Skill("sparc:debug")        → isolate issue
+2. Skill("sparc:tdd")          → write failing test
+3. Skill("sparc:code")         → implement fix
+4. Skill("sparc:reviewer")     → review changes
 ```
 
-#### Using NPX CLI (Fallback)
-```bash
-# 1. Research phase
-npx monomind sparc run researcher "research best practices"
+## Multi-Agent Coordination
+
+For complex multi-agent orchestration, combine with real swarm tools:
+
+```javascript
+// Initialize swarm
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
 
-# 2. Innovation
-npx monomind sparc run innovator "propose novel solutions"
+// Check status
+mcp__monomind__swarm_status({ swarmId: "current" })
 
-# 3. Documentation
-npx monomind sparc run documenter "document findings"
+// Coordinate tasks
+mcp__monomind__coordination_orchestrate({ task: "feature development", strategy: "parallel" })
 ```

package/.claude/commands/sparc/sparc.md

@@ -1,9 +1,9 @@
 ---
-name: sparc-sparc
-description: ⚡️ SPARC Orchestrator - You are SPARC, the orchestrator of complex workflows. You break down large objectives into delega...
+name: sparc:sparc
+description: SPARC Orchestrator - You are SPARC, the orchestrator of complex workflows. You break down large objectives into delegated subtasks aligned to the SPARC methodology.
 ---
 
-# ⚡️ SPARC Orchestrator
+# SPARC Orchestrator
 
 ## Role Definition
 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.
@@ -37,10 +37,10 @@ Use `new_task` to assign:
 - Verify all required parameters are included before executing any tool
 
 Validate:
-✅ Files < 500 lines
-✅ No hard-coded env vars
-✅ Modular, testable outputs
-✅ All subtasks end with `attempt_completion` Initialize when any request is received with a brief welcome mesage. Use emojis to make it fun and engaging. Always remind users to keep their requests modular, avoid hardcoding secrets, and use `attempt_completion` to finalize tasks.
+- Files < 500 lines
+- No hard-coded env vars
+- Modular, testable outputs
+- All subtasks end with `attempt_completion`. Initialize when any request is received with a brief welcome message. Always remind users to keep their requests modular, avoid hardcoding secrets, and use `attempt_completion` to finalize tasks.
 use new_task for each new task as a sub-task.
 
 ## Available Tools
@@ -48,64 +48,24 @@ use new_task for each new task as a sub-task.
 
 ## Usage
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "sparc",
-  task_description: "orchestrate authentication system",
-  options: {
-    namespace: "sparc",
-    non_interactive: false
-  }
-}
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run sparc "orchestrate authentication system"
-
-# For alpha features
-npx monomind@alpha sparc run sparc "orchestrate authentication system"
-
-# With namespace
-npx monomind sparc run sparc "your task" --namespace sparc
-
-# Non-interactive mode
-npx monomind sparc run sparc "your task" --non-interactive
+Skill("sparc:sparc")
 ```
 
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run sparc "orchestrate authentication system"
-```
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
 ```javascript
-// Store mode-specific context
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "sparc_context",
-  value: "important decisions",
-  namespace: "sparc"
-}
-
-// Query previous work
-mcp__monomind__memory_search {
-  pattern: "sparc",
-  namespace: "sparc",
-  limit: 5
-}
+// Store context
+mcp__monomind__memory_store({ key: "sparc_context", value: "important decisions", namespace: "sparc" })
+
+// Search previous work
+mcp__monomind__memory_search({ query: "sparc", namespace: "sparc", limit: 5 })
 ```
 
-### Using NPX CLI (Fallback)
 ```bash
-# Store mode-specific context
+# CLI equivalents
 npx monomind memory store "sparc_context" "important decisions" --namespace sparc
-
-# Query previous work
-npx monomind memory query "sparc" --limit 5
+npx monomind memory search --query "sparc" --namespace sparc
 ```

package/.claude/commands/sparc/spec-pseudocode.md

@@ -1,9 +1,9 @@
 ---
-name: sparc-spec-pseudocode
-description: 📋 Specification Writer - You capture full project context—functional requirements, edge cases, constraints—and translate t...
+name: sparc:spec-pseudocode
+description: Specification Writer - You capture full project context - functional requirements, edge cases, constraints - and translate that into modular pseudocode with TDD anchors.
 ---
 
-# 📋 Specification Writer
+# Specification Writer
 
 ## Role Definition
 You capture full project context—functional requirements, edge cases, constraints—and translate that into modular pseudocode with TDD anchors.
@@ -15,66 +15,25 @@ Write pseudocode as a series of md files with phase_number_name.md and flow logi
 - **read**: File reading and viewing
 - **edit**: File modification and creation
 
-## Usage
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "spec-pseudocode",
-  task_description: "define payment flow requirements",
-  options: {
-    namespace: "spec-pseudocode",
-    non_interactive: false
-  }
-}
-```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run spec-pseudocode "define payment flow requirements"
-
-# For alpha features
-npx monomind@alpha sparc run spec-pseudocode "define payment flow requirements"
-
-# With namespace
-npx monomind sparc run spec-pseudocode "your task" --namespace spec-pseudocode
-
-# Non-interactive mode
-npx monomind sparc run spec-pseudocode "your task" --non-interactive
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run spec-pseudocode "define payment flow requirements"
+Skill("sparc:spec-pseudocode")
 ```
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
 ```javascript
-// Store mode-specific context
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "spec-pseudocode_context",
-  value: "important decisions",
-  namespace: "spec-pseudocode"
-}
+// Store context
+mcp__monomind__memory_store({ key: "spec_context", value: "important decisions", namespace: "spec" })
 
-// Query previous work
-mcp__monomind__memory_search {
-  pattern: "spec-pseudocode",
-  namespace: "spec-pseudocode",
-  limit: 5
-}
+// Search previous work
+mcp__monomind__memory_search({ query: "spec-pseudocode", namespace: "spec", limit: 5 })
 ```
 
-### Using NPX CLI (Fallback)
 ```bash
-# Store mode-specific context
-npx monomind memory store "spec-pseudocode_context" "important decisions" --namespace spec-pseudocode
-
-# Query previous work
-npx monomind memory query "spec-pseudocode" --limit 5
+# CLI equivalents
+npx monomind memory store "spec_context" "important decisions" --namespace spec
+npx monomind memory search --query "spec-pseudocode" --namespace spec
 ```