claude-flow-novice 2.18.5 → 2.18.7

package/.claude/skills/cfn-local-ruvector-accelerator/test-local-ruvector.sh

@@ -0,0 +1,250 @@
+#!/bin/bash
+# test-local-ruvector.sh - Test Local RuVector implementation
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+STORAGE_PATH="${HOME}/.local-ruvector-test"
+TEST_DIR="/tmp/ruvector-test-project"
+
+echo "🧪 Testing Local RuVector Accelerator..."
+
+# Clean up previous test
+rm -rf "$STORAGE_PATH" "$TEST_DIR"
+mkdir -p "$TEST_DIR"
+
+# Create test code files
+echo "📝 Creating test code files..."
+
+# Rust file
+cat > "$TEST_DIR/auth.rs" << 'EOF'
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct User {
+    pub id: String,
+    pub email: String,
+    pub roles: Vec<String>,
+}
+
+pub struct AuthService {
+    users: HashMap<String, User>,
+}
+
+impl AuthService {
+    pub fn new() -> Self {
+        Self {
+            users: HashMap::new(),
+        }
+    }
+    
+    pub fn authenticate(&self, email: &str, password: &str) -> Option<&User> {
+        // In real implementation, verify password hash
+        self.users.values().find(|user| user.email == email)
+    }
+    
+    pub fn authorize(&self, user: &User, required_role: &str) -> bool {
+        user.roles.contains(&required_role.to_string())
+    }
+}
+
+pub fn create_jwt_token(user: &User) -> Result<String, AuthError> {
+    // JWT creation logic
+    Ok(format!("token_for_{}", user.id))
+}
+
+#[derive(Debug)]
+pub enum AuthError {
+    InvalidCredentials,
+    TokenExpired,
+    Unauthorized,
+}
+EOF
+
+# Python file
+cat > "$TEST_DIR/database.py" << 'EOF'
+import sqlite3
+from typing import Optional, List, Dict, Any
+from dataclasses import dataclass
+from contextlib import contextmanager
+
+@dataclass
+class DatabaseConfig:
+    path: str
+    pool_size: int = 5
+    timeout: float = 30.0
+
+class DatabaseManager:
+    def __init__(self, config: DatabaseConfig):
+        self.config = config
+        self._pool = []
+        
+    @contextmanager
+    def get_connection(self):
+        conn = sqlite3.connect(self.config.path)
+        conn.row_factory = sqlite3.Row
+        try:
+            yield conn
+        finally:
+            conn.close()
+            
+    def create_tables(self):
+        with self.get_connection() as conn:
+            conn.executescript("""
+                CREATE TABLE IF NOT EXISTS users (
+                    id INTEGER PRIMARY KEY,
+                    email TEXT UNIQUE NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                );
+                CREATE TABLE IF NOT EXISTS sessions (
+                    token TEXT PRIMARY KEY,
+                    user_id INTEGER,
+                    expires_at TIMESTAMP,
+                    FOREIGN KEY (user_id) REFERENCES users (id)
+                );
+            """)
+            
+    def get_user_by_email(self, email: str) -> Optional[Dict[str, Any]]:
+        with self.get_connection() as conn:
+            cursor = conn.execute(
+                "SELECT * FROM users WHERE email = ?", (email,)
+            )
+            return dict(cursor.fetchone()) if cursor.fetchone() else None
+EOF
+
+# JavaScript file
+cat > "$TEST_DIR/api.js" << 'EOF'
+const express = require('express');
+const jwt = require('jsonwebtoken');
+
+class APIError extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+
+class AuthMiddleware {
+    constructor(secretKey) {
+        this.secretKey = secretKey;
+    }
+    
+    verifyToken(req, res, next) {
+        const token = req.headers.authorization?.split(' ')[1];
+        
+        if (!token) {
+            throw new APIError(401, 'No token provided');
+        }
+        
+        try {
+            const decoded = jwt.verify(token, this.secretKey);
+            req.user = decoded;
+            next();
+        } catch (error) {
+            throw new APIError(401, 'Invalid token');
+        }
+    }
+    
+    requireRole(role) {
+        return (req, res, next) => {
+            if (!req.user.roles.includes(role)) {
+                throw new APIError(403, 'Insufficient permissions');
+            }
+            next();
+        };
+    }
+}
+
+const rateLimit = require('express-rate-limit');
+const createRateLimit = (windowMs, max) => rateLimit({
+    windowMs,
+    max,
+    message: 'Too many requests'
+});
+
+module.exports = { APIError, AuthMiddleware, createRateLimit };
+EOF
+
+echo "✅ Test files created"
+
+# Initialize Local RuVector
+echo ""
+echo "🚀 Initializing Local RuVector..."
+STORAGE_PATH="$STORAGE_PATH" "$SCRIPT_DIR/init-local-ruvector.sh"
+
+# Index test files
+echo ""
+echo "📊 Indexing test files..."
+"$SCRIPT_DIR/index-code.sh" --path "$TEST_DIR" --verbose
+
+# Test queries
+echo ""
+echo "🔍 Testing queries..."
+
+# Test 1: Search for authentication patterns
+echo ""
+echo "Test 1: Searching 'authentication middleware'..."
+"$SCRIPT_DIR/query-local.sh" --pattern "authentication middleware" --limit 3
+
+# Test 2: Search for Rust-specific patterns
+echo ""
+echo "Test 2: Searching Rust error handling..."
+"$SCRIPT_DIR/query-local.sh" --pattern "error handling" --file-type rs --limit 2
+
+# Test 3: JSON output
+echo ""
+echo "Test 3: JSON output for database patterns..."
+"$SCRIPT_DIR/query-local.sh" --pattern "database connection" --json | head -20
+
+# Test 4: Show content
+echo ""
+echo "Test 4: Pattern with content..."
+"$SCRIPT_DIR/query-local.sh" --pattern "JWT token" --show-content --limit 1 | head -30
+
+# Performance test
+echo ""
+echo "⚡ Performance test..."
+start_time=$(date +%s%N)
+for i in {1..10}; do
+    "$SCRIPT_DIR/query-local.sh" --pattern "auth" --limit 1 > /dev/null
+done
+end_time=$(date +%s%N)
+duration=$((($end_time - $start_time) / 1000000))
+avg_time=$(($duration / 10))
+
+echo "Average query time: ${avg_time}ms"
+
+# Show stats
+echo ""
+echo "📈 Final statistics:"
+cd "$SCRIPT_DIR"
+python3 -c "
+from search_engine_v2 import SearchEngine
+engine = SearchEngine('${STORAGE_PATH}/storage')
+stats = engine.get_stats()
+print(f'Total patterns: {stats[\"total_patterns\"]}')
+print(f'Average success rate: {stats[\"avg_success_rate\"]:.2f}')
+print(f'Total usage: {stats[\"total_usage\"]}')
+print(f'Unique file types: {stats[\"unique_file_types\"]}')
+"
+
+# Cleanup
+echo ""
+echo "🧹 Cleaning up test data..."
+rm -rf "$STORAGE_PATH" "$TEST_DIR"
+
+echo ""
+echo "✅ All tests passed!"
+echo ""
+echo "📋 Summary:"
+echo "   - Initialization: ✓"
+echo "   - Code indexing: ✓"
+echo "   - Pattern search: ✓"
+echo "   - File type filtering: ✓"
+echo "   - JSON output: ✓"
+echo "   - Content display: ✓"
+echo "   - Performance: ${avg_time}ms avg query time"
+
+# Make script executable
+chmod +x "${BASH_SOURCE[0]}"

package/.claude/skills/cfn-loop-orchestration

@@ -0,0 +1 @@
+cfn-loop-orchestration-v2/lib/orchestrator

package/.claude/skills/cfn-loop-orchestration-v2/cli/cfn-orchestrator.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * CFN Loop Orchestrator - Main CLI Entry Point
+ * Simplified CLI that matches the documented interface
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Resolve paths
+const skillDir = path.dirname(__dirname);
+const orchestratorCli = path.join(skillDir, 'lib/orchestrator/dist/cli/orchestrator-cli.js');
+
+/**
+ * Execute orchestrator with all arguments
+ */
+function execute(args) {
+  // Validate orchestrator exists
+  if (!require('fs').existsSync(orchestratorCli)) {
+    console.error(`Error: Orchestrator CLI not found at ${orchestratorCli}`);
+    console.error('Please build the orchestrator first: cd lib/orchestrator && npm run build');
+    process.exit(1);
+  }
+
+  // Spawn orchestrator
+  const child = spawn('node', [orchestratorCli, ...args], {
+    stdio: 'inherit',
+    cwd: skillDir
+  });
+
+  // Handle exit
+  child.on('exit', (code) => {
+    process.exit(code || 0);
+  });
+
+  // Handle errors
+  child.on('error', (err) => {
+    console.error(`Failed to execute orchestrator: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// Export for module use
+module.exports = { execute };
+
+// Execute if run directly
+if (require.main === module) {
+  execute(process.argv.slice(2));
+}

package/.claude/skills/cfn-loop-orchestration-v2/cli/orchestrate.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# CFN Loop Orchestration CLI Wrapper
+# Bash wrapper that routes to the TypeScript implementation
+
+set -euo pipefail
+
+# Get skill directory
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+SKILL_DIR="$(dirname "$SCRIPT_DIR")"
+
+# Paths
+CLI_RESOLVER="$SCRIPT_DIR/resolve-provider-model.cjs"
+
+# Check if resolver exists
+if [[ ! -f "$CLI_RESOLVER" ]]; then
+  echo "Error: CLI resolver not found at $CLI_RESOLVER" >&2
+  exit 1
+fi
+
+# Execute with node
+exec node "$CLI_RESOLVER" "$@"

package/.claude/skills/cfn-loop-orchestration-v2/cli/resolve-provider-model.cjs

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+/**
+ * CFN Loop Orchestration - CLI Provider Resolver
+ * Wrapper for the TypeScript orchestrator CLI with provider routing
+ *
+ * Version: 1.0.0
+ * Purpose: Resolves provider and routes to orchestrator-cli
+ */
+
+const { spawn } = require('child_process');
+const path = require('path');
+
+// Resolve paths
+const skillDir = path.dirname(__dirname);
+const orchestratorCli = path.join(skillDir, 'lib/orchestrator/dist/cli/orchestrator-cli.js');
+
+/**
+ * Parse environment variables for provider routing
+ */
+function resolveProvider() {
+  const customRouting = process.env.CFN_CUSTOM_ROUTING;
+  if (!customRouting || customRouting !== 'true') {
+    return 'zai'; // Default
+  }
+
+  const provider = process.argv.find(arg => arg.startsWith('--provider='))?.split('=')[1];
+  return provider || process.env.CFN_DEFAULT_PROVIDER || 'zai';
+}
+
+/**
+ * Execute orchestrator with resolved provider
+ */
+function executeOrchestrator() {
+  const provider = resolveProvider();
+
+  // Add provider to environment
+  const env = { ...process.env, CFN_PROVIDER: provider };
+
+  // Build argument list
+  const args = process.argv.slice(2);
+
+  console.error(`[cfn-loop-orchestration] Provider resolved to: ${provider}`);
+  console.error(`[cfn-loop-orchestration] Executing: ${orchestratorCli} ${args.join(' ')}`);
+
+  // Spawn orchestrator
+  const child = spawn('node', [orchestratorCli, ...args], {
+    env,
+    stdio: 'inherit',
+    cwd: skillDir
+  });
+
+  // Handle exit
+  child.on('exit', (code) => {
+    process.exit(code);
+  });
+
+  // Handle errors
+  child.on('error', (err) => {
+    console.error(`[cfn-loop-orchestration] Failed to execute orchestrator: ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// Execute if run directly
+if (require.main === module) {
+  executeOrchestrator();
+}
+
+module.exports = { resolveProvider, executeOrchestrator };

package/.claude/skills/cfn-loop-orchestration-v2/lib/orchestrator/src/agent-spawner/agent-spawner.ts

@@ -0,0 +1,34 @@
+/**
+ * Agent spawner implementation
+ * Spawns specialized agents for loop execution
+ */
+
+import { AgentSpec, ExecutionMode } from '../types';
+
+/**
+ * Agent spawner class - placeholder for migration
+ */
+export class AgentSpawner {
+  /**
+   * Spawn agents for a specific loop and wave
+   */
+  static async spawnAgents(
+    taskId: string,
+    loopNumber: number,
+    agentCount: number,
+    _mode: ExecutionMode
+  ): Promise<AgentSpec[]> {
+    const agents: AgentSpec[] = [];
+
+    for (let i = 0; i < agentCount; i++) {
+      agents.push({
+        id: `${taskId}-loop${loopNumber}-agent${i}`,
+        type: `loop${loopNumber}-agent`,
+        memoryTier: 2,
+        memoryLimit: '1g',
+      });
+    }
+
+    return agents;
+  }
+}