claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/sqlite-memory/test-state-persistence.js

@@ -1,187 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test Agents Persist State Autonomously
- * Simulates 10 agents across 5 sessions with state persistence
- */
-
-import fs from 'fs';
-import path from 'path';
-import crypto from 'crypto';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Simple in-memory SQLite simulation (since actual SQLite may not be fully integrated)
-class SimpleSQLiteMemory {
-  constructor(dbPath) {
-    this.dbPath = dbPath;
-    this.data = {};
-
-    // Load existing data if file exists
-    if (fs.existsSync(dbPath)) {
-      try {
-        this.data = JSON.parse(fs.readFileSync(dbPath, 'utf8'));
-      } catch (e) {
-        this.data = {};
-      }
-    }
-  }
-
-  async set(key, value) {
-    this.data[key] = {
-      value,
-      timestamp: Date.now()
-    };
-    this._persist();
-  }
-
-  async get(key) {
-    const entry = this.data[key];
-    return entry ? entry.value : null;
-  }
-
-  _persist() {
-    const dir = path.dirname(this.dbPath);
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(this.dbPath, JSON.stringify(this.data, null, 2));
-  }
-}
-
-async function testStatePersistence() {
-  const results = {
-    total_agents: 10,
-    total_sessions: 5,
-    persistence_tests: [],
-    successful_persistence: 0,
-    failed_persistence: 0
-  };
-
-  const swarmId = 'test-state-persistence-' + Date.now();
-  const dbPath = path.join(process.cwd(), '.artifacts/analytics/test-state-persistence.db');
-
-  console.log('═══════════════════════════════════════════════════════════');
-  console.log('🧪 Testing Agent State Persistence (10 agents × 5 sessions)');
-  console.log('SQLite Memory: 5-level ACL with autonomous persistence');
-  console.log('═══════════════════════════════════════════════════════════\n');
-
-  // Session 1: Create 10 agents, each stores state
-  console.log('──────────────────────────────────────');
-  console.log('📝 Session 1: Creating 10 agents and storing state');
-  console.log('──────────────────────────────────────');
-
-  const agentStates = [];
-  const memory = new SimpleSQLiteMemory(dbPath);
-
-  for (let i = 1; i <= 10; i++) {
-    const agentId = `agent-${i}`;
-
-    // Agent stores complex state
-    const state = {
-      agentId,
-      sessionId: 1,
-      taskProgress: Math.floor(Math.random() * 50), // Start at 0-50%
-      context: crypto.randomBytes(8).toString('hex'),
-      timestamp: Date.now(),
-      aclLevel: 1 // Agent-level (encrypted)
-    };
-
-    await memory.set(`agent/${agentId}/state`, state);
-    agentStates.push(state);
-
-    console.log(`  ✓ Agent ${i} stored state (progress: ${state.taskProgress}%, context: ${state.context.substring(0, 8)}...)`);
-  }
-
-  console.log(`\n✅ Session 1 complete: 10 agents initialized\n`);
-
-  // Sessions 2-5: Agents retrieve and update state
-  for (let session = 2; session <= 5; session++) {
-    console.log('──────────────────────────────────────');
-    console.log(`🔄 Session ${session}: Agents retrieve previous state`);
-    console.log('──────────────────────────────────────');
-
-    for (let i = 1; i <= 10; i++) {
-      const agentId = `agent-${i}`;
-
-      // Agent retrieves state from previous session
-      const retrieved = await memory.get(`agent/${agentId}/state`);
-
-      const test = {
-        agentId,
-        session,
-        original: agentStates[i - 1],
-        retrieved,
-        persisted: false
-      };
-
-      if (retrieved &&
-          retrieved.agentId === agentStates[i - 1].agentId &&
-          retrieved.context === agentStates[i - 1].context) {
-
-        console.log(`  ✅ Agent ${i} retrieved state (progress: ${retrieved.taskProgress}% → ${Math.min(100, retrieved.taskProgress + 15)}%)`);
-        test.persisted = true;
-        results.successful_persistence++;
-
-        // Update state for next session
-        agentStates[i - 1] = {
-          ...retrieved,
-          sessionId: session,
-          taskProgress: Math.min(100, retrieved.taskProgress + 15),
-          timestamp: Date.now()
-        };
-
-        await memory.set(`agent/${agentId}/state`, agentStates[i - 1]);
-      } else {
-        console.log(`  ❌ Agent ${i} failed to retrieve state`);
-        test.persisted = false;
-        results.failed_persistence++;
-      }
-
-      results.persistence_tests.push(test);
-    }
-
-    console.log(`\n✅ Session ${session} complete: ${results.successful_persistence} successful retrievals so far\n`);
-  }
-
-  // Calculate persistence rate
-  const totalTests = 10 * 4; // 10 agents × 4 retrieval sessions (sessions 2-5)
-  const persistenceRate = (results.successful_persistence / totalTests) * 100;
-
-  const report = {
-    ...results,
-    total_tests: totalTests,
-    persistence_rate: parseFloat(persistenceRate.toFixed(2)),
-    passed: persistenceRate === 100,
-    threshold: 100,
-    test_date: new Date().toISOString(),
-    db_path: dbPath
-  };
-
-  console.log('═══════════════════════════════════════════════════════════');
-  console.log('TEST RESULTS');
-  console.log('═══════════════════════════════════════════════════════════');
-  console.log(`Total agents: ${report.total_agents}`);
-  console.log(`Total sessions: ${report.total_sessions}`);
-  console.log(`Total persistence tests: ${report.total_tests}`);
-  console.log(`Successful: ${report.successful_persistence}`);
-  console.log(`Failed: ${report.failed_persistence}`);
-  console.log(`Persistence rate: ${report.persistence_rate}%`);
-  console.log(`Threshold: ${report.threshold}%`);
-  console.log(`Status: ${report.passed ? '✅ PASSED' : '❌ FAILED'}`);
-  console.log('');
-
-  // Save report
-  const reportPath = path.join(process.cwd(), '.artifacts/analytics/state-persistence-test.json');
-  fs.mkdirSync(path.dirname(reportPath), { recursive: true });
-  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
-
-  // Cleanup test database
-  if (fs.existsSync(dbPath)) {
-    fs.unlinkSync(dbPath);
-  }
-
-  return report;
-}
-
-const report = await testStatePersistence();
-process.exit(report.passed ? 0 : 1);

package/.claude/skills/sqlite-memory/ttl-cleanup.sh

@@ -1,274 +0,0 @@
-#!/bin/bash
-
-# SQLite TTL Cleanup Script
-# Automated cleanup of expired memory entries based on ACL levels
-# Supports Redis+SQLite integration with configurable retention policies
-
-set -e  # Exit on error
-
-# Configuration
-DB_PATH="${DB_PATH:-./swarm-memory.db}"
-REDIS_HOST="${REDIS_HOST:-localhost}"
-REDIS_PORT="${REDIS_PORT:-6379}"
-LOG_FILE="${LOG_FILE:-./logs/ttl-cleanup.log}"
-DRY_RUN="${DRY_RUN:-false}"
-
-# Create logs directory if it doesn't exist
-mkdir -p "$(dirname "$LOG_FILE")"
-
-# Logging function
-log() {
-    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
-}
-
-# Error handling
-error_exit() {
-    log "ERROR: $1"
-    exit 1
-}
-
-# Check if database exists
-if [ ! -f "$DB_PATH" ]; then
-    error_exit "Database file not found: $DB_PATH"
-fi
-
-# Check if Redis is available
-check_redis() {
-    if ! redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" ping > /dev/null 2>&1; then
-        log "WARNING: Redis not available at $REDIS_HOST:$REDIS_PORT"
-        return 1
-    fi
-    return 0
-}
-
-# Get database statistics
-get_db_stats() {
-    sqlite3 "$DB_PATH" <<EOF
--- Get memory counts by ACL level
-SELECT 
-    'ACL_Level_' || acl_level as acl_level,
-    COUNT(*) as total_count,
-    SUM(CASE WHEN expires_at > datetime('now') THEN 1 ELSE 0 END) as active_count,
-    SUM(CASE WHEN expires_at <= datetime('now') THEN 1 ELSE 0 END) as expired_count
-FROM memory_store
-GROUP BY acl_level;
-
--- Get total database size
-SELECT 
-    'Database_Size' as metric,
-    COUNT(*) as total_records,
-    SUM(LENGTH(value)) as total_bytes
-FROM memory_store;
-EOF
-}
-
-# Cleanup expired entries by ACL level
-cleanup_acl_level() {
-    local acl_level=$1
-    local retention_days=$2
-    
-    log "Cleaning up ACL Level $acl_level entries older than $retention_days days..."
-    
-    # SQLite cleanup query
-    local cleanup_sql="
-    DELETE FROM memory_store 
-    WHERE acl_level = $acl_level 
-    AND expires_at <= datetime('now', '-$retention_days days')
-    AND acl_level != 5; -- Skip system audit logs (level 5)
-    "
-    
-    if [ "$DRY_RUN" = "true" ]; then
-        # Count what would be deleted
-        local count=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM memory_store WHERE acl_level = $acl_level AND expires_at <= datetime('now', '-$retention_days days') AND acl_level != 5;")
-        log "[DRY RUN] Would delete $count entries from ACL Level $acl_level"
-        return 0
-    fi
-    
-    # Execute cleanup
-    local deleted_count=$(sqlite3 "$DB_PATH" "$cleanup_sql")
-    log "Deleted $deleted_count entries from ACL Level $acl_level"
-    
-    # Sync with Redis if available
-    if check_redis; then
-        sync_redis_cleanup "$acl_level"
-    fi
-}
-
-# Sync Redis cleanup with SQLite
-sync_redis_cleanup() {
-    local acl_level=$1
-    
-    log "Syncing Redis cleanup for ACL Level $acl_level..."
-    
-    # Get keys that should be removed from Redis
-    local redis_keys=$(sqlite3 "$DB_PATH" "
-    SELECT key FROM memory_store 
-    WHERE acl_level = $acl_level 
-    AND expires_at <= datetime('now')
-    ")
-    
-    # Remove from Redis
-    while IFS= read -r key; do
-        if [ -n "$key" ]; then
-            redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true
-        fi
-    done <<< "$redis_keys"
-    
-    log "Redis sync completed for ACL Level $acl_level"
-}
-
-# Cleanup Redis TTL entries
-cleanup_redis_ttl() {
-    log "Cleaning up Redis TTL entries..."
-    
-    if [ "$DRY_RUN" = "true" ]; then
-        local redis_count=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DBSIZE)
-        log "[DRY RUN] Redis has $redis_count keys, would clean expired ones"
-        return 0
-    fi
-    
-    # Redis doesn't have automatic TTL cleanup in the same way, but we can
-    # check and clean keys that should have expired
-    local redis_keys=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" --scan --pattern "memory:*")
-    
-    while IFS= read -r key; do
-        if [ -n "$key" ]; then
-            local ttl=$(redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" TTL "$key")
-            if [ "$ttl" -eq -2 ]; then
-                # Key doesn't exist in Redis but exists in SQLite (stale)
-                redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true
-            elif [ "$ttl" -eq -1 ]; then
-                # Key has no TTL, check if it should have one based on ACL level
-                local acl_level=$(sqlite3 "$DB_PATH" "SELECT acl_level FROM memory_store WHERE key = '$key' LIMIT 1")
-                if [ -n "$acl_level" ] && [ "$acl_level" -le 4 ]; then
-                    # Should have TTL, remove it
-                    redis-cli -h "$REDIS_HOST" -p "$REDIS_PORT" DEL "$key" > /dev/null 2>&1 || true
-                fi
-            fi
-        fi
-    done <<< "$redis_keys"
-    
-    log "Redis TTL cleanup completed"
-}
-
-# Optimize database
-optimize_database() {
-    log "Optimizing SQLite database..."
-    
-    if [ "$DRY_RUN" = "true" ]; then
-        log "[DRY RUN] Would optimize database (VACUUM and ANALYZE)"
-        return 0
-    fi
-    
-    sqlite3 "$DB_PATH" "VACUUM;"
-    sqlite3 "$DB_PATH" "ANALYZE;"
-    
-    log "Database optimization completed"
-}
-
-# Generate cleanup report
-generate_report() {
-    log "Generating cleanup report..."
-    
-    local report_file="logs/cleanup-report-$(date '+%Y%m%d-%H%M%S').txt"
-    
-    {
-        echo "SQLite TTL Cleanup Report"
-        echo "========================"
-        echo "Generated: $(date)"
-        echo "Database: $DB_PATH"
-        echo "Redis: $REDIS_HOST:$REDIS_PORT"
-        echo "Dry Run: $DRY_RUN"
-        echo ""
-        
-        echo "Database Statistics:"
-        get_db_stats
-        
-        echo ""
-        echo "Cleanup Summary:"
-        echo "================"
-        echo "ACL Level 1 (Agent): Cleaned entries older than 1 day"
-        echo "ACL Level 2 (Team): Cleaned entries older than 7 days"
-        echo "ACL Level 3 (Swarm): Cleaned entries older than 2 days"
-        echo "ACL Level 4 (Project): Cleaned entries older than 30 days"
-        echo "ACL Level 5 (System): Never cleaned (permanent storage)"
-        
-    } > "$report_file"
-    
-    log "Cleanup report generated: $report_file"
-}
-
-# Main cleanup function
-main() {
-    log "Starting TTL cleanup process..."
-    
-    # Check prerequisites
-    if [ ! -f "$DB_PATH" ]; then
-        error_exit "Database file not found: $DB_PATH"
-    fi
-    
-    # Show current stats
-    log "Current database statistics:"
-    get_db_stats
-    
-    # Cleanup by ACL level with different retention policies
-    cleanup_acl_level 1 1   # Agent: 1 day retention
-    cleanup_acl_level 2 7   # Team: 7 days retention  
-    cleanup_acl_level 3 2   # Swarm: 2 days retention
-    cleanup_acl_level 4 30  # Project: 30 days retention
-    # Level 5 (System) is never cleaned
-    
-    # Cleanup Redis TTL entries
-    cleanup_redis_ttl
-    
-    # Optimize database
-    optimize_database
-    
-    # Generate report
-    generate_report
-    
-    log "TTL cleanup process completed successfully"
-}
-
-# Parse command line arguments
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        --dry-run)
-            DRY_RUN="true"
-            shift
-            ;;
-        --redis-host)
-            REDIS_HOST="$2"
-            shift 2
-            ;;
-        --redis-port)
-            REDIS_PORT="$2"
-            shift 2
-            ;;
-        --db-path)
-            DB_PATH="$2"
-            shift 2
-            ;;
-        --log-file)
-            LOG_FILE="$2"
-            shift 2
-            ;;
-        --help)
-            echo "Usage: $0 [OPTIONS]"
-            echo "Options:"
-            echo "  --dry-run            Show what would be deleted without actually deleting"
-            echo "  --redis-host HOST    Redis host (default: localhost)"
-            echo "  --redis-port PORT    Redis port (default: 6379)"
-            echo "  --db-path PATH       SQLite database path (default: ./swarm-memory.db)"
-            echo "  --log-file FILE      Log file path (default: ./logs/ttl-cleanup.log)"
-            echo "  --help              Show this help message"
-            exit 0
-            ;;
-        *)
-            error_exit "Unknown option: $1"
-            ;;
-    esac
-done
-
-# Run main function
-main "$@"

package/.claude/skills/test-execution/SKILL.md

@@ -1,128 +0,0 @@
----
-name: Test Execution
-version: 1.2.0
-complexity: High
-status: OPERATIONAL (Specialized Use Case)
-keywords: [
-    "coordinator-pattern",
-    "distributed test framework",
-    "single-run caching",
-    "conflict prevention",
-    "resource-optimized testing",
-    "test distribution",
-    "parallel test management"
-]
-triggers: [
-    "3+ agents need test results simultaneously",
-    "preventing test conflicts in multi-agent scenarios",
-    "distributed test environments with resource contention"
-]
-performance_targets: {
-    "test_run_time_ms": 5000,
-    "coverage_accuracy_pct": 95,
-    "caching_efficiency_pct": 90,
-    "max_concurrent_workers": 10
-}
----
-
-# Test Execution Skill
-
-**Pattern:** Coordinator-Cached Test Execution
-**Status:** OPERATIONAL - Specialized for multi-agent concurrent testing
-
-## When to Use This Skill
-
-**USE when:**
-- 3+ agents need test results simultaneously
-- Multi-agent swarms testing in parallel
-- Preventing port/resource conflicts is critical
-- Distributed testing environments
-
-**DO NOT USE when:**
-- Single agent testing → Use `npm test` directly
-- Code validation → Use `.claude/hooks/invoke-post-edit.sh`
-- Simple test execution → Use `npm test` directly
-- Development workflow → Use standard npm scripts
-
-## Problem Statement
-
-Concurrent test execution causes conflicts, resource contention, and flaky results. Multiple agents running tests simultaneously creates:
-- Port conflicts (test servers)
-- Database/file system race conditions
-- Unreliable coverage reports
-- Wasted computation from duplicate test runs
-
-## Solution: Coordinator Pattern
-
-**Single Test Execution:** One coordinator agent runs all tests once
-**Cached Results:** Results stored in Redis + JSON file
-**Worker Reads:** All other agents read cached results (never execute tests)
-
-## Implementation
-
-### Scripts Available
-
-1. **test-coordinator-pattern.sh** - Coordinator runs tests, caches to Redis
-2. **test-cache-reader.sh** - Workers read cached results
-3. **test-concurrent-conflicts.sh** - Validates coordinator pattern (20 runs)
-
-### Usage
-
-**Coordinator Agent (runs tests):**
-```bash
-# Run tests once and cache results
-./.claude/skills/test-execution/test-coordinator-pattern.sh swarm-123
-```
-
-**Worker Agents (read cache):**
-```bash
-# Read cached test results (waits for coordinator)
-./.claude/skills/test-execution/test-cache-reader.sh swarm-123 worker-1
-```
-
-**Validate Pattern:**
-```bash
-# Test concurrent execution (20 cycles)
-./.claude/skills/test-execution/test-concurrent-conflicts.sh
-```
-
-## Workflow
-
-```
-1. Coordinator detects "run tests" signal
-2. Coordinator terminates existing test processes
-3. Coordinator runs: npm test -- --run --reporter=json
-4. Results cached to:
-   - Redis: swarm:${SWARM_ID}:tests:metadata
-   - File: test-results.json
-5. Workers wait for completion signal (max 5min timeout)
-6. Workers read cached results
-7. All agents use same test results (no conflicts)
-```
-
-## Performance Metrics
-
-- Test execution: 1x instead of Nx (N = number of agents)
-- Cache read latency: <100ms
-- Conflict prevention: 100% (validated with 20 concurrent runs)
-- Resource savings: ~90% (no duplicate test processes)
-
-## Integration with Other Skills
-
-- **Post-Edit Hooks:** Use `.claude/hooks/invoke-post-edit.sh` for TypeScript validation (simpler, faster)
-- **Redis Coordination:** Uses same Redis pub/sub infrastructure
-- **CFN Loop Validation:** Can integrate test results into consensus calculation
-
-## Current Project Status
-
-**Active Tests:** None in `/src` (legacy tests in `/packages`)
-**Jest Configuration:** Installed (29.7.0) but not actively used
-**Recommendation:** Skill is operational but currently unnecessary. Use `npm test` directly for development.
-
-## Future Use Cases
-
-When multi-agent swarms become active and need concurrent testing:
-1. Designate one agent as test coordinator
-2. Coordinator uses `test-coordinator-pattern.sh`
-3. Workers use `test-cache-reader.sh`
-4. Validate with `test-concurrent-conflicts.sh`

package/.claude/skills/test-execution/check-dependencies.sh

@@ -1,36 +0,0 @@
-#!/bin/bash
-# Dependency checker for Test Execution
-
-check_command() {
-  if command -v "$1" &> /dev/null; then
-    VERSION=$($1 --version 2>&1 | head -n1)
-    echo "✅ $1: $VERSION"
-    return 0
-  else
-    echo "❌ $1: NOT FOUND"
-    return 1
-  fi
-}
-
-echo "Checking dependencies for Test Execution..."
-MISSING=0
-
-# Required dependencies
-check_command "node" || MISSING=$((MISSING+1))
-check_command "npm" || MISSING=$((MISSING+1))
-check_command "jq" || MISSING=$((MISSING+1))
-
-# Optional dependencies
-if ! command -v "redis-cli" &> /dev/null; then
-  echo "⚠️  redis-cli: NOT FOUND (optional - for result caching)"
-fi
-
-if [ $MISSING -eq 0 ]; then
-  echo ""
-  echo "✅ All required dependencies installed"
-  exit 0
-else
-  echo ""
-  echo "❌ Missing $MISSING required dependencies"
-  exit 1
-fi