claude-flow-novice 2.18.6 → 2.18.7

package/.claude/skills/cfn-edit-safety/lib/backup/backup.sh.backup

@@ -1,107 +0,0 @@
-#!/bin/bash
-
-##############################################################################
-# Pre-Edit Backup Script - Creates safe file backups before modifications
-# Version: 1.0.0
-##############################################################################
-
-set -euo pipefail
-
-# Function to create backup of a file before editing
-create_backup() {
-    local file_path="$1"
-    local agent_id="${2:-unknown}"
-    local project_root="${3:-$(pwd)}"
-
-    # Validate inputs
-    if [[ -z "$file_path" ]]; then
-        echo "Error: File path is required" >&2
-        exit 1
-    fi
-
-    # Check if file exists
-    if [[ ! -f "$file_path" ]]; then
-        echo "Warning: File does not exist: $file_path" >&2
-        # Create empty backup path for new files
-        echo "$project_root/.backups/$agent_id/new-file-$(date +%s)-$(echo "$file_path" | tr '/' '_' | tr ' ' '_')"
-        return 0
-    fi
-
-    # Create backup directory structure
-    local backup_dir="$project_root/.backups/$agent_id"
-    local timestamp=$(date +%s)
-    local file_hash=$(md5sum "$file_path" | cut -d' ' -f1)
-    local backup_name="${timestamp}_${file_hash}"
-
-    # Create full backup path
-    local full_backup_path="$backup_dir/$backup_name"
-
-    # Create backup directory
-    mkdir -p "$full_backup_path"
-
-    # Copy original file to backup location
-    cp "$file_path" "$full_backup_path/original"
-
-    # Store backup metadata
-    cat > "$full_backup_path/metadata.json" << EOF
-{
-  "timestamp": "$timestamp",
-  "agent_id": "$agent_id",
-  "original_file": "$file_path",
-  "file_hash": "$file_hash",
-  "backup_path": "$full_backup_path",
-  "created_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-}
-EOF
-
-    # Create revert script
-    cat > "$full_backup_path/revert.sh" << EOF
-#!/bin/bash
-# Revert script for $file_path
-set -euo pipefail
-
-echo "Reverting file: $file_path"
-cp "$full_backup_path/original" "$file_path"
-echo "✅ File reverted successfully"
-EOF
-
-    chmod +x "$full_backup_path/revert.sh"
-
-    # Output backup path for caller
-    echo "$full_backup_path"
-
-    echo "✅ Backup created: $full_backup_path" >&2
-}
-
-# Main execution
-if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
-    # Script called directly
-    if [[ $# -lt 1 ]]; then
-        echo "Usage: $0 <file_path> [--agent-id <id>] [--project-root <path>]" >&2
-        exit 1
-    fi
-
-    file_path="$1"
-    agent_id="unknown"
-    project_root="$(pwd)"
-
-    # Parse optional arguments
-    while [[ $# -gt 0 ]]; do
-        case $1 in
-            --agent-id)
-                agent_id="$2"
-                shift 2
-                ;;
-            --project-root)
-                project_root="$2"
-                shift 2
-                ;;
-            *)
-                # Skip unknown arguments
-                shift
-                ;;
-        esac
-    done
-
-    create_backup "$file_path" "$agent_id" "$project_root"
-fi

package/.claude/skills/cfn-loop-orchestration-v2/lib/coordination/agent-completion.sh.backup

@@ -1,36 +0,0 @@
-#!/bin/bash
-
-# Bash wrapper for TypeScript agent-completion CLI
-# Provides backward compatibility with existing bash-based agent completion
-#
-# Usage:
-#   agent-completion.sh --task-id <id> --agent-id <id> --confidence <score> [options]
-#
-# This wrapper delegates to the TypeScript CLI tool which provides:
-# - Type-safe Redis operations
-# - Test metric tracking (test-driven validation)
-# - Unified namespace handling (swarm/cfn_loop)
-# - Better error handling
-
-set -euo pipefail
-
-# Get the project root
-PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "${PWD}")
-
-# Path to the compiled TypeScript CLI
-CLI_PATH="${PROJECT_ROOT}/dist/cli/agent-completion.js"
-
-# Check if CLI is compiled
-if [ ! -f "$CLI_PATH" ]; then
-    echo "Error: TypeScript CLI not compiled. Run 'npm run build' first." >&2
-    exit 1
-fi
-
-# Ensure Node.js is available
-if ! command -v node &>/dev/null; then
-    echo "Error: Node.js not found. Required to run coordination CLI." >&2
-    exit 1
-fi
-
-# Pass all arguments to the TypeScript CLI
-exec node "$CLI_PATH" "$@"

package/.claude/skills/cfn-loop-orchestration-v2/lib/coordination/coordination-patterns.ts

@@ -1,194 +0,0 @@
-/**
- * CFN Loop Coordination Patterns
- * Implements agent coordination patterns: chain, broadcast, mesh, consensus collection
- */
-
-export interface CoordinationPattern {
-  type: 'chain' | 'broadcast' | 'mesh' | 'consensus';
-  agents: string[];
-  config: Record<string, any>;
-}
-
-export interface CoordinationResult {
-  pattern: string;
-  results: Record<string, any>;
-  consensus?: number;
-  metadata?: Record<string, any>;
-}
-
-/**
- * Chain Pattern: Sequential agent execution
- */
-export class ChainPattern {
-  constructor(private agents: string[]) {}
-
-  async execute(context: any): Promise<CoordinationResult> {
-    const results: Record<string, any> = {};
-
-    for (const agent of this.agents) {
-      // Execute agent with context from previous
-      const result = await this.executeAgent(agent, {
-        ...context,
-        previousResults: results
-      });
-      results[agent] = result;
-    }
-
-    return {
-      pattern: 'chain',
-      results
-    };
-  }
-
-  private async executeAgent(agent: string, context: any): Promise<any> {
-    // Implementation would spawn agent with context
-    // For now, return placeholder
-    return { agent, status: 'executed', context };
-  }
-}
-
-/**
- * Broadcast Pattern: Parallel agent execution with same context
- */
-export class BroadcastPattern {
-  constructor(private agents: string[]) {}
-
-  async execute(context: any): Promise<CoordinationResult> {
-    // Execute all agents in parallel
-    const promises = this.agents.map(agent =>
-      this.executeAgent(agent, context)
-    );
-
-    const agentResults = await Promise.all(promises);
-    const results: Record<string, any> = {};
-
-    this.agents.forEach((agent, index) => {
-      results[agent] = agentResults[index];
-    });
-
-    return {
-      pattern: 'broadcast',
-      results
-    };
-  }
-
-  private async executeAgent(agent: string, context: any): Promise<any> {
-    // Implementation would spawn agent with context
-    return { agent, status: 'executed', context };
-  }
-}
-
-/**
- * Mesh Pattern: Full mesh communication between agents
- */
-export class MeshPattern {
-  constructor(private agents: string[]) {}
-
-  async execute(context: any): Promise<CoordinationResult> {
-    const results: Record<string, any> = {};
-
-    // Each agent communicates with all others
-    for (const agent of this.agents) {
-      const meshContext = {
-        ...context,
-        mesh: {
-          agents: this.agents.filter(a => a !== agent),
-          previousResults: results
-        }
-      };
-
-      results[agent] = await this.executeAgent(agent, meshContext);
-    }
-
-    return {
-      pattern: 'mesh',
-      results
-    };
-  }
-
-  private async executeAgent(agent: string, context: any): Promise<any> {
-    // Implementation would spawn agent with mesh context
-    return { agent, status: 'executed', context };
-  }
-}
-
-/**
- * Consensus Collection Pattern: Collect and aggregate agent opinions
- */
-export class ConsensusPattern {
-  constructor(
-    private agents: string[],
-    private threshold: number = 0.8
-  ) {}
-
-  async execute(context: any): Promise<CoordinationResult> {
-    const results: Record<string, any> = {};
-
-    // Collect opinions from all agents
-    for (const agent of this.agents) {
-      const opinion = await this.collectOpinion(agent, context);
-      results[agent] = opinion;
-    }
-
-    // Calculate consensus
-    const consensus = this.calculateConsensus(results);
-
-    return {
-      pattern: 'consensus',
-      results,
-      consensus,
-      metadata: {
-        threshold: this.threshold,
-        reached: consensus >= this.threshold
-      }
-    };
-  }
-
-  private async collectOpinion(agent: string, context: any): Promise<any> {
-    // Implementation would collect agent's opinion/decision
-    return {
-      agent,
-      opinion: 'approve', // Example
-      confidence: 0.9,
-      reasoning: 'Implementation meets criteria'
-    };
-  }
-
-  private calculateConsensus(results: Record<string, any>): number {
-    const opinions = Object.values(results);
-    if (opinions.length === 0) return 0;
-
-    // Simple consensus calculation based on approval/confidence
-    const approvals = opinions.filter((op: any) => op.opinion === 'approve');
-    const totalConfidence = approvals.reduce((sum: number, op: any) =>
-      sum + (op.confidence || 0), 0);
-
-    return totalConfidence / opinions.length;
-  }
-}
-
-/**
- * Coordination Factory
- */
-export class CoordinationFactory {
-  static create(pattern: CoordinationPattern) {
-    switch (pattern.type) {
-      case 'chain':
-        return new ChainPattern(pattern.agents);
-      case 'broadcast':
-        return new BroadcastPattern(pattern.agents);
-      case 'mesh':
-        return new MeshPattern(pattern.agents);
-      case 'consensus':
-        return new ConsensusPattern(
-          pattern.agents,
-          pattern.config.threshold || 0.8
-        );
-      default:
-        throw new Error(`Unknown coordination pattern: ${pattern.type}`);
-    }
-  }
-}
-
-// Export type definitions
-export type { CoordinationPattern, CoordinationResult };

package/.claude/skills/cfn-loop-orchestration-v2/lib/coordination/coordination-signal.sh.backup

@@ -1,36 +0,0 @@
-#!/bin/bash
-
-# Bash wrapper for TypeScript coordination-signal CLI
-# Provides backward compatibility with existing bash-based coordination
-#
-# Usage:
-#   coordination-signal.sh --task-id <id> --channel <ch> --message <msg> [options]
-#
-# This wrapper delegates to the TypeScript CLI tool which provides:
-# - Type-safe Redis operations
-# - Unified namespace handling (swarm/cfn_loop)
-# - Automatic timeout management
-# - Better error handling
-
-set -euo pipefail
-
-# Get the project root
-PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "${PWD}")
-
-# Path to the compiled TypeScript CLI
-CLI_PATH="${PROJECT_ROOT}/dist/cli/coordination-signal.js"
-
-# Check if CLI is compiled
-if [ ! -f "$CLI_PATH" ]; then
-    echo "Error: TypeScript CLI not compiled. Run 'npm run build' first." >&2
-    exit 1
-fi
-
-# Ensure Node.js is available
-if ! command -v node &>/dev/null; then
-    echo "Error: Node.js not found. Required to run coordination CLI." >&2
-    exit 1
-fi
-
-# Pass all arguments to the TypeScript CLI
-exec node "$CLI_PATH" "$@"

package/.claude/skills/cfn-loop-orchestration-v2/lib/coordination/coordination-wait.sh.backup

@@ -1,36 +0,0 @@
-#!/bin/bash
-
-# Bash wrapper for TypeScript coordination-wait CLI
-# Provides backward compatibility with existing bash-based coordination
-#
-# Usage:
-#   coordination-wait.sh --task-id <id> --channel <ch> [--timeout <sec>]
-#
-# This wrapper delegates to the TypeScript CLI tool which provides:
-# - Type-safe Redis blocking operations
-# - Unified namespace handling (swarm/cfn_loop)
-# - Automatic timeout management
-# - Better error handling
-
-set -euo pipefail
-
-# Get the project root
-PROJECT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null || echo "${PWD}")
-
-# Path to the compiled TypeScript CLI
-CLI_PATH="${PROJECT_ROOT}/dist/cli/coordination-wait.js"
-
-# Check if CLI is compiled
-if [ ! -f "$CLI_PATH" ]; then
-    echo "Error: TypeScript CLI not compiled. Run 'npm run build' first." >&2
-    exit 1
-fi
-
-# Ensure Node.js is available
-if ! command -v node &>/dev/null; then
-    echo "Error: Node.js not found. Required to run coordination CLI." >&2
-    exit 1
-fi
-
-# Pass all arguments to the TypeScript CLI
-exec node "$CLI_PATH" "$@"

package/.claude/skills/cfn-loop-orchestration-v2/lib/coordination/index.ts

@@ -1,25 +0,0 @@
-/**
- * CFN Loop Coordination Module Index
- * Exports all coordination patterns and utilities
- */
-
-export {
-  ChainPattern,
-  BroadcastPattern,
-  MeshPattern,
-  ConsensusPattern,
-  CoordinationFactory,
-  type CoordinationPattern,
-  type CoordinationResult
-} from './coordination-patterns';
-
-// Re-export Redis coordination from orchestrator
-export { RedisCoordinator } from '../orchestrator/dist/redis/redis-coordinator';
-
-// Convenience exports
-export const Patterns = {
-  CHAIN: 'chain' as const,
-  BROADCAST: 'broadcast' as const,
-  MESH: 'mesh' as const,
-  CONSENSUS: 'consensus' as const
-};