claude-flow-novice 2.6.0 → 2.9.0

package/.claude/skills/ace-system/store-reflection.sh

@@ -1,149 +0,0 @@
-#!/bin/bash
-# Store reflection in context_reflections table
-# Usage: ./store-reflection.sh --reflection-type success --task-id sprint-123 --lessons-file lessons.json
-
-set -e
-
-# Default values
-DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
-REFLECTION_TYPE=""
-TASK_ID=""
-AGENT_ID=""
-EXECUTION_TRACE=""
-FEEDBACK_SIGNALS=""
-LESSONS_FILE=""
-ACL_LEVEL=3
-SWARM_ID="default-swarm"
-PROJECT_ID="default-project"
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --reflection-type)
-      REFLECTION_TYPE="$2"
-      shift 2
-      ;;
-    --task-id)
-      TASK_ID="$2"
-      shift 2
-      ;;
-    --agent-id)
-      AGENT_ID="$2"
-      shift 2
-      ;;
-    --execution-trace-file)
-      if [ -f "$2" ]; then
-        EXECUTION_TRACE=$(cat "$2")
-      fi
-      shift 2
-      ;;
-    --feedback-signals-file)
-      if [ -f "$2" ]; then
-        FEEDBACK_SIGNALS=$(cat "$2")
-      fi
-      shift 2
-      ;;
-    --lessons-file)
-      LESSONS_FILE="$2"
-      shift 2
-      ;;
-    --acl-level)
-      ACL_LEVEL="$2"
-      shift 2
-      ;;
-    --swarm-id)
-      SWARM_ID="$2"
-      shift 2
-      ;;
-    --project-id)
-      PROJECT_ID="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1"
-      exit 1
-      ;;
-  esac
-done
-
-# Validate required parameters
-if [ -z "$REFLECTION_TYPE" ] || [ -z "$TASK_ID" ] || [ -z "$LESSONS_FILE" ]; then
-  echo "Error: Missing required parameters"
-  echo "Usage: $0 --reflection-type <type> --task-id <id> --lessons-file <path>"
-  exit 1
-fi
-
-# Validate reflection type
-case $REFLECTION_TYPE in
-  success|failure|optimization|edge_case|pattern)
-    ;;
-  *)
-    echo "Error: Invalid reflection_type. Must be: success, failure, optimization, edge_case, or pattern"
-    exit 1
-    ;;
-esac
-
-# Read lessons file
-if [ ! -f "$LESSONS_FILE" ]; then
-  echo "Error: Lessons file not found: $LESSONS_FILE"
-  exit 1
-fi
-
-EXTRACTED_LESSONS=$(cat "$LESSONS_FILE")
-
-# Generate unique reflection ID
-REFLECTION_ID="refl-$(date +%s)-$(openssl rand -hex 3)"
-
-# Create database if not exists
-mkdir -p "$(dirname "$DB_PATH")"
-
-# Insert reflection into database
-sqlite3 "$DB_PATH" <<EOF
--- Ensure table exists (idempotent)
-CREATE TABLE IF NOT EXISTS context_reflections (
-    id TEXT PRIMARY KEY,
-    reflection_type TEXT NOT NULL CHECK (reflection_type IN ('success', 'failure', 'optimization', 'edge_case', 'pattern')),
-    task_id TEXT NOT NULL,
-    agent_id TEXT,
-    execution_trace TEXT NOT NULL,
-    feedback_signals TEXT NOT NULL,
-    extracted_lessons TEXT NOT NULL,
-    curator_status TEXT DEFAULT 'pending' CHECK (curator_status IN ('pending', 'processing', 'merged', 'rejected', 'human_review')),
-    merged_bullet_ids TEXT,
-    rejection_reason TEXT,
-    acl_level INTEGER NOT NULL DEFAULT 3 CHECK (acl_level BETWEEN 1 AND 6),
-    swarm_id TEXT NOT NULL,
-    project_id TEXT,
-    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-    processed_at DATETIME
-);
-
--- Insert reflection
-INSERT INTO context_reflections (
-  id, reflection_type, task_id, agent_id, execution_trace, feedback_signals,
-  extracted_lessons, curator_status, acl_level, swarm_id, project_id
-) VALUES (
-  '${REFLECTION_ID}',
-  '${REFLECTION_TYPE}',
-  '${TASK_ID}',
-  $([ -n "$AGENT_ID" ] && echo "'$AGENT_ID'" || echo "NULL"),
-  '${EXECUTION_TRACE:-{}}',
-  '${FEEDBACK_SIGNALS:-{}}',
-  '${EXTRACTED_LESSONS}',
-  'pending',
-  ${ACL_LEVEL},
-  '${SWARM_ID}',
-  $([ -n "$PROJECT_ID" ] && echo "'$PROJECT_ID'" || echo "NULL")
-);
-EOF
-
-# Verify insertion
-COUNT=$(sqlite3 "$DB_PATH" "SELECT COUNT(*) FROM context_reflections WHERE id = '${REFLECTION_ID}';")
-
-if [ "$COUNT" -eq 1 ]; then
-  echo "{\"status\":\"success\",\"reflection_id\":\"${REFLECTION_ID}\",\"database\":\"${DB_PATH}\",\"lessons_count\":$(echo "$EXTRACTED_LESSONS" | jq 'length')}"
-  exit 0
-else
-  echo "{\"status\":\"error\",\"message\":\"Reflection insertion failed\"}"
-  exit 1
-fi

package/.claude/skills/ace-system/test-ace-skill.sh

@@ -1,312 +0,0 @@
-#!/usr/bin/env bash
-
-##############################################################################
-# ACE System Skill Test Suite
-# Validates all ACE skill wrapper functionality
-#
-# Usage:
-#   ./test-ace-skill.sh
-##############################################################################
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-TEST_DIR=$(mktemp -d)
-trap "rm -rf $TEST_DIR" EXIT
-
-PASS_COUNT=0
-FAIL_COUNT=0
-
-# Test helper functions
-pass() {
-  echo "[PASS] $1"
-  ((PASS_COUNT++))
-}
-
-fail() {
-  echo "[FAIL] $1"
-  ((FAIL_COUNT++))
-}
-
-# Test 1: Context Reflection
-test_context_reflect() {
-  echo "Running: Context Reflection Test"
-
-  local test_context='{"task": "test-reflection", "complexity": "high", "constraints": ["time", "budget"]}'
-
-  if result=$("$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context "$test_context" \
-    --memory-path "$TEST_DIR/test-reflections.sqlite" 2>&1); then
-
-    # Validate JSON output
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      # Check required fields
-      if echo "$result" | jq -e '.id and .timestamp and .complexity and .insights' > /dev/null 2>&1; then
-        pass "Context reflection generates valid output"
-      else
-        fail "Context reflection missing required fields"
-      fi
-    else
-      fail "Context reflection returned invalid JSON"
-    fi
-  else
-    fail "Context reflection script failed: $result"
-  fi
-}
-
-# Test 2: Context Stats - Reflections Query
-test_context_stats() {
-  echo "Running: Context Stats Test"
-
-  # First create some reflections
-  "$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context '{"task": "stats-test-1"}' \
-    --memory-path "$TEST_DIR/test-stats.sqlite" > /dev/null 2>&1
-
-  "$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context '{"task": "stats-test-2"}' \
-    --complexity 0.8 \
-    --memory-path "$TEST_DIR/test-stats.sqlite" > /dev/null 2>&1
-
-  # Query reflections
-  if result=$("$SCRIPT_DIR/invoke-context-stats.sh" \
-    --query reflections \
-    --filter '{"complexity": {"$gt": 0.5}}' \
-    --limit 10 \
-    --memory-path "$TEST_DIR/test-stats.sqlite" 2>&1); then
-
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      # Check if array returned
-      if echo "$result" | jq -e 'type == "array"' > /dev/null 2>&1; then
-        pass "Context stats returns filtered reflections"
-      else
-        fail "Context stats did not return array"
-      fi
-    else
-      fail "Context stats returned invalid JSON"
-    fi
-  else
-    fail "Context stats script failed: $result"
-  fi
-}
-
-# Test 3: Context Stats - Summary Query
-test_context_stats_summary() {
-  echo "Running: Context Stats Summary Test"
-
-  # Use same database as previous test
-  if result=$("$SCRIPT_DIR/invoke-context-stats.sh" \
-    --query summary \
-    --memory-path "$TEST_DIR/test-stats.sqlite" 2>&1); then
-
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      # Check summary fields
-      if echo "$result" | jq -e '.totalReflections and .avgComplexity and .maxComplexity' > /dev/null 2>&1; then
-        pass "Context stats summary provides analytics"
-      else
-        fail "Context stats summary missing required fields"
-      fi
-    else
-      fail "Context stats summary returned invalid JSON"
-    fi
-  else
-    fail "Context stats summary script failed: $result"
-  fi
-}
-
-# Test 4: Context Query
-test_context_query() {
-  echo "Running: Context Query Test"
-
-  # Create reflections with specific keywords
-  "$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context '{"task": "authentication", "features": ["JWT", "OAuth"]}' \
-    --memory-path "$TEST_DIR/test-query.sqlite" > /dev/null 2>&1
-
-  "$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context '{"task": "deployment", "features": ["Docker", "K8s"]}' \
-    --memory-path "$TEST_DIR/test-query.sqlite" > /dev/null 2>&1
-
-  # Query for authentication-related contexts
-  if result=$("$SCRIPT_DIR/invoke-context-query.sh" \
-    --keywords "authentication,JWT" \
-    --similarity-threshold 0.3 \
-    --max-results 5 \
-    --memory-path "$TEST_DIR/test-query.sqlite" 2>&1); then
-
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      # Check if results have similarity scores
-      if echo "$result" | jq -e '.[0].similarity' > /dev/null 2>&1; then
-        pass "Context query finds similar contexts"
-      else
-        fail "Context query results missing similarity scores"
-      fi
-    else
-      fail "Context query returned invalid JSON"
-    fi
-  else
-    fail "Context query script failed: $result"
-  fi
-}
-
-# Test 5: Context Injection
-test_context_inject() {
-  echo "Running: Context Injection Test"
-
-  # Create source context file
-  local context_file="$TEST_DIR/inject-source.json"
-  echo '{"historical": "data", "priority": 0.9, "insights": ["learned behavior"]}' > "$context_file"
-
-  # Test deep merge strategy
-  if result=$("$SCRIPT_DIR/invoke-context-inject.sh" \
-    --context-file "$context_file" \
-    --target-task "test-inject-task" \
-    --merge-strategy deep 2>&1); then
-
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      # Check injection metadata
-      if echo "$result" | jq -e '.taskId and .mergeStrategy and .context' > /dev/null 2>&1; then
-        pass "Context injection merges successfully"
-      else
-        fail "Context injection missing required fields"
-      fi
-    else
-      fail "Context injection returned invalid JSON"
-    fi
-  else
-    fail "Context injection script failed: $result"
-  fi
-}
-
-# Test 6: Context Curation - Simple Merge
-test_context_curate_simple() {
-  echo "Running: Context Curation (Simple) Test"
-
-  # Create multiple context files
-  local ctx1="$TEST_DIR/curate-ctx1.json"
-  local ctx2="$TEST_DIR/curate-ctx2.json"
-  local ctx3="$TEST_DIR/curate-ctx3.json"
-
-  echo '{"agent": "coder-1", "confidence": 0.85, "result": "implemented"}' > "$ctx1"
-  echo '{"agent": "reviewer-1", "confidence": 0.90, "result": "approved"}' > "$ctx2"
-  echo '{"agent": "tester-1", "confidence": 0.80, "result": "validated"}' > "$ctx3"
-
-  # Test simple merge
-  if result=$("$SCRIPT_DIR/invoke-context-curate.sh" \
-    --contexts "$ctx1,$ctx2,$ctx3" \
-    --strategy simple 2>&1); then
-
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      # Check curation metadata
-      if echo "$result" | jq -e '.curated and .strategy == "simple" and .sourceCount == 3' > /dev/null 2>&1; then
-        pass "Context curation handles simple merge"
-      else
-        fail "Context curation metadata incorrect"
-      fi
-    else
-      fail "Context curation returned invalid JSON"
-    fi
-  else
-    fail "Context curation script failed: $result"
-  fi
-}
-
-# Test 7: Context Curation - Consensus Weighted
-test_context_curate_consensus() {
-  echo "Running: Context Curation (Consensus) Test"
-
-  # Use same files as simple test
-  local ctx1="$TEST_DIR/curate-ctx1.json"
-  local ctx2="$TEST_DIR/curate-ctx2.json"
-  local ctx3="$TEST_DIR/curate-ctx3.json"
-
-  # Test consensus-weighted merge
-  if result=$("$SCRIPT_DIR/invoke-context-curate.sh" \
-    --contexts "$ctx1,$ctx2,$ctx3" \
-    --strategy consensus-weighted 2>&1); then
-
-    if echo "$result" | jq . > /dev/null 2>&1; then
-      if echo "$result" | jq -e '.strategy == "consensus-weighted"' > /dev/null 2>&1; then
-        pass "Context curation handles consensus weighting"
-      else
-        fail "Context curation strategy not applied"
-      fi
-    else
-      fail "Context curation consensus returned invalid JSON"
-    fi
-  else
-    fail "Context curation consensus script failed: $result"
-  fi
-}
-
-# Test 8: Integration Test - Full CFN Loop Workflow
-test_cfn_loop_integration() {
-  echo "Running: CFN Loop Integration Test"
-
-  local loop_db="$TEST_DIR/cfn-loop.sqlite"
-
-  # Loop 3: Primary implementation
-  "$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context '{"phase": "loop3", "agent": "coder-1", "task": "implement-feature"}' \
-    --memory-path "$loop_db" \
-    --output "$TEST_DIR/loop3-agent1.json" > /dev/null 2>&1
-
-  "$SCRIPT_DIR/invoke-context-reflect.sh" \
-    --context '{"phase": "loop3", "agent": "devops-1", "task": "deploy-infrastructure"}' \
-    --memory-path "$loop_db" \
-    --output "$TEST_DIR/loop3-agent2.json" > /dev/null 2>&1
-
-  # Loop 2: Validation consensus
-  "$SCRIPT_DIR/invoke-context-curate.sh" \
-    --contexts "$TEST_DIR/loop3-agent1.json,$TEST_DIR/loop3-agent2.json" \
-    --strategy consensus-weighted \
-    --output "$TEST_DIR/loop2-merged.json" > /dev/null 2>&1
-
-  # Product Owner: Final decision
-  if "$SCRIPT_DIR/invoke-context-inject.sh" \
-    --context-file "$TEST_DIR/loop2-merged.json" \
-    --target-task "cfn-loop-final" \
-    --merge-strategy deep \
-    --output "$TEST_DIR/final-context.json" > /dev/null 2>&1; then
-
-    # Validate final output exists and is valid JSON
-    if [ -f "$TEST_DIR/final-context.json" ] && jq . "$TEST_DIR/final-context.json" > /dev/null 2>&1; then
-      pass "CFN Loop integration workflow completes successfully"
-    else
-      fail "CFN Loop final context invalid"
-    fi
-  else
-    fail "CFN Loop integration workflow failed"
-  fi
-}
-
-# Run all tests
-echo "========================================="
-echo "ACE System Skill Test Suite"
-echo "========================================="
-echo ""
-
-test_context_reflect
-test_context_stats
-test_context_stats_summary
-test_context_query
-test_context_inject
-test_context_curate_simple
-test_context_curate_consensus
-test_cfn_loop_integration
-
-echo ""
-echo "========================================="
-echo "Test Results"
-echo "========================================="
-echo "PASS: $PASS_COUNT"
-echo "FAIL: $FAIL_COUNT"
-echo ""
-
-if [ $FAIL_COUNT -eq 0 ]; then
-  echo "All tests passed!"
-  exit 0
-else
-  echo "Some tests failed."
-  exit 1
-fi

package/.claude/skills/ace-system/update-reflection.sh

@@ -1,41 +0,0 @@
-#!/bin/bash
-# Update reflection status
-# Usage: ./update-reflection.sh --reflection-id refl-123 --status merged --merged-bullet-ids '["STRAT-007"]'
-
-set -e
-
-DB_PATH="${ACE_DB_PATH:-./.artifacts/database/swarm-memory.db}"
-REFLECTION_ID=""
-STATUS=""
-MERGED_BULLET_IDS=""
-
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --reflection-id) REFLECTION_ID="$2"; shift 2 ;;
-    --status) STATUS="$2"; shift 2 ;;
-    --merged-bullet-ids) MERGED_BULLET_IDS="$2"; shift 2 ;;
-    *) echo "Unknown option: $1"; exit 1 ;;
-  esac
-done
-
-if [ -z "$REFLECTION_ID" ] || [ -z "$STATUS" ]; then
-  echo "Error: --reflection-id and --status required"
-  exit 1
-fi
-
-sqlite3 "$DB_PATH" <<EOF
-UPDATE context_reflections
-SET curator_status = '${STATUS}',
-    merged_bullet_ids = $([ -n "$MERGED_BULLET_IDS" ] && echo "'$MERGED_BULLET_IDS'" || echo "NULL"),
-    processed_at = CURRENT_TIMESTAMP
-WHERE id = '${REFLECTION_ID}';
-EOF
-
-COUNT=$(sqlite3 "$DB_PATH" "SELECT changes();")
-
-if [ "$COUNT" -gt 0 ]; then
-  echo "{\"status\":\"success\",\"reflection_id\":\"${REFLECTION_ID}\",\"new_status\":\"${STATUS}\"}"
-else
-  echo "{\"status\":\"error\",\"message\":\"Reflection not found: ${REFLECTION_ID}\"}"
-  exit 1
-fi

package/.claude/skills/agent-execution/execute-agent.sh

@@ -1,126 +0,0 @@
-#!/usr/bin/env bash
-##############################################################################
-# Agent Execution Script
-#
-# Executes CLI-spawned agents by invoking Claude API with agent prompt.
-# Supports both Anthropic and z.ai provider routing.
-#
-# Environment Variables:
-#   AGENT_TYPE      - Agent type/name (e.g., "rust-enterprise-developer")
-#   AGENT_ID        - Unique agent identifier (e.g., "rust-enterprise-1")
-#   AGENT_MODEL     - Model to use (haiku, sonnet, opus)
-#   AGENT_TOOLS     - Comma-separated list of tools
-#   TASK_ID         - Task identifier for CFN Loop coordination
-#   ITERATION       - Current iteration number
-#   MODE            - Execution mode (cli, api, hybrid)
-#   PROMPT_FILE     - Path to file containing agent prompt
-#
-# Usage:
-#   ./execute-agent.sh
-##############################################################################
-
-set -euo pipefail
-
-# Validate required environment variables
-if [ -z "${AGENT_TYPE:-}" ]; then
-  echo "Error: AGENT_TYPE environment variable required" >&2
-  exit 1
-fi
-
-if [ -z "${PROMPT_FILE:-}" ] || [ ! -f "${PROMPT_FILE:-}" ]; then
-  echo "Error: PROMPT_FILE must be set and file must exist" >&2
-  exit 1
-fi
-
-# Default values
-AGENT_ID="${AGENT_ID:-${AGENT_TYPE}-1}"
-AGENT_MODEL="${AGENT_MODEL:-haiku}"
-TASK_ID="${TASK_ID:-}"
-ITERATION="${ITERATION:-1}"
-MODE="${MODE:-cli}"
-
-echo "=== Agent Execution ==="
-echo "Agent Type: $AGENT_TYPE"
-echo "Agent ID: $AGENT_ID"
-echo "Model: $AGENT_MODEL"
-echo "Task ID: ${TASK_ID:-N/A}"
-echo "Iteration: $ITERATION"
-echo "Mode: $MODE"
-echo ""
-
-# Read prompt from file
-PROMPT=$(cat "$PROMPT_FILE")
-
-# Determine API provider
-API_PROVIDER="anthropic"
-if [ -f ".claude/config/api-provider.json" ]; then
-  PROVIDER_CONFIG=$(cat .claude/config/api-provider.json)
-  if echo "$PROVIDER_CONFIG" | grep -q '"provider".*"zai"'; then
-    API_PROVIDER="zai"
-  fi
-fi
-
-if [ "${CLAUDE_API_PROVIDER:-}" = "zai" ]; then
-  API_PROVIDER="zai"
-fi
-
-echo "API Provider: $API_PROVIDER"
-echo ""
-
-# Map agent model to API model name
-case "$AGENT_MODEL" in
-  haiku)
-    API_MODEL="claude-3-5-haiku-20241022"
-    ;;
-  sonnet)
-    API_MODEL="claude-3-5-sonnet-20241022"
-    ;;
-  opus)
-    API_MODEL="claude-3-opus-20240229"
-    ;;
-  *)
-    echo "Warning: Unknown model '$AGENT_MODEL', defaulting to haiku" >&2
-    API_MODEL="claude-3-5-haiku-20241022"
-    ;;
-esac
-
-# For now, we'll simulate agent execution by echoing the prompt
-# TODO: Implement actual API calls when API client is ready
-echo "=== Agent Prompt (First 500 chars) ==="
-echo "$PROMPT" | head -c 500
-echo "..."
-echo ""
-echo "=== Agent Execution Status ==="
-echo "✅ Agent prompt prepared successfully"
-echo "⚠️  Note: Direct API execution not yet implemented"
-echo ""
-echo "Next Steps:"
-echo "1. Integrate with Claude API SDK"
-echo "2. Implement streaming response handling"
-echo "3. Add tool execution support"
-echo ""
-
-# For CFN Loop agents, simulate completion protocol
-if [ -n "$TASK_ID" ]; then
-  echo "=== CFN Loop Simulation ==="
-  echo "This agent would execute the following protocol:"
-  echo ""
-  echo "1. Execute task work"
-  echo "2. redis-cli lpush \"swarm:${TASK_ID}:${AGENT_ID}:done\" \"complete\""
-  echo "3. ./.claude/skills/redis-coordination/invoke-waiting-mode.sh report \\"
-  echo "     --task-id \"$TASK_ID\" \\"
-  echo "     --agent-id \"$AGENT_ID\" \\"
-  echo "     --confidence 0.85 \\"
-  echo "     --iteration $ITERATION"
-  echo "4. ./.claude/skills/redis-coordination/invoke-waiting-mode.sh enter \\"
-  echo "     --task-id \"$TASK_ID\" \\"
-  echo "     --agent-id \"$AGENT_ID\" \\"
-  echo "     --context \"iteration-complete\""
-  echo ""
-fi
-
-# Clean up prompt file
-rm -f "$PROMPT_FILE"
-
-# Exit with success (temporary until real execution implemented)
-exit 0