@sparkleideas/cli 3.1.0-alpha.15

package/.claude/helpers/ddd-tracker.sh

@@ -0,0 +1,144 @@
+#!/bin/bash
+# Claude Flow V3 - DDD Progress Tracker Worker
+# Tracks Domain-Driven Design implementation progress
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+METRICS_DIR="$PROJECT_ROOT/.claude-flow/metrics"
+DDD_FILE="$METRICS_DIR/ddd-progress.json"
+V3_PROGRESS="$METRICS_DIR/v3-progress.json"
+LAST_RUN_FILE="$METRICS_DIR/.ddd-last-run"
+
+mkdir -p "$METRICS_DIR"
+
+# V3 Target Domains
+DOMAINS=("agent-lifecycle" "task-execution" "memory-management" "coordination" "shared-kernel")
+
+should_run() {
+  if [ ! -f "$LAST_RUN_FILE" ]; then return 0; fi
+  local last_run=$(cat "$LAST_RUN_FILE" 2>/dev/null || echo "0")
+  local now=$(date +%s)
+  [ $((now - last_run)) -ge 600 ]  # 10 minutes
+}
+
+check_domain() {
+  local domain="$1"
+  local domain_path="$PROJECT_ROOT/v3/@claude-flow/$domain"
+  local alt_path="$PROJECT_ROOT/src/domains/$domain"
+
+  local score=0
+  local max_score=100
+
+  # Check if domain directory exists (20 points)
+  if [ -d "$domain_path" ] || [ -d "$alt_path" ]; then
+    score=$((score + 20))
+    local path="${domain_path:-$alt_path}"
+    [ -d "$domain_path" ] && path="$domain_path" || path="$alt_path"
+
+    # Check for domain layer (15 points)
+    [ -d "$path/domain" ] || [ -d "$path/src/domain" ] && score=$((score + 15))
+
+    # Check for application layer (15 points)
+    [ -d "$path/application" ] || [ -d "$path/src/application" ] && score=$((score + 15))
+
+    # Check for infrastructure layer (15 points)
+    [ -d "$path/infrastructure" ] || [ -d "$path/src/infrastructure" ] && score=$((score + 15))
+
+    # Check for API/interface layer (10 points)
+    [ -d "$path/api" ] || [ -d "$path/src/api" ] && score=$((score + 10))
+
+    # Check for tests (15 points)
+    local test_count=$(find "$path" -name "*.test.ts" -o -name "*.spec.ts" 2>/dev/null | wc -l)
+    [ "$test_count" -gt 0 ] && score=$((score + 15))
+
+    # Check for index/exports (10 points)
+    [ -f "$path/index.ts" ] || [ -f "$path/src/index.ts" ] && score=$((score + 10))
+  fi
+
+  echo "$score"
+}
+
+count_entities() {
+  local type="$1"
+  local pattern="$2"
+
+  find "$PROJECT_ROOT/v3" "$PROJECT_ROOT/src" -name "*.ts" 2>/dev/null | \
+    xargs grep -l "$pattern" 2>/dev/null | \
+    grep -v node_modules | grep -v ".test." | wc -l || echo "0"
+}
+
+track_ddd() {
+  echo "[$(date +%H:%M:%S)] Tracking DDD progress..."
+
+  local total_score=0
+  local domain_scores=""
+  local completed_domains=0
+
+  for domain in "${DOMAINS[@]}"; do
+    local score=$(check_domain "$domain")
+    total_score=$((total_score + score))
+    domain_scores="$domain_scores\"$domain\": $score, "
+
+    [ "$score" -ge 50 ] && completed_domains=$((completed_domains + 1))
+  done
+
+  # Calculate overall progress
+  local max_total=$((${#DOMAINS[@]} * 100))
+  local progress=$((total_score * 100 / max_total))
+
+  # Count DDD artifacts
+  local entities=$(count_entities "entities" "class.*Entity\|interface.*Entity")
+  local value_objects=$(count_entities "value-objects" "class.*VO\|ValueObject")
+  local aggregates=$(count_entities "aggregates" "class.*Aggregate\|AggregateRoot")
+  local repositories=$(count_entities "repositories" "interface.*Repository\|Repository")
+  local services=$(count_entities "services" "class.*Service\|Service")
+  local events=$(count_entities "events" "class.*Event\|DomainEvent")
+
+  # Write DDD metrics
+  cat > "$DDD_FILE" << EOF
+{
+  "timestamp": "$(date -Iseconds)",
+  "progress": $progress,
+  "domains": {
+    ${domain_scores%,*}
+  },
+  "completed": $completed_domains,
+  "total": ${#DOMAINS[@]},
+  "artifacts": {
+    "entities": $entities,
+    "valueObjects": $value_objects,
+    "aggregates": $aggregates,
+    "repositories": $repositories,
+    "services": $services,
+    "domainEvents": $events
+  }
+}
+EOF
+
+  # Update v3-progress.json
+  if [ -f "$V3_PROGRESS" ] && command -v jq &>/dev/null; then
+    jq --argjson progress "$progress" --argjson completed "$completed_domains" \
+      '.ddd.progress = $progress | .domains.completed = $completed' \
+      "$V3_PROGRESS" > "$V3_PROGRESS.tmp" && mv "$V3_PROGRESS.tmp" "$V3_PROGRESS"
+  fi
+
+  echo "[$(date +%H:%M:%S)] ✓ DDD: ${progress}% | Domains: $completed_domains/${#DOMAINS[@]} | Entities: $entities | Services: $services"
+
+  date +%s > "$LAST_RUN_FILE"
+}
+
+case "${1:-check}" in
+  "run"|"track") track_ddd ;;
+  "check") should_run && track_ddd || echo "[$(date +%H:%M:%S)] Skipping (throttled)" ;;
+  "force") rm -f "$LAST_RUN_FILE"; track_ddd ;;
+  "status")
+    if [ -f "$DDD_FILE" ]; then
+      jq -r '"Progress: \(.progress)% | Domains: \(.completed)/\(.total) | Entities: \(.artifacts.entities) | Services: \(.artifacts.services)"' "$DDD_FILE"
+    else
+      echo "No DDD data available"
+    fi
+    ;;
+  *) echo "Usage: $0 [run|check|force|status]" ;;
+esac

package/.claude/helpers/github-safe.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+
+/**
+ * Safe GitHub CLI Helper
+ * Prevents timeout issues when using gh commands with special characters
+ * 
+ * Usage:
+ *   ./github-safe.js issue comment 123 "Message with `backticks`"
+ *   ./github-safe.js pr create --title "Title" --body "Complex body"
+ */
+
+import { execSync } from 'child_process';
+import { writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { randomBytes } from 'crypto';
+
+const args = process.argv.slice(2);
+
+if (args.length < 2) {
+  console.log(`
+Safe GitHub CLI Helper
+
+Usage:
+  ./github-safe.js issue comment <number> <body>
+  ./github-safe.js pr comment <number> <body>
+  ./github-safe.js issue create --title <title> --body <body>
+  ./github-safe.js pr create --title <title> --body <body>
+
+This helper prevents timeout issues with special characters like:
+- Backticks in code examples
+- Command substitution \$(...)
+- Directory paths
+- Special shell characters
+`);
+  process.exit(1);
+}
+
+const [command, subcommand, ...restArgs] = args;
+
+// Handle commands that need body content
+if ((command === 'issue' || command === 'pr') && 
+    (subcommand === 'comment' || subcommand === 'create')) {
+  
+  let bodyIndex = -1;
+  let body = '';
+  
+  if (subcommand === 'comment' && restArgs.length >= 2) {
+    // Simple format: github-safe.js issue comment 123 "body"
+    body = restArgs[1];
+    bodyIndex = 1;
+  } else {
+    // Flag format: --body "content" 
+    bodyIndex = restArgs.indexOf('--body');
+    if (bodyIndex !== -1 && bodyIndex < restArgs.length - 1) {
+      body = restArgs[bodyIndex + 1];
+    }
+  }
+  
+  if (body) {
+    // Use temporary file for body content
+    const tmpFile = join(tmpdir(), `gh-body-${randomBytes(8).toString('hex')}.tmp`);
+    
+    try {
+      writeFileSync(tmpFile, body, 'utf8');
+      
+      // Build new command with --body-file
+      const newArgs = [...restArgs];
+      if (subcommand === 'comment' && bodyIndex === 1) {
+        // Replace body with --body-file
+        newArgs[1] = '--body-file';
+        newArgs.push(tmpFile);
+      } else if (bodyIndex !== -1) {
+        // Replace --body with --body-file
+        newArgs[bodyIndex] = '--body-file';
+        newArgs[bodyIndex + 1] = tmpFile;
+      }
+      
+      // Execute safely
+      const ghCommand = `gh ${command} ${subcommand} ${newArgs.join(' ')}`;
+      console.log(`Executing: ${ghCommand}`);
+      
+      const result = execSync(ghCommand, { 
+        stdio: 'inherit',
+        timeout: 30000 // 30 second timeout
+      });
+      
+    } catch (error) {
+      console.error('Error:', error.message);
+      process.exit(1);
+    } finally {
+      // Clean up
+      try {
+        unlinkSync(tmpFile);
+      } catch (e) {
+        // Ignore cleanup errors
+      }
+    }
+  } else {
+    // No body content, execute normally
+    execSync(`gh ${args.join(' ')}`, { stdio: 'inherit' });
+  }
+} else {
+  // Other commands, execute normally
+  execSync(`gh ${args.join(' ')}`, { stdio: 'inherit' });
+}

package/.claude/helpers/github-setup.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+# Setup GitHub integration for Claude Flow
+
+echo "🔗 Setting up GitHub integration..."
+
+# Check for gh CLI
+if ! command -v gh &> /dev/null; then
+    echo "⚠️  GitHub CLI (gh) not found"
+    echo "Install from: https://cli.github.com/"
+    echo "Continuing without GitHub features..."
+else
+    echo "✅ GitHub CLI found"
+    
+    # Check auth status
+    if gh auth status &> /dev/null; then
+        echo "✅ GitHub authentication active"
+    else
+        echo "⚠️  Not authenticated with GitHub"
+        echo "Run: gh auth login"
+    fi
+fi
+
+echo ""
+echo "📦 GitHub swarm commands available:"
+echo "  - npx claude-flow github swarm"
+echo "  - npx claude-flow repo analyze"
+echo "  - npx claude-flow pr enhance"
+echo "  - npx claude-flow issue triage"

package/.claude/helpers/guidance-hook.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+# Capture hook guidance for Claude visibility
+GUIDANCE_FILE=".claude-flow/last-guidance.txt"
+mkdir -p .claude-flow
+
+case "$1" in
+  "route")
+    npx agentic-flow@alpha hooks route "$2" 2>&1 | tee "$GUIDANCE_FILE"
+    ;;
+  "pre-edit")
+    npx agentic-flow@alpha hooks pre-edit "$2" 2>&1 | tee "$GUIDANCE_FILE"
+    ;;
+esac

package/.claude/helpers/guidance-hooks.sh

@@ -0,0 +1,102 @@
+#!/bin/bash
+# Guidance Hooks for Claude Flow V3
+# Provides context and routing for Claude Code operations
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+CACHE_DIR="$PROJECT_ROOT/.claude-flow"
+
+# Ensure cache directory exists
+mkdir -p "$CACHE_DIR" 2>/dev/null || true
+
+# Color codes
+CYAN='\033[0;36m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+RESET='\033[0m'
+DIM='\033[2m'
+
+# Get command
+COMMAND="${1:-help}"
+shift || true
+
+case "$COMMAND" in
+    pre-edit)
+        FILE_PATH="$1"
+        if [[ -n "$FILE_PATH" ]]; then
+            if [[ "$FILE_PATH" =~ (config|secret|credential|password|key|auth) ]]; then
+                echo -e "${YELLOW}[Guidance] Security-sensitive file${RESET}"
+            fi
+            if [[ "$FILE_PATH" =~ ^v3/ ]]; then
+                echo -e "${CYAN}[Guidance] V3 module - follow ADR guidelines${RESET}"
+            fi
+        fi
+        exit 0
+        ;;
+
+    post-edit)
+        FILE_PATH="$1"
+        echo "$(date -Iseconds) edit $FILE_PATH" >> "$CACHE_DIR/edit-history.log" 2>/dev/null || true
+        exit 0
+        ;;
+
+    pre-command)
+        COMMAND_STR="$1"
+        if [[ "$COMMAND_STR" =~ (rm -rf|sudo|chmod 777) ]]; then
+            echo -e "${RED}[Guidance] High-risk command${RESET}"
+        fi
+        exit 0
+        ;;
+
+    route)
+        TASK="$1"
+        [[ -z "$TASK" ]] && exit 0
+        if [[ "$TASK" =~ (security|CVE|vulnerability) ]]; then
+            echo -e "${DIM}[Route] security-architect${RESET}"
+        elif [[ "$TASK" =~ (memory|AgentDB|HNSW|vector) ]]; then
+            echo -e "${DIM}[Route] memory-specialist${RESET}"
+        elif [[ "$TASK" =~ (performance|optimize|benchmark) ]]; then
+            echo -e "${DIM}[Route] performance-engineer${RESET}"
+        elif [[ "$TASK" =~ (test|TDD|spec) ]]; then
+            echo -e "${DIM}[Route] test-architect${RESET}"
+        fi
+        exit 0
+        ;;
+
+    session-context)
+        cat << 'EOF'
+## V3 Development Context
+
+**Architecture**: Domain-Driven Design with 15 @claude-flow modules
+**Priority**: Security-first (CVE-1, CVE-2, CVE-3 remediation)
+**Performance Targets**:
+- HNSW search: 150x-12,500x faster
+- Flash Attention: 2.49x-7.47x speedup
+- Memory: 50-75% reduction
+
+**Active Patterns**:
+- Use TDD London School (mock-first)
+- Event sourcing for state changes
+- agentic-flow@alpha as core foundation
+- Bounded contexts with clear interfaces
+
+**Code Quality Rules**:
+- Files under 500 lines
+- No hardcoded secrets
+- Input validation at boundaries
+- Typed interfaces for all public APIs
+
+**Learned Patterns**: 17 available for reference
+EOF
+        exit 0
+        ;;
+
+    user-prompt)
+        exit 0
+        ;;
+
+    *)
+        exit 0
+        ;;
+esac

package/.claude/helpers/health-monitor.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# Claude Flow V3 - Health Monitor Worker
+# Checks disk space, memory pressure, process health
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+METRICS_DIR="$PROJECT_ROOT/.claude-flow/metrics"
+HEALTH_FILE="$METRICS_DIR/health.json"
+LAST_RUN_FILE="$METRICS_DIR/.health-last-run"
+
+mkdir -p "$METRICS_DIR"
+
+should_run() {
+  if [ ! -f "$LAST_RUN_FILE" ]; then return 0; fi
+  local last_run=$(cat "$LAST_RUN_FILE" 2>/dev/null || echo "0")
+  local now=$(date +%s)
+  [ $((now - last_run)) -ge 300 ]  # 5 minutes
+}
+
+check_health() {
+  echo "[$(date +%H:%M:%S)] Running health check..."
+
+  # Disk usage
+  local disk_usage=$(df -h "$PROJECT_ROOT" 2>/dev/null | awk 'NR==2 {print $5}' | tr -d '%')
+  local disk_free=$(df -h "$PROJECT_ROOT" 2>/dev/null | awk 'NR==2 {print $4}')
+
+  # Memory usage
+  local mem_total=$(free -m 2>/dev/null | awk '/Mem:/ {print $2}' || echo "0")
+  local mem_used=$(free -m 2>/dev/null | awk '/Mem:/ {print $3}' || echo "0")
+  local mem_pct=$((mem_used * 100 / (mem_total + 1)))
+
+  # Process counts
+  local node_procs=$(pgrep -c node 2>/dev/null || echo "0")
+  local agentic_procs=$(ps aux 2>/dev/null | grep -c "agentic-flow" | grep -v grep || echo "0")
+
+  # CPU load
+  local load_avg=$(cat /proc/loadavg 2>/dev/null | awk '{print $1}' || echo "0")
+
+  # File descriptor usage
+  local fd_used=$(ls /proc/$$/fd 2>/dev/null | wc -l || echo "0")
+
+  # Determine health status
+  local status="healthy"
+  local warnings=""
+
+  if [ "$disk_usage" -gt 90 ]; then
+    status="critical"
+    warnings="$warnings disk_full"
+  elif [ "$disk_usage" -gt 80 ]; then
+    status="warning"
+    warnings="$warnings disk_high"
+  fi
+
+  if [ "$mem_pct" -gt 90 ]; then
+    status="critical"
+    warnings="$warnings memory_full"
+  elif [ "$mem_pct" -gt 80 ]; then
+    [ "$status" != "critical" ] && status="warning"
+    warnings="$warnings memory_high"
+  fi
+
+  # Write health metrics
+  cat > "$HEALTH_FILE" << EOF
+{
+  "status": "$status",
+  "timestamp": "$(date -Iseconds)",
+  "disk": {
+    "usage_pct": $disk_usage,
+    "free": "$disk_free"
+  },
+  "memory": {
+    "total_mb": $mem_total,
+    "used_mb": $mem_used,
+    "usage_pct": $mem_pct
+  },
+  "processes": {
+    "node": $node_procs,
+    "agentic_flow": $agentic_procs
+  },
+  "load_avg": $load_avg,
+  "fd_used": $fd_used,
+  "warnings": "$(echo $warnings | xargs)"
+}
+EOF
+
+  echo "[$(date +%H:%M:%S)] ✓ Health: $status | Disk: ${disk_usage}% | Memory: ${mem_pct}% | Load: $load_avg"
+
+  date +%s > "$LAST_RUN_FILE"
+
+  # Return non-zero if unhealthy
+  [ "$status" = "healthy" ] && return 0 || return 1
+}
+
+case "${1:-check}" in
+  "run") check_health ;;
+  "check") should_run && check_health || echo "[$(date +%H:%M:%S)] Skipping (throttled)" ;;
+  "force") rm -f "$LAST_RUN_FILE"; check_health ;;
+  "status")
+    if [ -f "$HEALTH_FILE" ]; then
+      jq -r '"Status: \(.status) | Disk: \(.disk.usage_pct)% | Memory: \(.memory.usage_pct)% | Load: \(.load_avg)"' "$HEALTH_FILE"
+    else
+      echo "No health data available"
+    fi
+    ;;
+  *) echo "Usage: $0 [run|check|force|status]" ;;
+esac