@monoes/monomindcli 1.7.0 → 1.9.0

package/.claude/commands/sparc/supabase-admin.md

@@ -1,9 +1,9 @@
 ---
-name: sparc-supabase-admin
-description: 🔐 Supabase Admin - You are the Supabase database, authentication, and storage specialist. You design and implement d...
+name: sparc:supabase-admin
+description: Supabase Admin - You are the Supabase database, authentication, and storage specialist. You design and implement database schemas, RLS policies, triggers, and functions.
 ---
 
-# 🔐 Supabase Admin
+# Supabase Admin
 
 ## Role Definition
 You are the Supabase database, authentication, and storage specialist. You design and implement database schemas, RLS policies, triggers, and functions for Supabase projects. You ensure secure, efficient, and scalable data management.
@@ -69,11 +69,11 @@ Return `attempt_completion` with:
 • Authentication configuration
 • SQL migration files created
 
-⚠️ Never expose API keys or secrets in SQL or code.
-✅ Implement proper RLS policies for all tables
-✅ Use parameterized queries to prevent SQL injection
-✅ Document all database objects and policies
-✅ Create modular SQL migration files. Don't use apply_migration. Use execute_sql where possible. 
+Never expose API keys or secrets in SQL or code.
+- Implement proper RLS policies for all tables
+- Use parameterized queries to prevent SQL injection
+- Document all database objects and policies
+- Create modular SQL migration files. Don't use apply_migration. Use execute_sql where possible.
 
 # Supabase MCP
 
@@ -110,12 +110,6 @@ The Supabase MCP (Management Control Panel) provides a set of tools for managing
    - Implement proper RLS policies for all tables
    - Test security policies thoroughly
 
-### Current Project
-
-```json
-{"id":"hgbfbvtujatvwpjgibng","organization_id":"wvkxkdydapcjjdbsqkiu","name":"permit-place-dashboard-v2","region":"us-west-1","created_at":"2025-04-22T17:22:14.786709Z","status":"ACTIVE_HEALTHY"}
-```
-
 ## Available Commands
 
 ### Project Management
@@ -283,66 +277,25 @@ Rebases a development branch on production. This will effectively run any newer
 - **edit**: File modification and creation
 - **mcp**: Model Context Protocol tools
 
-## Usage
-
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "supabase-admin",
-  task_description: "create user authentication schema",
-  options: {
-    namespace: "supabase-admin",
-    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 supabase-admin "create user authentication schema"
-
-# For alpha features
-npx monomind@alpha sparc run supabase-admin "create user authentication schema"
+## How to Invoke
 
-# With namespace
-npx monomind sparc run supabase-admin "your task" --namespace supabase-admin
-
-# Non-interactive mode
-npx monomind sparc run supabase-admin "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 supabase-admin "create user authentication schema"
+Skill("sparc:supabase-admin")
 ```
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
 ```javascript
-// Store mode-specific context
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "supabase-admin_context",
-  value: "important decisions",
-  namespace: "supabase-admin"
-}
-
-// Query previous work
-mcp__monomind__memory_search {
-  pattern: "supabase-admin",
-  namespace: "supabase-admin",
-  limit: 5
-}
+// Store context
+mcp__monomind__memory_store({ key: "supabase_context", value: "important decisions", namespace: "supabase" })
+
+// Search previous work
+mcp__monomind__memory_search({ query: "supabase", namespace: "supabase", limit: 5 })
 ```
 
-### Using NPX CLI (Fallback)
 ```bash
-# Store mode-specific context
-npx monomind memory store "supabase-admin_context" "important decisions" --namespace supabase-admin
-
-# Query previous work
-npx monomind memory query "supabase-admin" --limit 5
+# CLI equivalents
+npx monomind memory store "supabase_context" "important decisions" --namespace supabase
+npx monomind memory search --query "supabase" --namespace supabase
 ```

package/.claude/commands/sparc/swarm-coordinator.md

@@ -1,35 +1,18 @@
+---
+name: sparc:swarm-coordinator
+description: Swarm Coordinator - Specialized swarm management with batch coordination capabilities. Hierarchical/mesh topologies, agent management, and fault recovery.
+---
+
 # SPARC Swarm Coordinator Mode
 
 ## Purpose
 Specialized swarm management with batch coordination capabilities.
 
-## Activation
-
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "swarm-coordinator",
-  task_description: "manage development swarm",
-  options: {
-    topology: "hierarchical",
-    max_agents: 10
-  }
-}
-```
-
-### Option 2: Using NPX CLI (Fallback when MCP not available)
-```bash
-# Use when running from terminal or MCP tools unavailable
-npx monomind sparc run swarm-coordinator "manage development swarm"
+## How to Invoke
 
-# For alpha features
-npx monomind@alpha sparc run swarm-coordinator "manage development swarm"
+In Claude Code, load this mode as a skill:
 ```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run swarm-coordinator "manage development swarm"
+Skill("sparc:swarm-coordinator")
 ```
 
 ## Core Capabilities
@@ -52,3 +35,16 @@ npx monomind@alpha sparc run swarm-coordinator "manage development swarm"
 - Failure recovery
 - Performance monitoring
 - Quality assurance
+
+## Real MCP Tools
+
+```javascript
+// Initialize a swarm
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+
+// Check swarm status
+mcp__monomind__swarm_status({ swarmId: "current" })
+
+// Coordinate tasks
+mcp__monomind__coordination_orchestrate({ task: "...", strategy: "parallel" })
+```

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

@@ -1,35 +1,18 @@
+---
+name: sparc:tdd
+description: TDD - Test-driven development with TodoWrite planning and comprehensive testing. Red-green-refactor cycle with coverage optimization.
+---
+
 # SPARC TDD Mode
 
 ## Purpose
 Test-driven development with TodoWrite planning and comprehensive testing.
 
-## Activation
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "tdd",
-  task_description: "shopping cart feature",
-  options: {
-    coverage_target: 90,
-    test_framework: "jest"
-  }
-}
+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 tdd "shopping cart feature"
-
-# For alpha features
-npx monomind@alpha sparc run tdd "shopping cart feature"
-```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run tdd "shopping cart feature"
+Skill("sparc:tdd")
 ```
 
 ## Core Capabilities

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

@@ -1,35 +1,18 @@
+---
+name: sparc:tester
+description: Tester - Comprehensive testing with parallel execution capabilities. Unit, integration, E2E, performance, and security testing across environments.
+---
+
 # SPARC Tester Mode
 
 ## Purpose
 Comprehensive testing with parallel execution capabilities.
 
-## Activation
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "tester",
-  task_description: "full regression suite",
-  options: {
-    parallel: true,
-    coverage: 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 tester "full regression suite"
-
-# For alpha features
-npx monomind@alpha sparc run tester "full regression suite"
-```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run tester "full regression suite"
+Skill("sparc:tester")
 ```
 
 ## Core Capabilities

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

@@ -1,9 +1,9 @@
 ---
-name: sparc-tutorial
-description: 📘 SPARC Tutorial - You are the SPARC onboarding and education assistant. Your job is to guide users through the full...
+name: sparc:tutorial
+description: SPARC Tutorial - You are the SPARC onboarding and education assistant. Your job is to guide users through the full SPARC development process using structured thinking models.
 ---
 
-# 📘 SPARC Tutorial
+# SPARC Tutorial
 
 ## Role Definition
 You are the SPARC onboarding and education assistant. Your job is to guide users through the full SPARC development process using structured thinking models. You help users understand how to navigate complex projects using the specialized SPARC modes and properly formulate tasks using new_task.
@@ -14,66 +14,25 @@ You teach developers how to apply the SPARC methodology through actionable examp
 ## Available Tools
 - **read**: File reading and viewing
 
-## Usage
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "tutorial",
-  task_description: "guide me through SPARC methodology",
-  options: {
-    namespace: "tutorial",
-    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 tutorial "guide me through SPARC methodology"
-
-# For alpha features
-npx monomind@alpha sparc run tutorial "guide me through SPARC methodology"
-
-# With namespace
-npx monomind sparc run tutorial "your task" --namespace tutorial
-
-# Non-interactive mode
-npx monomind sparc run tutorial "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 tutorial "guide me through SPARC methodology"
+Skill("sparc:tutorial")
 ```
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
 ```javascript
-// Store mode-specific context
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "tutorial_context",
-  value: "important decisions",
-  namespace: "tutorial"
-}
+// Store context
+mcp__monomind__memory_store({ key: "tutorial_context", value: "important decisions", namespace: "tutorial" })
 
-// Query previous work
-mcp__monomind__memory_search {
-  pattern: "tutorial",
-  namespace: "tutorial",
-  limit: 5
-}
+// Search previous work
+mcp__monomind__memory_search({ query: "tutorial", namespace: "tutorial", limit: 5 })
 ```
 
-### Using NPX CLI (Fallback)
 ```bash
-# Store mode-specific context
+# CLI equivalents
 npx monomind memory store "tutorial_context" "important decisions" --namespace tutorial
-
-# Query previous work
-npx monomind memory query "tutorial" --limit 5
+npx monomind memory search --query "tutorial" --namespace tutorial
 ```

package/.claude/commands/sparc/workflow-manager.md

@@ -1,35 +1,18 @@
+---
+name: sparc:workflow-manager
+description: Workflow Manager - Process automation with TodoWrite planning and Task execution. Pipeline creation, event handling, and state management.
+---
+
 # SPARC Workflow Manager Mode
 
 ## Purpose
 Process automation with TodoWrite planning and Task execution.
 
-## Activation
+## How to Invoke
 
-### Option 1: Using MCP Tools (Preferred in Claude Code)
-```javascript
-mcp__monomind__sparc_mode {
-  mode: "workflow-manager",
-  task_description: "automate deployment",
-  options: {
-    pipeline: "ci-cd",
-    rollback_enabled: 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 workflow-manager "automate deployment"
-
-# For alpha features
-npx monomind@alpha sparc run workflow-manager "automate deployment"
-```
-
-### Option 3: Local Installation
-```bash
-# If monomind is installed locally
-./monomind sparc run workflow-manager "automate deployment"
+Skill("sparc:workflow-manager")
 ```
 
 ## Core Capabilities

package/.claude/commands/sparc.md

@@ -1,166 +1,112 @@
 ---
 name: sparc
-description: Execute SPARC methodology workflows with Monomind
+description: Execute SPARC methodology workflows — orchestrates Specification, Pseudocode, Architecture, Refinement, and Completion phases via specialist sub-skills
 ---
 
-# ⚡️ SPARC Development Methodology
+# 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.
+You are SPARC, the orchestrator of complex workflows. Break down large objectives into delegated subtasks aligned to the SPARC methodology. Ensure secure, modular, testable, and maintainable delivery using the appropriate specialist modes.
 
-## SPARC Workflow
+## SPARC Phases
 
-Follow SPARC:
+1. **Specification** — Clarify objectives and scope. Never allow hard-coded env vars.
+2. **Pseudocode** — High-level logic with TDD anchors.
+3. **Architecture** — Extensible system diagrams and service boundaries.
+4. **Refinement** — TDD, debugging, security, and optimization flows.
+5. **Completion** — Integrate, document, and monitor for continuous improvement.
 
-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.
+## Invoking SPARC Sub-Skills
 
-Use `new_task` to assign:
-- spec-pseudocode
+Use the `Skill` tool to activate specialist modes:
 
-## 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"
+// Full SPARC orchestration
+Skill("sparc:sparc")
+
+// Specific phases
+Skill("sparc:architect")      // Architecture and system design
+Skill("sparc:code")           // Auto-Coder implementation
+Skill("sparc:tdd")            // TDD — test-first development
+Skill("sparc:debug")          // Systematic debugging
+Skill("sparc:security-review") // Security review
+Skill("sparc:docs-writer")    // Documentation
+Skill("sparc:integration")    // System integration
+Skill("sparc:optimizer")      // Performance optimization
+Skill("sparc:devops")         // DevOps and deployment
+Skill("sparc:researcher")     // Research and analysis
 ```
 
-## SPARC Methodology Phases
+## Available SPARC Modes
 
-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
+| Skill | Purpose |
+|---|---|
+| `sparc:sparc` | Full SPARC orchestrator |
+| `sparc:architect` | System architecture and design |
+| `sparc:code` | Code implementation |
+| `sparc:tdd` | Test-driven development |
+| `sparc:debug` | Systematic debugging |
+| `sparc:security-review` | Security audit and hardening |
+| `sparc:docs-writer` | Documentation generation |
+| `sparc:integration` | System integration |
+| `sparc:post-deployment-monitoring-mode` | Production monitoring |
+| `sparc:refinement-optimization-mode` | Performance optimization |
+| `sparc:ask` | SPARC Q&A assistant |
+| `sparc:devops` | Infrastructure and deployment |
+| `sparc:tutorial` | SPARC tutorial |
+| `sparc:supabase-admin` | Supabase administration |
+| `sparc:spec-pseudocode` | Requirements and pseudocode |
+| `sparc:mcp` | MCP integration |
 
 ## Memory Integration
 
-### Using MCP Tools (Preferred)
+Store SPARC context across phases using real MCP tools:
+
 ```javascript
-// Store specifications
-mcp__monomind__memory_usage {
-  action: "store",
-  key: "spec_auth",
-  value: "OAuth2 + JWT requirements",
-  namespace: "spec"
-}
+// Store specification decisions
+mcp__monomind__memory_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"
-}
-```
+mcp__monomind__memory_store({ key: "arch/api", value: "Microservices with API Gateway", namespace: "arch" })
 
-### 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
+// Search past decisions
+mcp__monomind__memory_search({ query: "authentication", namespace: "spec" })
+```
 
-# Query previous work
-./monomind memory query "authentication" --limit 10
+Or via CLI:
 
-# Export project memory
-./monomind memory export sparc-project-backup.json
+```bash
+npx monomind memory store --key "spec/auth" --value "OAuth2 + JWT" --namespace spec
+npx monomind memory search --query "authentication" --namespace spec
 ```
 
-## Advanced Swarm Mode
+## Swarm Mode for Complex SPARC Tasks
 
-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
+For tasks requiring multiple parallel agents:
 
-# Background optimization swarm
-./monomind swarm "Optimize system performance" --strategy optimization --background
+```bash
+# Initialize anti-drift swarm
+npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
 
-# Distributed research swarm
-./monomind swarm "Analyze market trends" --strategy research --distributed --ui
+# Start with objective
+npx monomind swarm start -o "Build authentication system" -s development
 ```
 
-## Non-Interactive Mode
+Then spawn agents via Claude Code's Task tool (all in one message):
 
-For CI/CD integration and automation:
-```bash
-./monomind sparc run code "implement API" --non-interactive
-./monomind sparc tdd "user tests" --non-interactive --enable-permissions
+```javascript
+Task({ subagent_type: "coordinator", description: "Orchestrate SPARC phases", run_in_background: true })
+Task({ subagent_type: "system-architect", description: "Design architecture", run_in_background: true })
+Task({ subagent_type: "coder", description: "Implement spec", run_in_background: true })
+Task({ subagent_type: "tester", description: "Write TDD tests", run_in_background: true })
+Task({ subagent_type: "reviewer", description: "Security and code review", run_in_background: true })
 ```
 
 ## 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`
+- Keep files under 500 lines
+- Never hardcode secrets or env values
+- Always write tests before implementation (TDD)
+- Store important decisions in memory across phases
+- All tasks should end with verification against acceptance criteria
 
-See `/monomind-help` for all available commands.
+See `/monomind:help` for all available commands.