monomind 1.19.0 → 2.0.1

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

@@ -1,37 +0,0 @@
----
-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.
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:tester")
-```
-
-## Core Capabilities
-- Test planning
-- Test execution
-- Bug detection
-- Coverage analysis
-- Report generation
-
-## Test Types
-- Unit tests
-- Integration tests
-- E2E tests
-- Performance tests
-- Security tests
-
-## Parallel Features
-- Concurrent test runs
-- Distributed testing
-- Load testing
-- Cross-browser testing
-- Multi-environment validation

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

@@ -1,38 +0,0 @@
----
-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
-
-## 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.
-
-## Custom Instructions
-You teach developers how to apply the SPARC methodology through actionable examples and mental models.
-
-## Available Tools
-- **read**: File reading and viewing
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:tutorial")
-```
-
-## Memory Integration
-
-```javascript
-// Store context
-mcp__monomind__memory_store({ key: "tutorial_context", value: "important decisions", namespace: "tutorial" })
-
-// Search previous work
-mcp__monomind__memory_search({ query: "tutorial", namespace: "tutorial", limit: 5 })
-```
-
-```bash
-# CLI equivalents
-npx monomind memory store "tutorial_context" "important decisions" --namespace tutorial
-npx monomind memory search --query "tutorial" --namespace tutorial
-```

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

@@ -1,37 +0,0 @@
----
-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.
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:workflow-manager")
-```
-
-## Core Capabilities
-- Workflow design
-- Process automation
-- Pipeline creation
-- Event handling
-- State management
-
-## Workflow Patterns
-- Sequential flows
-- Parallel branches
-- Conditional logic
-- Loop iterations
-- Error handling
-
-## Automation Features
-- Trigger management
-- Task scheduling
-- Progress tracking
-- Result validation
-- Rollback capability

package/.claude/commands/sparc.md

@@ -1,112 +0,0 @@
----
-name: sparc
-description: Execute SPARC methodology workflows — orchestrates Specification, Pseudocode, Architecture, Refinement, and Completion phases via specialist sub-skills
----
-
-# SPARC Development Methodology
-
-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 Phases
-
-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.
-
-## Invoking SPARC Sub-Skills
-
-Use the `Skill` tool to activate specialist modes:
-
-```javascript
-// 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
-```
-
-## Available SPARC Modes
-
-| 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
-
-Store SPARC context across phases using real MCP tools:
-
-```javascript
-// Store specification decisions
-mcp__monomind__memory_store({ key: "spec/auth", value: "OAuth2 + JWT requirements", namespace: "spec" })
-
-// Store architectural decisions
-mcp__monomind__memory_store({ key: "arch/api", value: "Microservices with API Gateway", namespace: "arch" })
-
-// Search past decisions
-mcp__monomind__memory_search({ query: "authentication", namespace: "spec" })
-```
-
-Or via CLI:
-
-```bash
-npx monomind memory store --key "spec/auth" --value "OAuth2 + JWT" --namespace spec
-npx monomind memory search --query "authentication" --namespace spec
-```
-
-## Swarm Mode for Complex SPARC Tasks
-
-For tasks requiring multiple parallel agents:
-
-```bash
-# Initialize anti-drift swarm
-npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
-
-# Start with objective
-npx monomind swarm start -o "Build authentication system" -s development
-```
-
-Then spawn agents via Claude Code's Task tool (all in one message):
-
-```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
-
-- 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 `/mastermind:help` for all available commands.

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

@@ -1,116 +0,0 @@
----
-name: stream-chain:pipeline
-description: Execute predefined stream-chain pipelines for common development workflows — analysis, refactor, test, optimize. Each step feeds full context into the next.
----
-
-# Stream-Chain Pipeline Mode
-
-Execute predefined multi-step workflows where each step's output flows into the next as context.
-
-## How to Invoke
-
-In Claude Code, activate pipeline mode:
-```
-Skill("stream-chain:pipeline")
-```
-
-Then tell Claude which pipeline to run and on what target:
-> "Run the analysis pipeline on the `src/auth/` directory."
-> "Run the refactor pipeline on `UserService.ts`."
-
----
-
-## Available Pipelines
-
-### analysis
-
-Comprehensive codebase analysis and improvement identification.
-
-**Steps:**
-1. Map directory structure and identify main components
-2. Identify potential improvements and issues
-3. Generate actionable improvement report with priorities
-
-**When to use:** New codebase onboarding, technical debt assessment, architecture review, code quality audits.
-
----
-
-### refactor
-
-Systematic code refactoring with prioritization.
-
-**Steps:**
-1. Find code that would benefit from refactoring
-2. Create prioritized refactoring plan with specific changes
-3. Provide refactored code for top 3 priorities
-
-**When to use:** Technical debt reduction, code quality improvement, design pattern implementation.
-
----
-
-### test
-
-Comprehensive test generation with coverage analysis.
-
-**Steps:**
-1. Identify areas lacking test coverage
-2. Design test cases for critical functions
-3. Generate unit test implementations with assertions
-
-**When to use:** Increasing test coverage, TDD workflow support, regression test creation.
-
----
-
-### optimize
-
-Performance optimization with profiling and implementation.
-
-**Steps:**
-1. Profile codebase and identify performance bottlenecks
-2. Analyze bottlenecks and suggest optimization strategies
-3. Provide optimized implementations for main issues
-
-**When to use:** Performance improvement, resource optimization, latency reduction.
-
----
-
-## Running Pipelines
-
-After invoking the skill, direct Claude conversationally:
-
-> "Run the test pipeline on all files in `src/services/`."
-> "Run the optimization pipeline, focus on database query patterns."
-> "Run the analysis pipeline, then the refactor pipeline on the findings."
-
-## Chaining Pipelines
-
-Run multiple pipelines sequentially for a full QA cycle:
-```
-analysis → refactor → test → optimize
-```
-
-> "Run a full QA chain: analysis, then refactor, then test on the resulting changes."
-
-## Custom Pipelines
-
-For repeatable custom pipelines, define the steps explicitly:
-
-> "Run a custom pipeline on the payment module:
-> 1. Scan for security vulnerabilities
-> 2. Categorize issues by severity
-> 3. Generate fixes with priority
-> 4. Create security test cases"
-
-Or use the `stream-chain:run` mode for ad-hoc custom chains.
-
-## Pipeline Output
-
-Each pipeline step delivers:
-- Step-by-step progress and results
-- Success/failure status per step
-- Consolidated summary of findings
-- Actionable recommendations
-
-## See Also
-- `stream-chain:run` — custom prompt chains with full control
-- `stream-chain` — full stream-chain skill with advanced patterns

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

@@ -1,156 +0,0 @@
----
-name: stream-chain:run
-description: Execute custom stream chains where you define the prompt sequence. Each step receives the full output of the previous step as context.
----
-
-# Stream-Chain Run Mode
-
-Execute custom multi-step workflows with your own prompt sequence. Each step's full output becomes context for the next.
-
-## How to Invoke
-
-In Claude Code, activate run mode:
-```
-Skill("stream-chain:run")
-```
-
-Then provide your chain directly:
-> "Run a stream chain:
-> 1. Write a sorting function
-> 2. Add tests for it
-> 3. Optimize it for performance"
-
----
-
-## How Context Flows
-
-Each step receives the complete output of all previous steps:
-
-```
-Step 1: "Write a sorting function"
-Output: [function code]
-
-Step 2 receives:
-  Previous output: [function code]
-  Task: "Add comprehensive tests"
-
-Step 3 receives:
-  Previous output: [function + tests]
-  Task: "Optimize for performance"
-```
-
----
-
-## Examples
-
-### Basic Development Chain
-
-> "Stream chain:
-> 1. Write a user authentication function
-> 2. Add input validation and error handling
-> 3. Create unit tests with edge cases"
-
-### Security Audit Workflow
-
-> "Stream chain for the `src/auth/` module:
-> 1. Analyze for security vulnerabilities
-> 2. Categorize issues by severity (critical/high/medium/low)
-> 3. Propose fixes with implementation priority
-> 4. Generate security test cases"
-
-### Code Refactoring Chain
-
-> "Stream chain:
-> 1. Identify code smells in `src/` directory
-> 2. Create refactoring plan with specific changes
-> 3. Apply refactoring to top 3 priority items
-> 4. Verify refactored code maintains original behavior"
-
-### Data Processing Pipeline
-
-> "Stream chain:
-> 1. Extract data from API responses in `handlers/`
-> 2. Transform data into normalized format
-> 3. Validate data against schema
-> 4. Generate data quality report"
-
-### Code Migration Workflow
-
-> "Stream chain for migrating Vue 2 to Vue 3:
-> 1. Analyze codebase dependencies and breaking changes
-> 2. Create migration plan with risk assessment
-> 3. Generate modernized code for high-priority components
-> 4. Create migration tests
-> 5. Document migration steps and rollback procedures"
-
----
-
-## Best Practices
-
-### 1. Clear, Specific Prompts
-
-Good:
-> "Analyze `auth.ts` for SQL injection vulnerabilities"
-
-Avoid:
-> "Check security"
-
-### 2. Logical Progression
-
-Build on previous outputs:
-1. Identify the problem
-2. Analyze root causes
-3. Design solution
-4. Implement solution
-5. Verify implementation
-
-### 3. Include Verification Steps
-
-> "Stream chain:
-> 1. Implement feature X
-> 2. Write tests for feature X
-> 3. Verify tests pass and cover edge cases"
-
-### 4. Iterative Refinement
-
-> "Stream chain:
-> 1. Generate initial implementation
-> 2. Review and identify issues
-> 3. Refine based on issues found
-> 4. Final quality check"
-
----
-
-## Multi-Agent Integration
-
-For complex chains, combine with swarm coordination:
-
-```javascript
-// Initialize swarm first
-mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 4, strategy: "specialized" })
-```
-
-Then direct the stream chain:
-> "With our 4-agent swarm, run a stream chain:
-> 1. Research: best practices for API design
-> 2. Design: REST API with discovered patterns
-> 3. Implement: API endpoints with validation
-> 4. Review: final quality check and documentation"
-
-## Memory Integration
-
-Use memory tools to persist chain results for future sessions:
-
-```javascript
-mcp__monomind__memory_store({
-  key: "stream-chain-result",
-  value: "summary of findings",
-  namespace: "stream-chain"
-})
-```
-
----
-
-## See Also
-- `stream-chain:pipeline` — predefined pipelines for common workflows
-- `stream-chain` — full stream-chain skill with advanced patterns

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

@@ -1,40 +0,0 @@
----
-name: swarm-README
-description: Swarm skill index — lists all available swarm coordination skills and strategies for multi-agent task execution
----
-
-# Swarm Skills
-
-Multi-agent swarm coordination for Monomind.
-
-## Core Skills
-
-- [swarm](./swarm.md) — Main swarm skill: how to start and coordinate swarms
-
-## Strategy Skills
-
-- [analysis](./analysis.md) — Distributed analysis via coordinated agents
-- [development](./development.md) — Coordinated development teams
-- [research](./research.md) — Parallel information gathering
-- [testing](./testing.md) — Distributed test execution
-- [maintenance](./maintenance.md) — System maintenance coordination
-- [optimization](./optimization.md) — Performance optimization swarms
-- [examples](./examples.md) — Common swarm patterns and recipes
-
-## Reference Skills
-
-- [swarm-status](./swarm-status.md) — Check swarm health and agent progress
-- [swarm-monitor](./swarm-monitor.md) — Monitor running swarms
-- [swarm-modes](./swarm-modes.md) — Topology modes: hierarchical, mesh, star
-- [swarm-strategies](./swarm-strategies.md) — Strategy selection guide
-- [swarm-background](./swarm-background.md) — Running swarms in the background
-- [swarm-analysis](./swarm-analysis.md) — Swarm performance analysis
-
-## Quick Start
-
-```bash
-# Initialize and start a swarm via CLI
-npx monomind swarm init --topology hierarchical --max-agents 8
-npx monomind swarm start "Build REST API" --strategy development
-npx monomind swarm status
-```

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

@@ -1,73 +0,0 @@
----
-name: swarm-analysis
-description: Analysis swarm strategy — distributed codebase, performance, and security analysis through coordinated mesh agents
----
-
-# Analysis Swarm Strategy
-
-Comprehensive analysis through distributed agent coordination.
-
-## How to Invoke
-
-```
-Skill("swarm:analysis")
-```
-
-Then describe what to analyze:
-> "Run an analysis swarm on the src/ directory."
-> "Analyze API performance bottlenecks across all services."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize analysis swarm
-mcp__monomind__swarm_init({
-  topology: "mesh",
-  maxAgents: 6,
-  strategy: "adaptive"
-})
-
-// Coordinate analysis
-mcp__monomind__coordination_orchestrate({
-  task: "analyze system performance",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology mesh --max-agents 6
-npx monomind swarm start "analyze system performance" --strategy analysis --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["metrics", "logging", "monitoring"] })
-mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["pattern-recognition", "anomaly-detection"] })
-mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["reporting", "visualization"] })
-mcp__monomind__agent_spawn({ type: "coordinator", capabilities: ["synthesis", "correlation"] })
-```
-
-## Coordination Modes
-
-| Mode | When to use |
-|------|-------------|
-| Mesh | Exploratory analysis — agents search in parallel |
-| Hierarchical | Complex systems — coordinator aggregates sub-agent findings |
-| Star | Sequential pipeline — each step depends on previous |
-
-## Monitoring
-
-```javascript
-// Check analysis progress
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// Performance metrics
-mcp__monomind__performance_report({ format: "detailed" })
-
-// System health
-mcp__monomind__system_health({})
-```

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

@@ -1,72 +0,0 @@
----
-name: swarm-development
-description: Development swarm strategy — hierarchical team coordination for building features with architect → coder → tester flow
----
-
-# Development Swarm Strategy
-
-Coordinated development through specialized agent teams.
-
-## How to Invoke
-
-```
-Skill("swarm:development")
-```
-
-Then describe the feature to build:
-> "Start a development swarm to build OAuth2 authentication."
-> "Coordinate agents to implement the payment processing module."
-
----
-
-## Swarm Setup
-
-```javascript
-// Initialize development swarm
-mcp__monomind__swarm_init({
-  topology: "hierarchical",
-  maxAgents: 8,
-  strategy: "specialized"
-})
-
-// Coordinate development
-mcp__monomind__coordination_orchestrate({
-  task: "build feature X",
-  strategy: "parallel"
-})
-```
-
-```bash
-# CLI equivalent
-npx monomind swarm init --topology hierarchical --max-agents 8 --strategy specialized
-npx monomind swarm start "build feature X" --strategy development --parallel
-```
-
-## Agent Roles
-
-```javascript
-mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["react", "typescript", "ui"] })
-mcp__monomind__agent_spawn({ type: "coder", capabilities: ["nodejs", "api", "database"] })
-mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e", "api-testing"] })
-```
-
-## Best Practices
-
-- Use hierarchical topology for large features (architect leads, coders implement, tester validates)
-- Enable parallel execution for independent modules
-- Run tester agent concurrently on completed units rather than waiting for all code
-
-## Monitoring
-
-```javascript
-// Check swarm status
-mcp__monomind__swarm_status({ swarmId: "current" })
-
-// System health
-mcp__monomind__system_health({})
-```
-
-```bash
-npx monomind swarm status
-```