@monoes/monomindcli 1.8.0 → 1.9.1

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

@@ -1,121 +1,116 @@
-# stream-chain pipeline
+---
+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.
+---
 
-Execute predefined pipelines for common development workflows.
+# Stream-Chain Pipeline Mode
 
-## Usage
+Execute predefined multi-step workflows where each step's output flows into the next as context.
 
-```bash
-monomind stream-chain pipeline <type> [options]
+## 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
-Code analysis and improvement pipeline.
 
-```bash
-monomind stream-chain pipeline analysis
-```
+Comprehensive codebase analysis and improvement identification.
 
 **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
+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
-Automated refactoring workflow.
 
-```bash
-monomind stream-chain pipeline refactor
-```
+Systematic code refactoring with prioritization.
 
 **Steps:**
-1. Identify code that could benefit from refactoring
+1. Find code that would benefit from refactoring
 2. Create prioritized refactoring plan with specific changes
-3. Provide refactored code examples for top 3 priorities
+3. Provide refactored code for top 3 priorities
+
+**When to use:** Technical debt reduction, code quality improvement, design pattern implementation.
+
+---
 
 ### test
-Comprehensive test generation.
 
-```bash
-monomind stream-chain pipeline test
-```
+Comprehensive test generation with coverage analysis.
 
 **Steps:**
-1. Analyze codebase and identify areas lacking test coverage
-2. Design comprehensive test cases for critical functions
+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 pipeline.
 
-```bash
-monomind stream-chain pipeline 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
 
-## Options
+**When to use:** Performance improvement, resource optimization, latency reduction.
 
-- `--verbose` - Show detailed execution
-- `--timeout <seconds>` - Timeout per step (default: 30)
-- `--debug` - Enable debug mode
+---
 
-## Examples
+## Running Pipelines
 
-### Run Analysis Pipeline
-```bash
-monomind stream-chain pipeline analysis
-```
+After invoking the skill, direct Claude conversationally:
 
-### Refactor with Extended Timeout
-```bash
-monomind stream-chain pipeline refactor --timeout 60
-```
+> "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."
 
-### Verbose Test Generation
-```bash
-monomind stream-chain pipeline test --verbose
-```
+## Chaining Pipelines
 
-### Performance Optimization
-```bash
-monomind stream-chain pipeline optimize --debug
+Run multiple pipelines sequentially for a full QA cycle:
+```
+analysis → refactor → test → optimize
 ```
 
-## Output
-
-Each pipeline generates:
-- Step-by-step execution progress
-- Success/failure status per step
-- Total execution time
-- Summary of results
+> "Run a full QA chain: analysis, then refactor, then test on the resulting changes."
 
 ## 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"
-        ]
-      }
-    }
-  }
-}
-```
+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
 
-Then run:
-```bash
-monomind stream-chain pipeline security
-```
+## 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,70 +1,156 @@
-# stream-chain run
+---
+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.
+---
 
-Execute a custom stream chain with your own prompts.
+# Stream-Chain Run Mode
 
-## Usage
+Execute custom multi-step workflows with your own prompt sequence. Each step's full output becomes context for the next.
 
-```bash
-monomind stream-chain run <prompt1> <prompt2> [...] [options]
+## How to Invoke
+
+In Claude Code, activate run mode:
+```
+Skill("stream-chain:run")
 ```
 
-Minimum 2 prompts required for chaining.
+Then provide your chain directly:
+> "Run a stream chain:
+> 1. Write a sorting function
+> 2. Add tests for it
+> 3. Optimize it for performance"
 
-## Options
+---
 
-- `--verbose` - Show detailed execution information
-- `--timeout <seconds>` - Timeout per step (default: 30)
-- `--debug` - Enable debug mode
+## How Context Flows
 
-## How It Works
+Each step receives the complete output of all previous steps:
 
-Each prompt in the chain receives the complete output from the previous step as context, enabling complex multi-step workflows.
+```
+Step 1: "Write a sorting function"
+Output: [function code]
 
-## Examples
+Step 2 receives:
+  Previous output: [function code]
+  Task: "Add comprehensive tests"
 
-### Basic Chain
-```bash
-monomind stream-chain run \
-  "Write a function" \
-  "Add tests for it"
+Step 3 receives:
+  Previous output: [function + tests]
+  Task: "Optimize for performance"
 ```
 
-### 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
-```
+## Examples
+
+### Basic Development Chain
 
-## Context Preservation
+> "Stream chain:
+> 1. Write a user authentication function
+> 2. Add input validation and error handling
+> 3. Create unit tests with edge cases"
 
-The output from each step is injected into the next prompt:
+### 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" })
 ```
-Step 1: "Write a sorting function"
-Output: [function code]
 
-Step 2 receives: "Previous step output:
-[function code]
+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
 
-Next step: Optimize for performance"
+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"
+})
 ```
 
-## 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
+## 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,15 +1,40 @@
-# Swarm Commands
+---
+name: swarm-README
+description: Swarm skill index — lists all available swarm coordination skills and strategies for multi-agent task execution
+---
 
-Commands for swarm operations in Monomind.
+# Swarm Skills
 
-## Available Commands
+Multi-agent swarm coordination for Monomind.
 
-- [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)
+## 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,95 +1,73 @@
+---
+name: swarm-analysis
+description: Analysis swarm strategy — distributed codebase, performance, and security analysis through coordinated mesh agents
+---
+
 # Analysis Swarm Strategy
 
-## Purpose
 Comprehensive analysis through distributed agent coordination.
 
-## Activation
+## 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
 
-### Using MCP Tools
 ```javascript
 // Initialize analysis swarm
 mcp__monomind__swarm_init({
-  "topology": "mesh",
-  "maxAgents": 6,
-  "strategy": "adaptive"
+  topology: "mesh",
+  maxAgents: 6,
+  strategy: "adaptive"
 })
 
-// Orchestrate analysis task
-mcp__monomind__task_orchestrate({
-  "task": "analyze system performance",
-  "strategy": "parallel",
-  "priority": "medium"
+// Coordinate analysis
+mcp__monomind__coordination_orchestrate({
+  task: "analyze system performance",
+  strategy: "parallel"
 })
 ```
 
-### Using CLI (Fallback)
-`npx monomind swarm "analyze system performance" --strategy analysis`
+```bash
+# CLI equivalent
+npx monomind swarm init --topology mesh --max-agents 6
+npx monomind swarm start "analyze system performance" --strategy analysis --parallel
+```
 
 ## 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"]
-})
+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
-- 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"]
-})
+| 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 |
 
-// Pattern recognition
-mcp__monomind__pattern_recognize({
-  "data": performanceData,
-  "patterns": ["anomaly", "trend", "cycle"]
-})
-```
+## Monitoring
 
-## Status Monitoring
 ```javascript
-// Monitor analysis progress
-mcp__monomind__task_status({
-  "taskId": "analysis-task-001"
-})
+// Check analysis progress
+mcp__monomind__swarm_status({ swarmId: "current" })
 
-// Get analysis results
-mcp__monomind__task_results({
-  "taskId": "analysis-task-001"
-})
+// Performance metrics
+mcp__monomind__performance_report({ format: "detailed" })
+
+// System health
+mcp__monomind__system_health({})
 ```