monomind 1.16.5 → 1.16.7

package/packages/@monomind/cli/.claude/commands/stream-chain/pipeline.md

@@ -0,0 +1,116 @@
+---
+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/packages/@monomind/cli/.claude/commands/stream-chain/run.md

@@ -0,0 +1,156 @@
+---
+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/packages/@monomind/cli/.claude/commands/swarm/README.md

@@ -0,0 +1,40 @@
+---
+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/packages/@monomind/cli/.claude/commands/swarm/analysis.md

@@ -0,0 +1,73 @@
+---
+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/packages/@monomind/cli/.claude/commands/swarm/development.md

@@ -0,0 +1,72 @@
+---
+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
+```

package/packages/@monomind/cli/.claude/commands/swarm/examples.md

@@ -0,0 +1,103 @@
+---
+name: swarm-examples
+description: Swarm pattern examples — concrete recipes for research, development, analysis, and testing swarms with real MCP tool invocations
+---
+
+# Common Swarm Patterns
+
+Ready-to-use recipes for the most common swarm scenarios.
+
+## Research Swarm
+
+```javascript
+// 1. Initialize
+mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 6, strategy: "adaptive" })
+
+// 2. Spawn agents
+mcp__monomind__agent_spawn({ type: "researcher", capabilities: ["web-search", "analysis", "synthesis"] })
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["data-processing", "reporting"] })
+
+// 3. Coordinate
+mcp__monomind__coordination_orchestrate({ task: "research AI trends", strategy: "parallel" })
+
+// 4. Monitor
+mcp__monomind__swarm_status({ swarmId: "current" })
+```
+
+```bash
+npx monomind swarm init --topology mesh --max-agents 6 --strategy research
+npx monomind swarm start "research AI trends" --strategy research --parallel
+```
+
+---
+
+## Development Swarm
+
+```javascript
+// 1. Initialize
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 8, strategy: "specialized" })
+
+// 2. Spawn team
+mcp__monomind__agent_spawn({ type: "architect", capabilities: ["system-design", "api-design"] })
+mcp__monomind__agent_spawn({ type: "coder", capabilities: ["typescript", "api", "backend"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["integration", "e2e"] })
+mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["api-docs", "readme"] })
+
+// 3. Coordinate
+mcp__monomind__coordination_orchestrate({ task: "build REST API", strategy: "sequential" })
+
+// 4. Monitor
+mcp__monomind__swarm_status({ swarmId: "current" })
+```
+
+```bash
+npx monomind swarm start "build REST API" --strategy development --mode hierarchical
+```
+
+---
+
+## Analysis Swarm
+
+```javascript
+// 1. Initialize
+mcp__monomind__swarm_init({ topology: "mesh", maxAgents: 5, strategy: "adaptive" })
+
+// 2. Spawn agents
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["static-analysis", "complexity-analysis"] })
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["security-scan", "vulnerability-detection"] })
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["performance-analysis", "bottleneck-detection"] })
+
+// 3. Coordinate
+mcp__monomind__coordination_orchestrate({ task: "analyze codebase", strategy: "parallel" })
+
+// 4. Report
+mcp__monomind__performance_report({ format: "detailed" })
+```
+
+```bash
+npx monomind swarm start "analyze codebase" --strategy analysis --mode mesh --parallel
+```
+
+---
+
+## Error Recovery
+
+When a swarm gets into a bad state:
+
+```javascript
+// Check status first
+mcp__monomind__swarm_status({ swarmId: "current" })
+
+// System health check
+mcp__monomind__system_health({})
+
+// Shut down and restart
+mcp__monomind__swarm_shutdown({ swarmId: "current" })
+mcp__monomind__swarm_init({ topology: "hierarchical", maxAgents: 6, strategy: "specialized" })
+```
+
+## See Also
+
+- `swarm:swarm` — Main skill with strategy selection guide
+- `swarm:swarm-modes` — Topology reference
+- `swarm:swarm-strategies` — When to use each strategy

package/packages/@monomind/cli/.claude/commands/swarm/maintenance.md

@@ -0,0 +1,75 @@
+---
+name: swarm-maintenance
+description: Maintenance swarm strategy — sequential coordinated system maintenance for dependency updates, security audits, and documentation
+---
+
+# Maintenance Swarm Strategy
+
+System maintenance and updates through coordinated agents.
+
+## How to Invoke
+
+```
+Skill("swarm:maintenance")
+```
+
+Then describe the maintenance task:
+> "Run a maintenance swarm to update all dependencies safely."
+> "Start a maintenance swarm for the monthly security audit."
+
+---
+
+## Swarm Setup
+
+```javascript
+// Initialize maintenance swarm
+mcp__monomind__swarm_init({
+  topology: "star",
+  maxAgents: 5,
+  strategy: "sequential"
+})
+
+// Coordinate maintenance
+mcp__monomind__coordination_orchestrate({
+  task: "update dependencies",
+  strategy: "sequential"
+})
+```
+
+```bash
+# CLI equivalent
+npx monomind swarm init --topology star --max-agents 5
+npx monomind swarm start "update dependencies" --strategy maintenance
+```
+
+## Agent Roles
+
+```javascript
+mcp__monomind__agent_spawn({ type: "analyst", capabilities: ["dependency-analysis", "version-management"] })
+mcp__monomind__agent_spawn({ type: "tester", capabilities: ["testing", "validation"] })
+mcp__monomind__agent_spawn({ type: "documenter", capabilities: ["documentation", "changelog"] })
+```
+
+## Maintenance Sequence
+
+Star topology runs sequentially — each agent completes before the next starts:
+
+1. **Analyzer agent** — audit outdated dependencies, find vulnerabilities
+2. **Tester agent** — verify tests pass on current state (baseline)
+3. **Analyst agent** — apply updates, verify no regressions
+4. **Tester agent** — rerun tests to confirm updates are safe
+5. **Documenter agent** — update CHANGELOG, document what changed
+
+## Security Scanning
+
+```javascript
+// Run security scan via AI defence
+mcp__monomind__aidefence_scan({ target: "./" })
+```
+
+## Monitoring
+
+```javascript
+mcp__monomind__swarm_status({ swarmId: "current" })
+mcp__monomind__system_health({})
+```