claude-flow-novice 2.18.5 → 2.18.7

package/.claude/settings.playwright.json

@@ -0,0 +1,198 @@
+{
+  "mcpServers": {
+    "playwright": {
+      "command": "docker",
+      "args": [
+        "run", "-i", "--rm", "--init",
+        "--name", "mcp-playwright-${AGENT_ID:-agent}",
+        "--memory=1g",
+        "--shm-size=2g",
+        "-e", "AGENT_ID=${AGENT_ID:-agent}",
+        "-e", "NODE_PATH=/usr/local/lib/node_modules",
+        "-e", "PLAYWRIGHT_BROWSERS_PATH=/ms-playwright",
+        "-v", "${PWD}/screenshots:/app/screenshots",
+        "claude-flow-novice:playwright-working",
+        "node", "-e", "
+          const { chromium } = require('playwright');
+          let browser = null;
+          let page = null;
+
+          try {
+            // MCP Server implementation
+            const readline = require('readline');
+            const rl = readline.createInterface({
+              input: process.stdin,
+              output: process.stdout,
+              terminal: false
+            });
+
+            const tools = {
+              take_screenshot: {
+                name: 'take_screenshot',
+                description: 'Take a screenshot of a webpage',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    url: { type: 'string', description: 'URL to capture' },
+                    filename: { type: 'string', description: 'Screenshot filename' },
+                    fullPage: { type: 'boolean', default: false }
+                  },
+                  required: ['url', 'filename']
+                }
+              },
+              search_google: {
+                name: 'search_google',
+                description: 'Search Google and return results',
+                inputSchema: {
+                  type: 'object',
+                  properties: {
+                    query: { type: 'string', description: 'Search query' },
+                    screenshot: { type: 'boolean', default: true }
+                  },
+                  required: ['query']
+                }
+              }
+            };
+
+            // Initialize browser
+            async function initBrowser() {
+              if (!browser) {
+                browser = await chromium.launch({
+                  headless: true,
+                  args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
+                });
+                page = await browser.newPage();
+              }
+            }
+
+            // Tool implementations
+            async function takeScreenshot(args) {
+              await initBrowser();
+              await page.goto(args.url, { waitUntil: 'networkidle', timeout: 15000 });
+
+              const filename = args.filename || 'screenshot-' + Date.now() + '.png';
+              const filepath = '/app/screenshots/' + filename;
+
+              await page.screenshot({
+                path: filepath,
+                fullPage: args.fullPage || false
+              });
+
+              return {
+                success: true,
+                filename: filename,
+                filepath: filepath,
+                url: args.url,
+                title: await page.title()
+              };
+            }
+
+            async function searchGoogle(args) {
+              await initBrowser();
+              await page.goto('https://www.google.com', { waitUntil: 'networkidle', timeout: 15000 });
+
+              // Handle cookies
+              try {
+                await page.waitForSelector('button[aria-label*=\"Accept\"], button[aria-label*=\"agree\"]', { timeout: 3000 });
+                await page.click('button[aria-label*=\"Accept\"], button[aria-label*=\"agree\"]');
+                await page.waitForTimeout(1000);
+              } catch (e) {}
+
+              // Search
+              const searchBox = await page.waitForSelector('textarea[name=\"q\"], input[name=\"q\"]');
+              await searchBox.fill(args.query);
+              await searchBox.press('Enter');
+
+              await page.waitForSelector('[role=\"main\"], #search', { timeout: 15000 });
+
+              const results = await page.\$\$eval('div[data-hveid] h3', elements =>
+                elements.slice(0, 5).map(el => el.textContent.trim())
+              );
+
+              let screenshotInfo = null;
+              if (args.screenshot) {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                const filename = 'google-search-' + args.query.toLowerCase().replace(/\\s+/g, '-') + '-' + timestamp + '.png';
+                await page.screenshot({ path: '/app/screenshots/' + filename });
+                screenshotInfo = { filename, path: '/app/screenshots/' + filename };
+              }
+
+              return {
+                success: true,
+                query: args.query,
+                results: results,
+                resultCount: results.length,
+                screenshot: screenshotInfo,
+                url: page.url()
+              };
+            }
+
+            // MCP Protocol handler
+            rl.on('line', async (line) => {
+              try {
+                const message = JSON.parse(line);
+
+                if (message.method === 'initialize') {
+                  console.log(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: message.id,
+                    result: {
+                      protocolVersion: '2024-11-05',
+                      capabilities: {
+                        tools: {}
+                      },
+                      serverInfo: {
+                        name: 'playwright-mcp-server',
+                        version: '1.0.0'
+                      }
+                    }
+                  }));
+                } else if (message.method === 'tools/list') {
+                  console.log(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: message.id,
+                    result: { tools: Object.values(tools) }
+                  }));
+                } else if (message.method === 'tools/call') {
+                  const toolName = message.params.name;
+                  const args = message.params.arguments || {};
+
+                  let result;
+                  if (toolName === 'take_screenshot') {
+                    result = await takeScreenshot(args);
+                  } else if (toolName === 'search_google') {
+                    result = await searchGoogle(args);
+                  } else {
+                    throw new Error('Unknown tool: ' + toolName);
+                  }
+
+                  console.log(JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: message.id,
+                    result: { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] }
+                  }));
+                }
+              } catch (error) {
+                console.log(JSON.stringify({
+                  jsonrpc: '2.0',
+                  id: message.id || null,
+                  error: { code: -32000, message: error.message }
+                }));
+              }
+            });
+
+            // Cleanup on exit
+            process.on('SIGINT', async () => {
+              if (browser) await browser.close();
+              process.exit(0);
+            });
+
+          } catch (error) {
+            console.error('MCP Server error:', error);
+            process.exit(1);
+          }
+        "
+      ]
+    }
+  }
+}

package/.claude/skills/.cfn/task-configs/task-test-123.json

@@ -0,0 +1,48 @@
+{
+  "taskId": "test-123",
+  "taskDescription": "Implement JWT authentication",
+  "mode": "standard",
+  "spawnMode": "task",
+  "scope": {
+    "epicGoal": "Implement JWT authentication",
+    "inScope": [
+      "JWT token generation and validation",
+      "Authentication middleware"
+    ],
+    "outOfScope": [
+      "Multi-factor authentication",
+      "Biometric login",
+      "User analytics and tracking",
+      "Admin dashboard UI",
+      "Monitoring and alerting"
+    ],
+    "deliverables": [
+      "src/auth/jwt.ts",
+      "src/auth/middleware.ts",
+      "tests/auth.test.ts"
+    ],
+    "directory": "src/auth",
+    "acceptanceCriteria": [
+      "JWT tokens expire correctly",
+      "Authentication tests pass with >80% coverage"
+    ]
+  },
+  "agents": {
+    "loop3": [
+      "backend-dev",
+      "researcher"
+    ],
+    "loop2": [
+      "reviewer",
+      "tester",
+      "architect",
+      "security-specialist"
+    ]
+  },
+  "thresholds": {
+    "gate": 0.75,
+    "consensus": 0.90,
+    "maxIterations": 10
+  },
+  "createdAt": "2025-12-08T20:20:18Z"
+}

package/.claude/skills/bulk-add-ruvector-instructions.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+set -eu
+
+# Add RuVector instructions to key agent profiles
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+AGENT_DIR="${SCRIPT_DIR}/../agents"
+
+# Define which agents to update (high-impact ones)
+AGENTS_TO_UPDATE=(
+    "custom/cfn-docker-expert.md"
+    "custom/cfn-loops-cli-expert.md"
+    "custom/cfn-redis-operations.md"
+    "custom/cfn-system-expert.md"
+    "custom/claude-code-expert.md"
+    "custom/mdap-trigger-specialist.md"
+    "custom/trigger-dev-expert.md"
+    "development/backend-developer.md"
+    "development/frontend-developer.md"
+    "development/database-architect.md"
+    "testing/tester.md"
+    "validation/code-reviewer.md"
+    "validation/security-specialist.md"
+)
+
+# Function to add instructions after post-edit pipeline section
+add_ruvector_instructions() {
+    local file="$1"
+    local temp_file=$(mktemp)
+
+    # Check if file already has RuVector instructions
+    if grep -q "RuVector Semantic Search" "$file"; then
+        echo "⚠️  $file already has RuVector instructions"
+        rm -f "$temp_file"
+        return 0
+    fi
+
+    # Find the line with post-edit pipeline and insert after it
+    if grep -q "Post-Edit Pipeline Requirement" "$file"; then
+        # Add after the entire post-edit section (look for the empty line after it)
+        awk '
+        /^# IMPORTANT: Post-Edit Pipeline Requirement/ {in_section=1}
+        in_section && /^$/ && !added {
+            print ""
+            print ""
+            print "# IMPORTANT: RuVector Semantic Search (Before Making Changes)"
+            print "# Before implementing any changes, ALWAYS query the codebase for similar patterns:"
+            print "#   /codebase-search \"relevant search terms for your task\" --top 5"
+            print "#   /codebase-search \"error pattern or issue you\"re fixing\" --top 3"
+            print "# Also query past errors and learnings:"
+            print "#   ./.claude/skills/cfn-ruvector-codebase-index/query-error-patterns.sh --task-description \"Your task description\""
+            print "#   ./.claude/skills/cfn-ruvector-codebase-index/query-learnings.sh --task-description \"Your task description\" --category PATTERN"
+            print "# This prevents duplicated work and leverages existing solutions."
+            added=1
+        }
+        {print}
+        ' "$file" > "$temp_file"
+        mv "$temp_file" "$file"
+        echo "✅ Added RuVector instructions to $file"
+    else
+        echo "❌ Could not find Post-Edit section in $file"
+        rm -f "$temp_file"
+    fi
+}
+
+# Process each agent
+echo "🔄 Adding RuVector instructions to key agent profiles..."
+echo ""
+
+updated=0
+skipped=0
+
+for agent in "${AGENTS_TO_UPDATE[@]}"; do
+    agent_path="${AGENT_DIR}/$agent"
+
+    if [[ ! -f "$agent_path" ]]; then
+        echo "⚠️  $agent not found, skipping"
+        ((skipped++))
+        continue
+    fi
+
+    add_ruvector_instructions "$agent_path"
+    ((updated++))
+done
+
+echo ""
+echo "=== Summary ==="
+echo "✅ Updated: $updated agents"
+echo "⚠️  Skipped: $skipped agents"

package/.claude/skills/cfn-agent-lifecycle/SKILL.md

@@ -0,0 +1,290 @@
+---
+name: cfn-agent-lifecycle
+description: Unified agent management from selection through completion - spawning, execution, output processing
+version: 2.0.0
+tags: [mega-skill, agent-management, lifecycle, spawning]
+status: production
+---
+
+# Agent Lifecycle Management Skill (Mega-Skill)
+
+**Version:** 2.0.0
+**Purpose:** Unified agent management from selection through completion
+**Status:** Production
+**Consolidates:** cfn-agent-selector, cfn-agent-selection-with-fallback, cfn-agent-spawning, cfn-agent-output-processing, cfn-agent-execution
+
+---
+
+## Overview
+
+This mega-skill provides complete agent lifecycle management:
+- **Selection** - Task classification and agent selection with fallback
+- **Spawning** - Agent deployment with dependency validation
+- **Output** - Structured output parsing and validation
+- **Audit** - SQLite lifecycle tracking for audit trails
+
+---
+
+## Directory Structure
+
+```
+agent-lifecycle/
+├── SKILL.md                          # This file
+├── lib/
+│   ├── selection/                    # Agent selection (from cfn-agent-selector + cfn-agent-selection-with-fallback)
+│   │   ├── select-agents.sh          # Basic agent selection
+│   │   ├── select-agents-with-fallback.sh  # Enhanced with fallback (recommended)
+│   │   ├── task-classifier.sh        # Task classification
+│   │   ├── agent-mappings.json       # Agent category mappings
+│   │   ├── src/                      # TypeScript implementation
+│   │   │   ├── agent-selector.ts
+│   │   │   ├── cli.ts
+│   │   │   └── agent-selector.test.ts
+│   │   └── dist/                     # Compiled TypeScript
+│   │       ├── agent-selector.cjs
+│   │       └── cli.cjs
+│   ├── spawning/                     # Agent spawning (from cfn-agent-spawning + cfn-agent-execution)
+│   │   ├── spawn-agent.sh            # Main spawning script
+│   │   ├── spawn-worker.sh           # Worker spawning
+│   │   ├── spawn-templates.sh        # Template management
+│   │   ├── spawn-agent-wrapper.sh    # Wrapper with error handling
+│   │   ├── execute-agent.sh          # Agent execution
+│   │   ├── check-dependencies.sh     # Dependency validation
+│   │   ├── parse-agent-provider.sh   # Provider parsing
+│   │   └── get-agent-provider-env.sh # Provider env setup
+│   ├── output/                       # Output processing (from cfn-agent-output-processing)
+│   │   └── README.md                 # Output processing documentation
+│   └── audit/                        # Audit trail (original agent-lifecycle)
+│       ├── execute-lifecycle-hook.sh # SQLite lifecycle hooks
+│       └── simple-audit.sh           # Simple audit script
+└── cli/                              # CLI wrappers for convenience
+    ├── select-agents.sh              # → lib/selection/select-agents-with-fallback.sh
+    ├── spawn-agent.sh                # → lib/spawning/spawn-agent.sh
+    └── lifecycle-hook.sh             # → lib/audit/execute-lifecycle-hook.sh
+```
+
+---
+
+## Quick Start
+
+### 1. Select Agents for a Task
+
+```bash
+# Recommended: Use fallback-enabled selection
+./.claude/skills/agent-lifecycle/cli/select-agents.sh "Implement JWT authentication"
+
+# Output (JSON):
+# {
+#   "loop3": ["backend-developer", "security-specialist"],
+#   "loop2": ["code-reviewer", "tester", "security-specialist"],
+#   "product_owner": "product-owner",
+#   "category": "backend-api",
+#   "confidence": 0.92
+# }
+```
+
+### 2. Spawn Agents
+
+```bash
+./.claude/skills/agent-lifecycle/cli/spawn-agent.sh \
+  --task "Implement user authentication" \
+  --agents coder,security-specialist,tester \
+  --agent-id coordinator-1
+```
+
+### 3. Track Lifecycle Events
+
+```bash
+# Register agent spawn
+./.claude/skills/agent-lifecycle/cli/lifecycle-hook.sh spawn \
+  --agent-id "${AGENT_ID}" \
+  --agent-type "${AGENT_TYPE}" \
+  --acl-level 1
+
+# Update confidence
+./.claude/skills/agent-lifecycle/cli/lifecycle-hook.sh update \
+  --agent-id "${AGENT_ID}" \
+  --confidence 0.85
+
+# Mark completion
+./.claude/skills/agent-lifecycle/cli/lifecycle-hook.sh complete \
+  --agent-id "${AGENT_ID}" \
+  --confidence 0.90
+```
+
+---
+
+## Module Details
+
+### Selection Module (lib/selection/)
+
+**Purpose:** Task classification and agent selection
+
+**Features:**
+- Task classification into 9 categories
+- Agent selection for Loop 3 (implementers) and Loop 2 (validators)
+- Guaranteed non-empty agent arrays (fallback behavior)
+- Agent validation against available profiles
+- TypeScript implementation for type safety
+
+**Task Categories:**
+| Category | Loop 3 Agents | Loop 2 Agents |
+|----------|---------------|---------------|
+| backend-api | backend-developer, api-gateway-specialist | code-reviewer, tester, api-testing-specialist |
+| fullstack | backend-developer, react-frontend-engineer | code-reviewer, tester, integration-tester |
+| mobile | mobile-dev, backend-developer | code-reviewer, tester, interaction-tester |
+| infrastructure | devops-engineer, docker-specialist | code-reviewer, tester, chaos-engineering-specialist |
+| security | security-specialist, backend-developer | code-reviewer, tester, security-specialist |
+| frontend | react-frontend-engineer, typescript-specialist | code-reviewer, tester, playwright-tester |
+| database | database-architect, backend-developer | code-reviewer, tester, data-engineer |
+| performance | backend-developer, perf-analyzer | code-reviewer, tester, performance-benchmarker |
+| default | backend-developer, devops-engineer | code-reviewer, tester, code-quality-validator |
+
+### Spawning Module (lib/spawning/)
+
+**Purpose:** Agent deployment and dependency management
+
+**Features:**
+- System dependency validation (Bash 4.0+, Node.js, etc.)
+- Node.js module validation (redis, dotenv)
+- Claude Flow prerequisites check
+- Multi-agent spawning
+- Provider routing support
+
+**Performance Targets:**
+- Dependency check: <50ms
+- Spawn time: <200ms
+- Stop time: <150ms
+- Success rate: 99.5%
+
+### Output Module (lib/output/)
+
+**Purpose:** Structured output extraction from agents
+
+**Features:**
+- Multi-pattern parsing with fallbacks
+- Output validation framework
+- Redis coordination integration
+- Universal pattern system for any agent type
+
+### Audit Module (lib/audit/)
+
+**Purpose:** SQLite lifecycle tracking
+
+**Features:**
+- Agent spawn registration
+- Confidence updates during work
+- Completion tracking
+- Cross-session recovery support
+- ACL level enforcement (1-6)
+
+---
+
+## Integration with CFN Loop
+
+```bash
+# 1. Classify task and select agents
+CLASSIFICATION=$(./lib/selection/task-classifier.sh "$TASK_DESCRIPTION")
+AGENTS_JSON=$(./cli/select-agents.sh "$TASK_DESCRIPTION")
+
+# 2. Extract agent lists
+LOOP3_AGENTS=$(echo "$AGENTS_JSON" | jq -r '.loop3 | join(",")')
+LOOP2_AGENTS=$(echo "$AGENTS_JSON" | jq -r '.loop2 | join(",")')
+
+# 3. Spawn agents with lifecycle tracking
+./cli/lifecycle-hook.sh spawn --agent-id "$AGENT_ID" --agent-type "$AGENT_TYPE"
+./cli/spawn-agent.sh --task "$TASK" --agents "$LOOP3_AGENTS" --agent-id "$AGENT_ID"
+
+# 4. After completion
+./cli/lifecycle-hook.sh complete --agent-id "$AGENT_ID" --confidence 0.92
+```
+
+---
+
+## Migration from Individual Skills
+
+### Old Paths → New Paths
+
+| Old Path | New Path |
+|----------|----------|
+| `.claude/skills/cfn-agent-selector/select-agents.sh` | `.claude/skills/agent-lifecycle/lib/selection/select-agents.sh` |
+| `.claude/skills/cfn-agent-selection-with-fallback/select-agents.sh` | `.claude/skills/agent-lifecycle/lib/selection/select-agents-with-fallback.sh` |
+| `.claude/skills/cfn-agent-spawning/spawn-agent.sh` | `.claude/skills/agent-lifecycle/lib/spawning/spawn-agent.sh` |
+| `.claude/skills/cfn-agent-execution/execute-agent.sh` | `.claude/skills/agent-lifecycle/lib/spawning/execute-agent.sh` |
+
+### CLI Wrappers (Convenience)
+
+For easier migration, use CLI wrappers:
+```bash
+./.claude/skills/agent-lifecycle/cli/select-agents.sh  # Recommended entry point
+./.claude/skills/agent-lifecycle/cli/spawn-agent.sh
+./.claude/skills/agent-lifecycle/cli/lifecycle-hook.sh
+```
+
+---
+
+## TypeScript Implementation
+
+The selection module includes a production-ready TypeScript implementation:
+
+```bash
+# Use TypeScript version
+export USE_TYPESCRIPT=true
+./lib/selection/select-agents-with-fallback.sh "Implement auth"
+
+# Or call directly
+node ./lib/selection/dist/cli.cjs "Implement auth"
+```
+
+**Benefits:**
+- Type-safe interfaces
+- 95.2% classification accuracy
+- 42 tests, 100% passing
+- Path traversal security validation
+
+---
+
+## Dependencies
+
+- **Bash:** 4.0+
+- **Node.js:** LTS (for TypeScript features)
+- **jq:** JSON processing
+- **SQLite3:** Audit database
+- **Redis:** Coordination (optional)
+
+---
+
+## Testing
+
+```bash
+# Test selection
+./lib/selection/src/agent-selector.test.ts
+
+# Test spawning dependencies
+./lib/spawning/check-dependencies.sh
+
+# Test lifecycle hooks
+./lib/audit/simple-audit.sh
+```
+
+---
+
+## Version History
+
+### 2.0.0 (2025-12-02) - Mega-Skill Consolidation
+- Merged: cfn-agent-selector, cfn-agent-selection-with-fallback
+- Merged: cfn-agent-spawning, cfn-agent-execution
+- Merged: cfn-agent-output-processing
+- Added: CLI wrappers for convenience
+- Added: Unified documentation
+
+### 1.0.0 (Original)
+- SQLite lifecycle hooks for auditing
+
+---
+
+## Related Skills
+
+- **task-classifier** (`.claude/skills/task-classifier/`) - Standalone task classification
+- **cfn-docker-agent-spawning** (`.claude/skills/cfn-docker-agent-spawning/`) - Docker-specific spawning
+- **cfn-product-owner-decision** (`.claude/skills/cfn-product-owner-decision/`) - Product owner output processing

package/.claude/skills/cfn-agent-lifecycle/cli/lifecycle-hook.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# CLI wrapper for lifecycle hooks
+# Delegates to lib/audit/execute-lifecycle-hook.sh
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/../lib/audit/execute-lifecycle-hook.sh" "$@"

package/.claude/skills/cfn-agent-lifecycle/cli/select-agents.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# CLI wrapper for agent selection
+# Delegates to lib/selection/select-agents-with-fallback.sh
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/../lib/selection/select-agents-with-fallback.sh" "$@"

package/.claude/skills/cfn-agent-lifecycle/cli/spawn-agent.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# CLI wrapper for agent spawning
+# Delegates to lib/spawning/spawn-agent.sh
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/../lib/spawning/spawn-agent.sh" "$@"