claude-flow 2.0.0-alpha.70 → 2.0.0-alpha.71

package/.claude/commands/sparc/architect.md

@@ -1,21 +1,9 @@
----
-name: sparc-architect
-description: 🏗️ Architect - You design scalable, secure, and modular architectures based on functional specs and user needs. ...
----
+# SPARC Architect Mode
 
-# 🏗️ Architect
+## Purpose
+System design with Memory-based coordination for scalable architectures.
 
-## Role Definition
-You design scalable, secure, and modular architectures based on functional specs and user needs. You define responsibilities across services, APIs, and components.
-
-## Custom Instructions
-Create architecture mermaid diagrams, data flows, and integration points. Ensure no part of the design includes secrets or hardcoded env values. Emphasize modular boundaries and maintain extensibility. All descriptions and diagrams must fit within a single file or modular folder.
-
-## Available Tools
-- **read**: File reading and viewing
-- **edit**: File modification and creation
-
-## Usage
+## Activation
 
 ### Option 1: Using MCP Tools (Preferred in Claude Code)
 ```javascript
@@ -23,8 +11,8 @@ mcp__claude-flow__sparc_mode {
   mode: "architect",
   task_description: "design microservices architecture",
   options: {
-    namespace: "architect",
-    non_interactive: false
+    detailed: true,
+    memory_enabled: true
   }
 }
 ```
@@ -36,12 +24,6 @@ npx claude-flow sparc run architect "design microservices architecture"
 
 # For alpha features
 npx claude-flow@alpha sparc run architect "design microservices architecture"
-
-# With namespace
-npx claude-flow sparc run architect "your task" --namespace architect
-
-# Non-interactive mode
-npx claude-flow sparc run architect "your task" --non-interactive
 ```
 
 ### Option 3: Local Installation
@@ -50,31 +32,22 @@ npx claude-flow sparc run architect "your task" --non-interactive
 ./claude-flow sparc run architect "design microservices architecture"
 ```
 
-## Memory Integration
-
-### Using MCP Tools (Preferred)
-```javascript
-// Store mode-specific context
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "architect_context",
-  value: "important decisions",
-  namespace: "architect"
-}
-
-// Query previous work
-mcp__claude-flow__memory_search {
-  pattern: "architect",
-  namespace: "architect",
-  limit: 5
-}
-```
-
-### Using NPX CLI (Fallback)
-```bash
-# Store mode-specific context
-npx claude-flow memory store "architect_context" "important decisions" --namespace architect
+## Core Capabilities
+- System architecture design
+- Component interface definition
+- Database schema design
+- API contract specification
+- Infrastructure planning
 
-# Query previous work
-npx claude-flow memory query "architect" --limit 5
-```
+## Memory Integration
+- Store architecture decisions in Memory
+- Share component specifications across agents
+- Maintain design consistency
+- Track architectural evolution
+
+## Design Patterns
+- Microservices
+- Event-driven architecture
+- Domain-driven design
+- Hexagonal architecture
+- CQRS and Event Sourcing

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

@@ -1,33 +1,18 @@
----
-name: sparc-tdd
-description: 🧪 Tester (TDD) - You implement Test-Driven Development (TDD, London School), writing tests first and refactoring a...
----
+# SPARC TDD Mode
 
-# 🧪 Tester (TDD)
+## Purpose
+Test-driven development with TodoWrite planning and comprehensive testing.
 
-## Role Definition
-You implement Test-Driven Development (TDD, London School), writing tests first and refactoring after minimal implementation passes.
-
-## Custom Instructions
-Write failing tests first. Implement only enough code to pass. Refactor after green. Ensure tests do not hardcode secrets. Keep files < 500 lines. Validate modularity, test coverage, and clarity before using `attempt_completion`.
-
-## Available Tools
-- **read**: File reading and viewing
-- **edit**: File modification and creation
-- **browser**: Web browsing capabilities
-- **mcp**: Model Context Protocol tools
-- **command**: Command execution
-
-## Usage
+## Activation
 
 ### Option 1: Using MCP Tools (Preferred in Claude Code)
 ```javascript
 mcp__claude-flow__sparc_mode {
   mode: "tdd",
-  task_description: "create user authentication tests",
+  task_description: "shopping cart feature",
   options: {
-    namespace: "tdd",
-    non_interactive: false
+    coverage_target: 90,
+    test_framework: "jest"
   }
 }
 ```
@@ -35,49 +20,35 @@ mcp__claude-flow__sparc_mode {
 ### Option 2: Using NPX CLI (Fallback when MCP not available)
 ```bash
 # Use when running from terminal or MCP tools unavailable
-npx claude-flow sparc run tdd "create user authentication tests"
+npx claude-flow sparc run tdd "shopping cart feature"
 
 # For alpha features
-npx claude-flow@alpha sparc run tdd "create user authentication tests"
-
-# With namespace
-npx claude-flow sparc run tdd "your task" --namespace tdd
-
-# Non-interactive mode
-npx claude-flow sparc run tdd "your task" --non-interactive
+npx claude-flow@alpha sparc run tdd "shopping cart feature"
 ```
 
 ### Option 3: Local Installation
 ```bash
 # If claude-flow is installed locally
-./claude-flow sparc run tdd "create user authentication tests"
+./claude-flow sparc run tdd "shopping cart feature"
 ```
 
-## Memory Integration
-
-### Using MCP Tools (Preferred)
-```javascript
-// Store mode-specific context
-mcp__claude-flow__memory_usage {
-  action: "store",
-  key: "tdd_context",
-  value: "important decisions",
-  namespace: "tdd"
-}
-
-// Query previous work
-mcp__claude-flow__memory_search {
-  pattern: "tdd",
-  namespace: "tdd",
-  limit: 5
-}
-```
-
-### Using NPX CLI (Fallback)
-```bash
-# Store mode-specific context
-npx claude-flow memory store "tdd_context" "important decisions" --namespace tdd
-
-# Query previous work
-npx claude-flow memory query "tdd" --limit 5
-```
+## Core Capabilities
+- Test-first development
+- Red-green-refactor cycle
+- Test suite design
+- Coverage optimization
+- Continuous testing
+
+## TDD Workflow
+1. Write failing tests
+2. Implement minimum code
+3. Make tests pass
+4. Refactor code
+5. Repeat cycle
+
+## Testing Strategies
+- Unit testing
+- Integration testing
+- End-to-end testing
+- Performance testing
+- Security testing

package/.claude/settings.local.json

@@ -2,7 +2,12 @@
   "permissions": {
     "allow": [
       "mcp__ruv-swarm",
-      "mcp__claude-flow"
+      "mcp__claude-flow",
+      "Bash(npx:*)",
+      "Bash(npx:*)",
+      "Bash(npx:*)",
+      "Bash(npx claude-flow:*)",
+      "Bash(npx:*)"
     ],
     "deny": []
   }

package/bin/claude-flow

@@ -1,7 +1,7 @@
 #!/bin/sh
 # Claude-Flow Smart Dispatcher - Detects and uses the best available runtime
 
-VERSION="2.0.0-alpha.70"
+VERSION="2.0.0-alpha.71"
 
 # Determine the correct path based on how the script is invoked
 if [ -L "$0" ]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-flow",
-  "version": "2.0.0-alpha.70",
+  "version": "2.0.0-alpha.71",
   "description": "Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)",
   "main": "cli.mjs",
   "bin": {

package/src/cli/simple-commands/hooks.js

@@ -438,7 +438,16 @@ async function postTaskCommand(subArgs, flags) {
 async function postEditCommand(subArgs, flags) {
   const options = flags;
   const file = options.file || 'unknown-file';
-  const memoryKey = options['memory-key'] || options.memoryKey;
+  let memoryKey = options['memory-key'] || options.memoryKey;
+  
+  // Handle case where memory-key is passed as a boolean flag without value
+  if (memoryKey === true) {
+    // Generate a default memory key based on the file path and timestamp
+    const path = await import('path');
+    const basename = path.basename(file);
+    memoryKey = `edit:${basename}:${Date.now()}`;
+  }
+  
   const format = options.format || false;
   const updateMemory = options['update-memory'] || false;
   const trainNeural = options['train-neural'] || false;
@@ -566,7 +575,7 @@ async function postEditCommand(subArgs, flags) {
       metadata: { hookType: 'post-edit', file, formatted: formatResult?.attempted || false },
     });
 
-    if (memoryKey) {
+    if (memoryKey && typeof memoryKey === 'string') {
       await store.store(
         memoryKey,
         {

package/.claude/commands/analysis/README.md

@@ -1,9 +0,0 @@
-# Analysis Commands
-
-Commands for analysis operations in Claude Flow.
-
-## Available Commands
-
-- [bottleneck-detect](./bottleneck-detect.md)
-- [token-usage](./token-usage.md)
-- [performance-report](./performance-report.md)

package/.claude/commands/analysis/bottleneck-detect.md

@@ -1,162 +0,0 @@
-# bottleneck detect
-
-Analyze performance bottlenecks in swarm operations and suggest optimizations.
-
-## Usage
-
-```bash
-npx claude-flow bottleneck detect [options]
-```
-
-## Options
-
-- `--swarm-id, -s <id>` - Analyze specific swarm (default: current)
-- `--time-range, -t <range>` - Analysis period: 1h, 24h, 7d, all (default: 1h)
-- `--threshold <percent>` - Bottleneck threshold percentage (default: 20)
-- `--export, -e <file>` - Export analysis to file
-- `--fix` - Apply automatic optimizations
-
-## Examples
-
-### Basic bottleneck detection
-
-```bash
-npx claude-flow bottleneck detect
-```
-
-### Analyze specific swarm
-
-```bash
-npx claude-flow bottleneck detect --swarm-id swarm-123
-```
-
-### Last 24 hours with export
-
-```bash
-npx claude-flow bottleneck detect -t 24h -e bottlenecks.json
-```
-
-### Auto-fix detected issues
-
-```bash
-npx claude-flow bottleneck detect --fix --threshold 15
-```
-
-## Metrics Analyzed
-
-### Communication Bottlenecks
-
-- Message queue delays
-- Agent response times
-- Coordination overhead
-- Memory access patterns
-
-### Processing Bottlenecks
-
-- Task completion times
-- Agent utilization rates
-- Parallel execution efficiency
-- Resource contention
-
-### Memory Bottlenecks
-
-- Cache hit rates
-- Memory access patterns
-- Storage I/O performance
-- Neural pattern loading
-
-### Network Bottlenecks
-
-- API call latency
-- MCP communication delays
-- External service timeouts
-- Concurrent request limits
-
-## Output Format
-
-```
-🔍 Bottleneck Analysis Report
-━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-📊 Summary
-├── Time Range: Last 1 hour
-├── Agents Analyzed: 6
-├── Tasks Processed: 42
-└── Critical Issues: 2
-
-🚨 Critical Bottlenecks
-1. Agent Communication (35% impact)
-   └── coordinator → coder-1 messages delayed by 2.3s avg
-
-2. Memory Access (28% impact)
-   └── Neural pattern loading taking 1.8s per access
-
-⚠️ Warning Bottlenecks
-1. Task Queue (18% impact)
-   └── 5 tasks waiting > 10s for assignment
-
-💡 Recommendations
-1. Switch to hierarchical topology (est. 40% improvement)
-2. Enable memory caching (est. 25% improvement)
-3. Increase agent concurrency to 8 (est. 20% improvement)
-
-✅ Quick Fixes Available
-Run with --fix to apply:
-- Enable smart caching
-- Optimize message routing
-- Adjust agent priorities
-```
-
-## Automatic Fixes
-
-When using `--fix`, the following optimizations may be applied:
-
-1. **Topology Optimization**
-
-   - Switch to more efficient topology
-   - Adjust communication patterns
-   - Reduce coordination overhead
-
-2. **Caching Enhancement**
-
-   - Enable memory caching
-   - Optimize cache strategies
-   - Preload common patterns
-
-3. **Concurrency Tuning**
-
-   - Adjust agent counts
-   - Optimize parallel execution
-   - Balance workload distribution
-
-4. **Priority Adjustment**
-   - Reorder task queues
-   - Prioritize critical paths
-   - Reduce wait times
-
-## Performance Impact
-
-Typical improvements after bottleneck resolution:
-
-- **Communication**: 30-50% faster message delivery
-- **Processing**: 20-40% reduced task completion time
-- **Memory**: 40-60% fewer cache misses
-- **Overall**: 25-45% performance improvement
-
-## Integration with Claude Code
-
-```javascript
-// Check for bottlenecks in Claude Code
-mcp__claude-flow__bottleneck_detect {
-  timeRange: "1h",
-  threshold: 20,
-  autoFix: false
-}
-```
-
-## See Also
-
-- `performance report` - Detailed performance analysis
-- `token usage` - Token optimization analysis
-- `swarm monitor` - Real-time monitoring
-- `cache manage` - Cache optimization

package/.claude/commands/analysis/performance-report.md

@@ -1,25 +0,0 @@
-# performance-report
-
-Generate comprehensive performance reports for swarm operations.
-
-## Usage
-```bash
-npx claude-flow analysis performance-report [options]
-```
-
-## Options
-- `--format <type>` - Report format (json, html, markdown)
-- `--include-metrics` - Include detailed metrics
-- `--compare <id>` - Compare with previous swarm
-
-## Examples
-```bash
-# Generate HTML report
-npx claude-flow analysis performance-report --format html
-
-# Compare swarms
-npx claude-flow analysis performance-report --compare swarm-123
-
-# Full metrics report
-npx claude-flow analysis performance-report --include-metrics --format markdown
-```

package/.claude/commands/analysis/token-usage.md

@@ -1,25 +0,0 @@
-# token-usage
-
-Analyze token usage patterns and optimize for efficiency.
-
-## Usage
-```bash
-npx claude-flow analysis token-usage [options]
-```
-
-## Options
-- `--period <time>` - Analysis period (1h, 24h, 7d, 30d)
-- `--by-agent` - Break down by agent
-- `--by-operation` - Break down by operation type
-
-## Examples
-```bash
-# Last 24 hours token usage
-npx claude-flow analysis token-usage --period 24h
-
-# By agent breakdown
-npx claude-flow analysis token-usage --by-agent
-
-# Export detailed report
-npx claude-flow analysis token-usage --period 7d --export tokens.csv
-```

package/.claude/commands/automation/README.md

@@ -1,9 +0,0 @@
-# Automation Commands
-
-Commands for automation operations in Claude Flow.
-
-## Available Commands
-
-- [auto-agent](./auto-agent.md)
-- [smart-spawn](./smart-spawn.md)
-- [workflow-select](./workflow-select.md)

package/.claude/commands/automation/auto-agent.md

@@ -1,122 +0,0 @@
-# auto agent
-
-Automatically spawn and manage agents based on task requirements.
-
-## Usage
-
-```bash
-npx claude-flow auto agent [options]
-```
-
-## Options
-
-- `--task, -t <description>` - Task description for agent analysis
-- `--max-agents, -m <number>` - Maximum agents to spawn (default: auto)
-- `--min-agents <number>` - Minimum agents required (default: 1)
-- `--strategy, -s <type>` - Selection strategy: optimal, minimal, balanced
-- `--no-spawn` - Analyze only, don't spawn agents
-
-## Examples
-
-### Basic auto-spawning
-
-```bash
-npx claude-flow auto agent --task "Build a REST API with authentication"
-```
-
-### Constrained spawning
-
-```bash
-npx claude-flow auto agent -t "Debug performance issue" --max-agents 3
-```
-
-### Analysis only
-
-```bash
-npx claude-flow auto agent -t "Refactor codebase" --no-spawn
-```
-
-### Minimal strategy
-
-```bash
-npx claude-flow auto agent -t "Fix bug in login" -s minimal
-```
-
-## How It Works
-
-1. **Task Analysis**
-
-   - Parses task description
-   - Identifies required skills
-   - Estimates complexity
-   - Determines parallelization opportunities
-
-2. **Agent Selection**
-
-   - Matches skills to agent types
-   - Considers task dependencies
-   - Optimizes for efficiency
-   - Respects constraints
-
-3. **Topology Selection**
-
-   - Chooses optimal swarm structure
-   - Configures communication patterns
-   - Sets up coordination rules
-   - Enables monitoring
-
-4. **Automatic Spawning**
-   - Creates selected agents
-   - Assigns specific roles
-   - Distributes subtasks
-   - Initiates coordination
-
-## Agent Types Selected
-
-- **Architect**: System design, architecture decisions
-- **Coder**: Implementation, code generation
-- **Tester**: Test creation, quality assurance
-- **Analyst**: Performance, optimization
-- **Researcher**: Documentation, best practices
-- **Coordinator**: Task management, progress tracking
-
-## Strategies
-
-### Optimal
-
-- Maximum efficiency
-- May spawn more agents
-- Best for complex tasks
-- Highest resource usage
-
-### Minimal
-
-- Minimum viable agents
-- Conservative approach
-- Good for simple tasks
-- Lowest resource usage
-
-### Balanced
-
-- Middle ground
-- Adaptive to complexity
-- Default strategy
-- Good performance/resource ratio
-
-## Integration with Claude Code
-
-```javascript
-// In Claude Code after auto-spawning
-mcp__claude-flow__auto_agent {
-  task: "Build authentication system",
-  strategy: "balanced",
-  maxAgents: 6
-}
-```
-
-## See Also
-
-- `agent spawn` - Manual agent creation
-- `swarm init` - Initialize swarm manually
-- `smart spawn` - Intelligent agent spawning
-- `workflow select` - Choose predefined workflows

package/.claude/commands/automation/smart-spawn.md

@@ -1,25 +0,0 @@
-# smart-spawn
-
-Intelligently spawn agents based on workload analysis.
-
-## Usage
-```bash
-npx claude-flow automation smart-spawn [options]
-```
-
-## Options
-- `--analyze` - Analyze before spawning
-- `--threshold <n>` - Spawn threshold
-- `--topology <type>` - Preferred topology
-
-## Examples
-```bash
-# Smart spawn with analysis
-npx claude-flow automation smart-spawn --analyze
-
-# Set spawn threshold
-npx claude-flow automation smart-spawn --threshold 5
-
-# Force topology
-npx claude-flow automation smart-spawn --topology hierarchical
-```

package/.claude/commands/automation/workflow-select.md

@@ -1,25 +0,0 @@
-# workflow-select
-
-Automatically select optimal workflow based on task type.
-
-## Usage
-```bash
-npx claude-flow automation workflow-select [options]
-```
-
-## Options
-- `--task <description>` - Task description
-- `--constraints <list>` - Workflow constraints
-- `--preview` - Preview without executing
-
-## Examples
-```bash
-# Select workflow for task
-npx claude-flow automation workflow-select --task "Deploy to production"
-
-# With constraints
-npx claude-flow automation workflow-select --constraints "no-downtime,rollback"
-
-# Preview mode
-npx claude-flow automation workflow-select --task "Database migration" --preview
-```

package/.claude/commands/coordination/README.md

@@ -1,9 +0,0 @@
-# Coordination Commands
-
-Commands for coordination operations in Claude Flow.
-
-## Available Commands
-
-- [swarm-init](./swarm-init.md)
-- [agent-spawn](./agent-spawn.md)
-- [task-orchestrate](./task-orchestrate.md)