@monoes/monomindcli 1.10.47 → 1.10.55

package/.claude/skills/security-hardening/SKILL.md

@@ -1,101 +0,0 @@
----
-name: security-hardening
-description: "Complete security architecture hardening for monomind. Addresses critical CVEs (CVE-1, CVE-2, CVE-3) and implements secure-by-default patterns. Use for security-first implementation."
-triggers:
-  - security vulnerability
-  - CVE fix
-  - input validation
-  - path traversal
-  - hardcoded credentials
-  - security audit
-  - harden monomind
-  - injection vulnerability
-  - security scan
----
-
-# Security Overhaul
-
-## What This Skill Does
-
-Orchestrates comprehensive security hardening for monomind, addressing critical vulnerabilities and establishing security-first development practices using specialized v1 security agents.
-
-## Quick Start
-
-```bash
-# Initialize v1 security domain (parallel)
-Task("Security architecture", "Design v1 threat model and security boundaries", "v1-security-architect")
-Task("CVE remediation", "Fix CVE-1, CVE-2, CVE-3 critical vulnerabilities", "security-auditor")
-Task("Security testing", "Implement TDD London School security framework", "test-architect")
-```
-
-## Critical Security Fixes
-
-### CVE-1: Vulnerable Dependencies
-
-```bash
-npm update @anthropic-ai/claude-code@^2.0.31
-npm audit --audit-level high
-```
-
-### CVE-2: Weak Password Hashing
-
-```typescript
-// ❌ Old: SHA-256 with hardcoded salt
-const hash = crypto
-  .createHash("sha256")
-  .update(password + salt)
-  .digest("hex");
-
-// ✅ New: bcrypt with 12 rounds
-import bcrypt from "bcrypt";
-const hash = await bcrypt.hash(password, 12);
-```
-
-### CVE-3: Hardcoded Credentials
-
-```typescript
-// ✅ Generate secure random credentials
-const apiKey = crypto.randomBytes(32).toString("hex");
-```
-
-## Security Patterns
-
-### Input Validation (Zod)
-
-```typescript
-import { z } from "zod";
-
-const TaskSchema = z.object({
-  taskId: z.string().uuid(),
-  content: z.string().max(10000),
-  agentType: z.enum(["security", "core", "integration"]),
-});
-```
-
-### Path Sanitization
-
-```typescript
-function securePath(userPath: string, allowedPrefix: string): string {
-  const resolved = path.resolve(allowedPrefix, userPath);
-  if (!resolved.startsWith(path.resolve(allowedPrefix))) {
-    throw new SecurityError("Path traversal detected");
-  }
-  return resolved;
-}
-```
-
-### Safe Command Execution
-
-```typescript
-import { execFile } from "child_process";
-
-// ✅ Safe: No shell interpretation
-const { stdout } = await execFile("git", [userInput], { shell: false });
-```
-
-## Success Metrics
-
-- **Security Score**: 90/100 (npm audit + custom scans)
-- **CVE Resolution**: 100% of critical vulnerabilities fixed
-- **Test Coverage**: >95% security-critical code
-- **Implementation**: All secure patterns documented and tested

package/.claude/skills/stream-chain/SKILL.md

@@ -1,560 +0,0 @@
----
-name: stream-chain
-description: Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows
----
-
-# Stream-Chain Skill
-
-Execute sophisticated multi-step workflows where each agent's output flows into the next, enabling complex data transformations and sequential processing pipelines.
-
-## Overview
-
-Stream-Chain provides two powerful modes for orchestrating multi-agent workflows:
-
-1. **Custom Chains** (`run`): Execute custom prompt sequences with full control
-2. **Predefined Pipelines** (`pipeline`): Use battle-tested workflows for common tasks
-
-Each step in a chain receives the complete output from the previous step, enabling sophisticated multi-agent coordination through streaming data flow.
-
----
-
-## Quick Start
-
-### Run a Custom Chain
-
-```bash
-monomind stream-chain run \
-  "Analyze codebase structure" \
-  "Identify improvement areas" \
-  "Generate action plan"
-```
-
-### Execute a Pipeline
-
-```bash
-monomind stream-chain pipeline analysis
-```
-
----
-
-## Custom Chains (`run`)
-
-Execute custom stream chains with your own prompts for maximum flexibility.
-
-### Syntax
-
-```bash
-monomind stream-chain run <prompt1> <prompt2> [...] [options]
-```
-
-**Requirements:**
-- Minimum 2 prompts required
-- Each prompt becomes a step in the chain
-- Output flows sequentially through all steps
-
-### Options
-
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--verbose` | Show detailed execution information | `false` |
-| `--timeout <seconds>` | Timeout per step | `30` |
-| `--debug` | Enable debug mode with full logging | `false` |
-
-### How Context Flows
-
-Each step receives the previous output as context:
-
-```
-Step 1: "Write a sorting function"
-Output: [function implementation]
-
-Step 2 receives:
-  "Previous step output:
-  [function implementation]
-
-  Next task: Add comprehensive tests"
-
-Step 3 receives:
-  "Previous steps output:
-  [function + tests]
-
-  Next task: Optimize performance"
-```
-
-### Examples
-
-#### Basic Development Chain
-
-```bash
-monomind stream-chain run \
-  "Write a user authentication function" \
-  "Add input validation and error handling" \
-  "Create unit tests with edge cases"
-```
-
-#### Security Audit Workflow
-
-```bash
-monomind stream-chain run \
-  "Analyze authentication system for vulnerabilities" \
-  "Identify and categorize security issues by severity" \
-  "Propose fixes with implementation priority" \
-  "Generate security test cases" \
-  --timeout 45 \
-  --verbose
-```
-
-#### Code Refactoring Chain
-
-```bash
-monomind stream-chain run \
-  "Identify code smells in src/ directory" \
-  "Create refactoring plan with specific changes" \
-  "Apply refactoring to top 3 priority items" \
-  "Verify refactored code maintains behavior" \
-  --debug
-```
-
-#### Data Processing Pipeline
-
-```bash
-monomind stream-chain run \
-  "Extract data from API responses" \
-  "Transform data into normalized format" \
-  "Validate data against schema" \
-  "Generate data quality report"
-```
-
----
-
-## Predefined Pipelines (`pipeline`)
-
-Execute battle-tested workflows optimized for common development tasks.
-
-### Syntax
-
-```bash
-monomind stream-chain pipeline <type> [options]
-```
-
-### Available Pipelines
-
-#### 1. Analysis Pipeline
-
-Comprehensive codebase analysis and improvement identification.
-
-```bash
-monomind stream-chain pipeline analysis
-```
-
-**Workflow Steps:**
-1. **Structure Analysis**: Map directory structure and identify components
-2. **Issue Detection**: Find potential improvements and problems
-3. **Recommendations**: Generate actionable improvement report
-
-**Use Cases:**
-- New codebase onboarding
-- Technical debt assessment
-- Architecture review
-- Code quality audits
-
-#### 2. Refactor Pipeline
-
-Systematic code refactoring with prioritization.
-
-```bash
-monomind stream-chain pipeline refactor
-```
-
-**Workflow Steps:**
-1. **Candidate Identification**: Find code needing refactoring
-2. **Prioritization**: Create ranked refactoring plan
-3. **Implementation**: Provide refactored code for top priorities
-
-**Use Cases:**
-- Technical debt reduction
-- Code quality improvement
-- Legacy code modernization
-- Design pattern implementation
-
-#### 3. Test Pipeline
-
-Comprehensive test generation with coverage analysis.
-
-```bash
-monomind stream-chain pipeline test
-```
-
-**Workflow Steps:**
-1. **Coverage Analysis**: Identify areas lacking tests
-2. **Test Design**: Create test cases for critical functions
-3. **Implementation**: Generate unit tests with assertions
-
-**Use Cases:**
-- Increasing test coverage
-- TDD workflow support
-- Regression test creation
-- Quality assurance
-
-#### 4. Optimize Pipeline
-
-Performance optimization with profiling and implementation.
-
-```bash
-monomind stream-chain pipeline optimize
-```
-
-**Workflow Steps:**
-1. **Profiling**: Identify performance bottlenecks
-2. **Strategy**: Analyze and suggest optimization approaches
-3. **Implementation**: Provide optimized code
-
-**Use Cases:**
-- Performance improvement
-- Resource optimization
-- Scalability enhancement
-- Latency reduction
-
-### Pipeline Options
-
-| Option | Description | Default |
-|--------|-------------|---------|
-| `--verbose` | Show detailed execution | `false` |
-| `--timeout <seconds>` | Timeout per step | `30` |
-| `--debug` | Enable debug mode | `false` |
-
-### Pipeline Examples
-
-#### Quick Analysis
-
-```bash
-monomind stream-chain pipeline analysis
-```
-
-#### Extended Refactoring
-
-```bash
-monomind stream-chain pipeline refactor --timeout 60 --verbose
-```
-
-#### Debug Test Generation
-
-```bash
-monomind stream-chain pipeline test --debug
-```
-
-#### Comprehensive Optimization
-
-```bash
-monomind stream-chain pipeline optimize --timeout 90 --verbose
-```
-
-### Pipeline Output
-
-Each pipeline execution provides:
-
-- **Progress**: Step-by-step execution status
-- **Results**: Success/failure per step
-- **Timing**: Total and per-step execution time
-- **Summary**: Consolidated results and recommendations
-
----
-
-## Custom Pipeline Definitions
-
-Define reusable pipelines in `.monomind/config.json`:
-
-### Configuration Format
-
-```json
-{
-  "streamChain": {
-    "pipelines": {
-      "security": {
-        "name": "Security Audit Pipeline",
-        "description": "Comprehensive security analysis",
-        "prompts": [
-          "Scan codebase for security vulnerabilities",
-          "Categorize issues by severity (critical/high/medium/low)",
-          "Generate fixes with priority and implementation steps",
-          "Create security test suite"
-        ],
-        "timeout": 45
-      },
-      "documentation": {
-        "name": "Documentation Generation Pipeline",
-        "prompts": [
-          "Analyze code structure and identify undocumented areas",
-          "Generate API documentation with examples",
-          "Create usage guides and tutorials",
-          "Build architecture diagrams and flow charts"
-        ]
-      }
-    }
-  }
-}
-```
-
-### Execute Custom Pipeline
-
-```bash
-monomind stream-chain pipeline security
-monomind stream-chain pipeline documentation
-```
-
----
-
-## Advanced Use Cases
-
-### Multi-Agent Coordination
-
-Chain different agent types for complex workflows:
-
-```bash
-monomind stream-chain run \
-  "Research best practices for API design" \
-  "Design REST API with discovered patterns" \
-  "Implement API endpoints with validation" \
-  "Generate OpenAPI specification" \
-  "Create integration tests" \
-  "Write deployment documentation"
-```
-
-### Data Transformation Pipeline
-
-Process and transform data through multiple stages:
-
-```bash
-monomind stream-chain run \
-  "Extract user data from CSV files" \
-  "Normalize and validate data format" \
-  "Enrich data with external API calls" \
-  "Generate analytics report" \
-  "Create visualization code"
-```
-
-### Code Migration Workflow
-
-Systematic code migration with validation:
-
-```bash
-monomind stream-chain run \
-  "Analyze legacy codebase dependencies" \
-  "Create migration plan with risk assessment" \
-  "Generate modernized code for high-priority modules" \
-  "Create migration tests" \
-  "Document migration steps and rollback procedures"
-```
-
-### Quality Assurance Chain
-
-Comprehensive code quality workflow:
-
-```bash
-monomind stream-chain pipeline analysis
-monomind stream-chain pipeline refactor
-monomind stream-chain pipeline test
-monomind stream-chain pipeline optimize
-```
-
----
-
-## Best Practices
-
-### 1. Clear and Specific Prompts
-
-**Good:**
-```bash
-"Analyze authentication.js for SQL injection vulnerabilities"
-```
-
-**Avoid:**
-```bash
-"Check security"
-```
-
-### 2. Logical Progression
-
-Order prompts to build on previous outputs:
-```bash
-1. "Identify the problem"
-2. "Analyze root causes"
-3. "Design solution"
-4. "Implement solution"
-5. "Verify implementation"
-```
-
-### 3. Appropriate Timeouts
-
-- Simple tasks: 30 seconds (default)
-- Analysis tasks: 45-60 seconds
-- Implementation tasks: 60-90 seconds
-- Complex workflows: 90-120 seconds
-
-### 4. Verification Steps
-
-Include validation in your chains:
-```bash
-monomind stream-chain run \
-  "Implement feature X" \
-  "Write tests for feature X" \
-  "Verify tests pass and cover edge cases"
-```
-
-### 5. Iterative Refinement
-
-Use chains for iterative improvement:
-```bash
-monomind stream-chain run \
-  "Generate initial implementation" \
-  "Review and identify issues" \
-  "Refine based on issues found" \
-  "Final quality check"
-```
-
----
-
-## Integration with Monomind
-
-### Combine with Swarm Coordination
-
-```bash
-# Initialize swarm for coordination
-monomind swarm init --topology mesh
-
-# Execute stream chain with swarm agents
-monomind stream-chain run \
-  "Agent 1: Research task" \
-  "Agent 2: Implement solution" \
-  "Agent 3: Test implementation" \
-  "Agent 4: Review and refine"
-```
-
-### Memory Integration
-
-Stream chains automatically store context in memory for cross-session persistence:
-
-```bash
-# Execute chain with memory
-monomind stream-chain run \
-  "Analyze requirements" \
-  "Design architecture" \
-  --verbose
-
-# Results stored in .monomind/memory/stream-chain/
-```
-
-### Neural Pattern Training
-
-Successful chains train neural patterns for improved performance:
-
-```bash
-# Enable neural training
-monomind stream-chain pipeline optimize --debug
-
-# Patterns learned and stored for future optimizations
-```
-
----
-
-## Troubleshooting
-
-### Chain Timeout
-
-If steps timeout, increase timeout value:
-
-```bash
-monomind stream-chain run "complex task" --timeout 120
-```
-
-### Context Loss
-
-If context not flowing properly, use `--debug`:
-
-```bash
-monomind stream-chain run "step 1" "step 2" --debug
-```
-
-### Pipeline Not Found
-
-Verify pipeline name and custom definitions:
-
-```bash
-# Check available pipelines
-cat .monomind/config.json | grep -A 10 "streamChain"
-```
-
----
-
-## Performance Characteristics
-
-- **Throughput**: 2-5 steps per minute (varies by complexity)
-- **Context Size**: Up to 100K tokens per step
-- **Memory Usage**: ~50MB per active chain
-- **Concurrency**: Supports parallel chain execution
-
----
-
-## Related Skills
-
-- **SPARC Methodology**: Systematic development workflow
-- **Swarm Coordination**: Multi-agent orchestration
-- **Memory Management**: Persistent context storage
-- **Neural Patterns**: Adaptive learning
-
----
-
-## Examples Repository
-
-### Complete Development Workflow
-
-```bash
-# Full feature development chain
-monomind stream-chain run \
-  "Analyze requirements for user profile feature" \
-  "Design database schema and API endpoints" \
-  "Implement backend with validation" \
-  "Create frontend components" \
-  "Write comprehensive tests" \
-  "Generate API documentation" \
-  --timeout 60 \
-  --verbose
-```
-
-### Code Review Pipeline
-
-```bash
-# Automated code review workflow
-monomind stream-chain run \
-  "Analyze recent git changes" \
-  "Identify code quality issues" \
-  "Check for security vulnerabilities" \
-  "Verify test coverage" \
-  "Generate code review report with recommendations"
-```
-
-### Migration Assistant
-
-```bash
-# Framework migration helper
-monomind stream-chain run \
-  "Analyze current Vue 2 codebase" \
-  "Identify Vue 3 breaking changes" \
-  "Create migration checklist" \
-  "Generate migration scripts" \
-  "Provide updated code examples"
-```
-
----
-
-## Conclusion
-
-Stream-Chain enables sophisticated multi-step workflows by:
-
-- **Sequential Processing**: Each step builds on previous results
-- **Context Preservation**: Full output history flows through chain
-- **Flexible Orchestration**: Custom chains or predefined pipelines
-- **Agent Coordination**: Natural multi-agent collaboration pattern
-- **Data Transformation**: Complex processing through simple steps
-
-Use `run` for custom workflows and `pipeline` for battle-tested solutions.