claude-flow-novice 2.10.5 → 2.10.6

package/claude-assets/skills/cfn-automatic-memory-persistence/SKILL.md

@@ -0,0 +1,73 @@
+# Automatic Memory Persistence Skill
+
+## Overview
+This skill provides automatic, structured persistence of agent outputs to a SQLite database, ensuring consistent memory tracking across CFN Loop workflows.
+
+## Key Components
+- `persist-agent-output.sh`: Primary script for saving agent outputs
+- `query-agent-history.sh`: Query and retrieve past agent outputs
+- `test-memory-persistence.sh`: Validation test suite
+
+## Memory Schema
+```json
+{
+  "agent/[agent-id]/output/[task-id]": {
+    "output": "Raw agent output text",
+    "confidence": 0.85,
+    "iteration": 1,
+    "timestamp": "2025-10-20T15:30:00Z",
+    "parsed_data": null
+  }
+}
+```
+
+## Integration Points
+- Loop 3 output processing
+- Loop 2 output processing
+- Product Owner decision parsing
+
+## Usage Examples
+
+### Persist Agent Output
+```bash
+./persist-agent-output.sh \
+  "task_authentication_v1" \  # Task ID
+  "backend-dev" \             # Agent ID
+  "Implemented JWT auth" \    # Output
+  0.85 \                      # Confidence
+  1                           # Iteration
+```
+
+### Query Agent History
+```bash
+# Get last 5 outputs for a specific agent
+./query-agent-history.sh "backend-dev" "" 5
+
+# Get outputs for a specific task
+./query-agent-history.sh "backend-dev" "task_authentication_v1"
+```
+
+## Security & Performance
+- ACL Level 1 (Read-only access)
+- Indexed by tags for fast retrieval
+- Minimal performance overhead
+- Escaped and normalized inputs
+
+## Testing
+Run comprehensive tests:
+```bash
+./test-memory-persistence.sh
+```
+
+## Sprint 7 Insights
+- **Confidence**: 0.95
+- **Priority**: 9
+- Provides robust, zero-configuration memory tracking
+- Eliminates manual output saving
+- Supports multi-iteration workflows
+
+## Best Practices
+- Always use script for output persistence
+- Do not modify SQLite database directly
+- Use query script for retrieval
+- Add structured parsing for complex outputs

package/claude-assets/skills/cfn-automatic-memory-persistence/persist-agent-output.sh

@@ -0,0 +1,49 @@
+#!/bin/bash
+# Saves agent output to SQLite via TypeScript adapter
+
+# Enable strict error handling
+set -euo pipefail
+
+# Input validation
+if [[ $# -lt 5 ]]; then
+    echo "Usage: $0 <TASK_ID> <AGENT_ID> <AGENT_OUTPUT> <CONFIDENCE> <ITERATION>"
+    exit 1
+fi
+
+TASK_ID="$1"
+AGENT_ID="$2"
+AGENT_OUTPUT="$3"
+CONFIDENCE="$4"
+ITERATION="$5"
+
+# Normalize confidence to float
+NORMALIZED_CONFIDENCE=$(printf "%.2f" "$CONFIDENCE")
+
+# Ensure output is properly escaped for JSON
+ESCAPED_OUTPUT=$(echo "$AGENT_OUTPUT" | jq -R -s '.')
+
+# Call TypeScript persistence layer
+node -e "
+const { SQLiteAdapter } = require('./src/cli/sqlite-adapter');
+const adapter = new SQLiteAdapter();
+
+const memoryKey = \`agent/${AGENT_ID}/output/${TASK_ID}\`;
+const outputRecord = {
+  output: $ESCAPED_OUTPUT,
+  confidence: parseFloat('$NORMALIZED_CONFIDENCE'),
+  iteration: parseInt('$ITERATION'),
+  timestamp: new Date().toISOString(),
+  parsed_data: null  // Optional: Add structured parsing logic here
+};
+
+try {
+  adapter.set(memoryKey, outputRecord, {
+    aclLevel: 1,  // Read-only access
+    tags: ['agent-output', \`agent-${AGENT_ID}\`, \`task-${TASK_ID}\`]
+  });
+  console.log(\`Successfully persisted output for agent ${AGENT_ID} in task ${TASK_ID}\`);
+} catch (error) {
+  console.error('Memory persistence failed:', error);
+  process.exit(1);
+}
+"

package/claude-assets/skills/cfn-automatic-memory-persistence/query-agent-history.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# Query agent output history from SQLite
+
+# Enable strict error handling
+set -euo pipefail
+
+# Input validation
+if [[ $# -lt 1 ]]; then
+    echo "Usage: $0 <AGENT_ID> [TASK_ID] [MAX_ENTRIES]"
+    exit 1
+fi
+
+AGENT_ID="$1"
+TASK_ID="${2:-}"
+MAX_ENTRIES="${3:-10}"
+
+# Call TypeScript query layer
+node -e "
+const { SQLiteAdapter } = require('./src/cli/sqlite-adapter');
+const adapter = new SQLiteAdapter();
+
+const queryPattern = '${AGENT_ID}' + (process.argv[2] ? '/output/${TASK_ID}' : '/output/*');
+
+try {
+  const results = adapter.query(queryPattern, {
+    limit: parseInt('${MAX_ENTRIES}'),
+    order: 'timestamp DESC'
+  });
+
+  console.log(JSON.stringify(results, null, 2));
+} catch (error) {
+  console.error('Query failed:', error);
+  process.exit(1);
+}
+" "${TASK_ID}"

package/claude-assets/skills/cfn-automatic-memory-persistence/test-memory-persistence.sh

@@ -0,0 +1,235 @@
+#!/bin/bash
+# Comprehensive Test Suite for Automatic Memory Persistence Skill
+
+set -e
+
+# Temporary test database
+TEST_DB="/tmp/test_memory_persistence_$(date +%s).sqlite"
+
+# Mock SQLite database creation for testing
+setup_mock_database() {
+    sqlite3 "$TEST_DB" << EOF
+CREATE TABLE agent_outputs (
+    task_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    output TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    iteration INTEGER NOT NULL,
+    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (task_id, agent_id, iteration)
+);
+CREATE INDEX idx_agent_task ON agent_outputs(agent_id, task_id);
+EOF
+}
+
+# Mock persist-agent-output.sh for testing
+mock_persist_agent_output() {
+    local task_id="$1"
+    local agent_id="$2"
+    local output="$3"
+    local confidence="$4"
+    local iteration="$5"
+
+    sqlite3 "$TEST_DB" << EOF
+INSERT OR REPLACE INTO agent_outputs
+(task_id, agent_id, output, confidence, iteration)
+VALUES
+('$task_id', '$agent_id', '$output', $confidence, $iteration);
+EOF
+}
+
+# Mock query-agent-history.sh for testing
+mock_query_agent_history() {
+    local agent_id="$1"
+    local task_id="$2"
+
+    sqlite3 "$TEST_DB" << EOF
+SELECT task_id, agent_id, output, confidence, iteration
+FROM agent_outputs
+WHERE agent_id = '$agent_id' AND task_id = '$task_id';
+EOF
+}
+
+# Test 1: Successful output persistence with complete fields
+test_output_persistence() {
+    local task_id="test_task_complete_$(date +%s)"
+    local agent_id="test_agent_complete"
+    local test_output="Comprehensive agent output with complete details"
+    local confidence=0.95
+    local iteration=1
+
+    # Persist output
+    mock_persist_agent_output "$task_id" "$agent_id" "$test_output" "$confidence" "$iteration"
+
+    # Query and validate
+    local query_result
+    query_result=$(mock_query_agent_history "$agent_id" "$task_id")
+
+    if [ -z "$query_result" ]; then
+        echo "Test 1 failed: No output retrieved for complete fields"
+        return 1
+    fi
+
+    # Validate specific fields (using different field splitting)
+    local retrieved_task_id retrieved_agent_id retrieved_output retrieved_confidence retrieved_iteration
+    IFS='|' read -r retrieved_task_id retrieved_agent_id retrieved_output retrieved_confidence retrieved_iteration <<< "$query_result"
+
+    if [ "$retrieved_task_id" != "$task_id" ] ||
+       [ "$retrieved_agent_id" != "$agent_id" ] ||
+       [ "$retrieved_output" != "$test_output" ] ||
+       [ "$(echo "$retrieved_confidence != $confidence" | bc)" -eq 1 ] ||
+       [ "$retrieved_iteration" != "$iteration" ]; then
+        echo "Test 1 failed: Retrieved data does not match persisted data"
+        return 1
+    fi
+
+    echo "Test 1: Complete output persistence passed"
+    return 0
+}
+
+# Test 2: Multiple agent outputs for same task
+test_multiple_agent_outputs() {
+    local task_id="test_task_multiple_$(date +%s)"
+    local agent_id_1="test_agent_1"
+    local agent_id_2="test_agent_2"
+    local test_output_1="First agent output"
+    local test_output_2="Second agent output"
+    local confidence_1=0.85
+    local confidence_2=0.90
+    local iteration_1=1
+    local iteration_2=2
+
+    # Persist outputs for multiple agents
+    mock_persist_agent_output "$task_id" "$agent_id_1" "$test_output_1" "$confidence_1" "$iteration_1"
+    mock_persist_agent_output "$task_id" "$agent_id_2" "$test_output_2" "$confidence_2" "$iteration_2"
+
+    # Query and validate multiple agent outputs
+    local query_result_1 query_result_2
+    query_result_1=$(mock_query_agent_history "$agent_id_1" "$task_id")
+    query_result_2=$(mock_query_agent_history "$agent_id_2" "$task_id")
+
+    if [ -z "$query_result_1" ] || [ -z "$query_result_2" ]; then
+        echo "Test 2 failed: Missing outputs for multiple agents"
+        return 1
+    fi
+
+    echo "Test 2: Multiple agent outputs for same task passed"
+    return 0
+}
+
+# Test 3: Error handling for invalid/missing data
+test_invalid_data_handling() {
+    local task_id="test_task_invalid_$(date +%s)"
+    local agent_id="test_agent_invalid"
+
+    # Attempt to query non-existent data
+    local query_result
+    query_result=$(mock_query_agent_history "$agent_id" "$task_id")
+
+    if [ -n "$query_result" ]; then
+        echo "Test 3 failed: Non-empty result for non-existent data"
+        return 1
+    fi
+
+    echo "Test 3: Invalid data handling passed"
+    return 0
+}
+
+# Test 4: Iteration and confidence tracking
+test_iteration_confidence_tracking() {
+    local task_id="test_task_iterations_$(date +%s)"
+    local agent_id="test_agent_iterations"
+    local outputs=("Initial output" "Improved output" "Final output")
+    local confidences=(0.70 0.85 0.95)
+    local iterations=(1 2 3)
+
+    # Persist multiple iterations with increasing confidence
+    for i in "${!outputs[@]}"; do
+        mock_persist_agent_output "$task_id" "$agent_id" "${outputs[i]}" "${confidences[i]}" "${iterations[i]}"
+    done
+
+    # Verify iterations are tracked
+    local iteration_count
+    iteration_count=$(sqlite3 "$TEST_DB" "SELECT COUNT(DISTINCT iteration) FROM agent_outputs WHERE task_id = '$task_id' AND agent_id = '$agent_id';")
+
+    if [ "$iteration_count" -ne 3 ]; then
+        echo "Test 4 failed: Incorrect iteration tracking"
+        return 1
+    fi
+
+    echo "Test 4: Iteration and confidence tracking passed"
+    return 0
+}
+
+# Test 5: ACL-level validation simulation
+test_acl_simulation() {
+    local task_id="test_task_acl_$(date +%s)"
+    local authorized_agent="authorized_agent"
+    local unauthorized_agent="unauthorized_agent"
+    local output="Confidential agent output"
+    local confidence=0.90
+    local iteration=1
+
+    # Simulate persisting output
+    mock_persist_agent_output "$task_id" "$authorized_agent" "$output" "$confidence" "$iteration"
+
+    # Verify authorized agent can access
+    local auth_query_result
+    auth_query_result=$(mock_query_agent_history "$authorized_agent" "$task_id")
+
+    if [ -z "$auth_query_result" ]; then
+        echo "Test 5 (Part A) failed: Authorized agent cannot access output"
+        return 1
+    fi
+
+    # Simulate unauthorized access attempt
+    local unauth_query_result
+    unauth_query_result=$(mock_query_agent_history "$unauthorized_agent" "$task_id")
+
+    if [ -n "$unauth_query_result" ]; then
+        echo "Test 5 (Part B) failed: Unauthorized agent could access output"
+        return 1
+    fi
+
+    echo "Test 5: ACL-level validation simulation passed"
+    return 0
+}
+
+# Main test runner
+main() {
+    echo "Running Comprehensive Memory Persistence Tests..."
+
+    # Setup test database
+    setup_mock_database
+
+    # Run tests
+    local total_tests=5
+    local passed_tests=0
+
+    # Execute each test
+    test_output_persistence && passed_tests=$((passed_tests+1))
+    test_multiple_agent_outputs && passed_tests=$((passed_tests+1))
+    test_invalid_data_handling && passed_tests=$((passed_tests+1))
+    test_iteration_confidence_tracking && passed_tests=$((passed_tests+1))
+    test_acl_simulation && passed_tests=$((passed_tests+1))
+
+    # Calculate confidence
+    local confidence=$(echo "scale=2; $passed_tests / $total_tests" | bc)
+
+    # Cleanup test database
+    rm -f "$TEST_DB"
+
+    # Report results
+    if [ "$passed_tests" -eq "$total_tests" ]; then
+        echo "All Memory Persistence Tests Passed!"
+        echo "Test Confidence: $confidence"
+        exit 0
+    else
+        echo "Memory Persistence Test Suite Failed: $passed_tests/$total_tests tests passed"
+        echo "Test Confidence: $confidence"
+        exit 1
+    fi
+}
+
+# Execute main test runner
+main

package/claude-assets/skills/cfn-complexity-estimator/SKILL.md

@@ -0,0 +1,96 @@
+# Task Complexity Estimator
+
+**Version:** 1.0.0
+**Purpose:** Estimate task complexity and predict iteration requirements for CFN v3
+
+## Overview
+
+Analyzes task description to estimate:
+- Complexity level (low, medium, high)
+- Estimated iterations (2-7 range)
+- Confidence in estimate
+
+## Complexity Factors
+
+### Factor 1: Step Count
+- Count distinct action verbs
+- Count deliverable files mentioned
+- Count integration points
+
+### Factor 2: Security/Compliance
+- Security keywords → +1 complexity
+- Compliance requirements → +1 complexity
+- Authentication/authorization → +1 complexity
+
+### Factor 3: Scope
+- Single file → low
+- Multiple files (2-5) → medium
+- System-wide (>5 files) → high
+
+### Factor 4: Dependencies
+- External APIs → +1 complexity
+- Database changes → +1 complexity
+- Multiple services → +1 complexity
+
+### Factor 5: Technology Stack
+- Familiar tech → -1 complexity
+- New/unfamiliar tech → +1 complexity
+- Cutting-edge/experimental → +2 complexity
+
+## Estimation Formula
+
+```
+Base Iterations = 2
+
++ Step Count / 3
++ Security factor (0-2)
++ Scope factor (0-3)
++ Dependencies factor (0-3)
++ Tech stack factor (-1 to +2)
+
+Capped at: 7 iterations (high complexity max)
+```
+
+## Complexity Mapping
+
+| Total Score | Complexity | Estimated Iterations |
+|-------------|------------|---------------------|
+| 0-2 | Low | 2 |
+| 3-4 | Medium | 3-4 |
+| 5+ | High | 5-7 |
+
+## Usage
+
+```bash
+ESTIMATE=$(./.claude/skills/complexity-estimator/estimate-complexity.sh \
+  --task-type "software-development" \
+  --description "Implement JWT authentication with refresh tokens and RBAC")
+
+echo "$ESTIMATE" | jq '.complexity'           # "high"
+echo "$ESTIMATE" | jq '.estimated_iterations' # 5
+echo "$ESTIMATE" | jq '.confidence'           # 0.75
+```
+
+## Output Format
+
+```json
+{
+  "complexity": "low|medium|high",
+  "estimated_iterations": 2-7,
+  "confidence": 0.0-1.0,
+  "factors": {
+    "step_count": 2,
+    "security": 1,
+    "scope": 2,
+    "dependencies": 1,
+    "tech_stack": 0
+  },
+  "reasoning": "High complexity due to security requirements (JWT, RBAC), multiple integration points, and estimated 6+ file changes."
+}
+```
+
+## Integration
+
+Used by:
+- `.claude/agents/cfn-v3-coordinator.md` - Set max_iterations, estimated_iterations
+- Playbook system - Store complexity patterns

package/claude-assets/skills/cfn-complexity-estimator/estimate-complexity.sh

@@ -0,0 +1,144 @@
+#!/bin/bash
+
+# Task Complexity Estimator for CFN v3
+# Removed set -o pipefail for compatibility
+
+TASK_TYPE=""
+DESCRIPTION=""
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --task-type) TASK_TYPE="$2"; shift 2 ;;
+    --description) DESCRIPTION="$2"; shift 2 ;;
+    *) echo "Unknown: $1"; exit 1 ;;
+  esac
+done
+
+if [ -z "$DESCRIPTION" ]; then
+  echo "Usage: estimate-complexity.sh --task-type TYPE --description 'text'" >&2
+  exit 1
+fi
+
+DESC_LOWER=$(echo "$DESCRIPTION" | tr '[:upper:]' '[:lower:]')
+
+# Helper function to check keyword
+has_keyword() {
+  local keyword="$1"
+  echo "$DESC_LOWER" | grep -qi "$keyword"
+  return $?
+}
+
+# Factor 1: Step Count
+# Count action verbs
+ACTION_VERBS="implement build create add update modify refactor deploy configure setup integrate test"
+STEP_COUNT=0
+for verb in $ACTION_VERBS; do
+  if has_keyword "$verb"; then
+    ((STEP_COUNT++)) || true
+  fi
+done
+
+STEP_SCORE=$((STEP_COUNT / 3))
+
+# Factor 2: Security/Compliance
+SECURITY_SCORE=0
+if has_keyword "security\|authentication\|authorization\|jwt\|oauth\|rbac"; then
+  ((SECURITY_SCORE++))
+fi
+if has_keyword "compliance\|gdpr\|hipaa\|pci\|sox"; then
+  ((SECURITY_SCORE++))
+fi
+if has_keyword "encryption\|ssl\|tls\|certificate"; then
+  ((SECURITY_SCORE++))
+fi
+
+# Factor 3: Scope
+SCOPE_SCORE=0
+if has_keyword "file\|files"; then
+  FILE_COUNT=$(echo "$DESC_LOWER" | grep -o "file" | wc -l)
+  if [ "$FILE_COUNT" -gt 5 ]; then
+    SCOPE_SCORE=3
+  elif [ "$FILE_COUNT" -ge 2 ]; then
+    SCOPE_SCORE=2
+  else
+    SCOPE_SCORE=1
+  fi
+fi
+if has_keyword "system-wide\|entire system\|all"; then
+  SCOPE_SCORE=3
+fi
+
+# Factor 4: Dependencies
+DEPENDENCY_SCORE=0
+if has_keyword "api\|external service\|third-party"; then
+  ((DEPENDENCY_SCORE++))
+fi
+if has_keyword "database\|sql\|schema\|migration"; then
+  ((DEPENDENCY_SCORE++))
+fi
+if has_keyword "microservice\|services\|distributed"; then
+  ((DEPENDENCY_SCORE++))
+fi
+
+# Factor 5: Tech Stack
+TECH_SCORE=0
+if has_keyword "new technology\|learning\|unfamiliar"; then
+  ((TECH_SCORE++))
+fi
+if has_keyword "experimental\|cutting-edge\|beta"; then
+  TECH_SCORE=2
+fi
+if has_keyword "legacy\|migration\|refactor"; then
+  ((TECH_SCORE++))
+fi
+
+# Calculate total score
+TOTAL_SCORE=$((STEP_SCORE + SECURITY_SCORE + SCOPE_SCORE + DEPENDENCY_SCORE + TECH_SCORE))
+
+# Determine complexity and iterations
+if [ "$TOTAL_SCORE" -le 2 ]; then
+  COMPLEXITY="low"
+  ESTIMATED_ITERATIONS=2
+  CONFIDENCE=0.80
+elif [ "$TOTAL_SCORE" -le 4 ]; then
+  COMPLEXITY="medium"
+  ESTIMATED_ITERATIONS=$((TOTAL_SCORE))
+  CONFIDENCE=0.75
+else
+  COMPLEXITY="high"
+  ESTIMATED_ITERATIONS=$((TOTAL_SCORE))
+  if [ "$ESTIMATED_ITERATIONS" -gt 7 ]; then
+    ESTIMATED_ITERATIONS=7
+  fi
+  CONFIDENCE=0.70
+fi
+
+# Build reasoning
+REASONING="Complexity: $COMPLEXITY"
+if [ "$SECURITY_SCORE" -gt 0 ]; then
+  REASONING="$REASONING. Security requirements detected ($SECURITY_SCORE factors)."
+fi
+if [ "$SCOPE_SCORE" -ge 2 ]; then
+  REASONING="$REASONING. Multi-file or system-wide scope."
+fi
+if [ "$DEPENDENCY_SCORE" -gt 0 ]; then
+  REASONING="$REASONING. External dependencies ($DEPENDENCY_SCORE)."
+fi
+
+# Build JSON output
+cat <<EOF
+{
+  "complexity": "$COMPLEXITY",
+  "estimated_iterations": $ESTIMATED_ITERATIONS,
+  "confidence": $CONFIDENCE,
+  "factors": {
+    "step_count": $STEP_COUNT,
+    "security": $SECURITY_SCORE,
+    "scope": $SCOPE_SCORE,
+    "dependencies": $DEPENDENCY_SCORE,
+    "tech_stack": $TECH_SCORE,
+    "total": $TOTAL_SCORE
+  },
+  "reasoning": "$REASONING"
+}
+EOF

package/claude-assets/skills/cfn-config-management/README.md

@@ -0,0 +1,42 @@
+# Configuration Management Skill
+
+## Prerequisites
+- Node.js 18+
+- jq
+- ajv-cli
+
+## Installation
+```bash
+npm install -g ajv-cli
+```
+
+## Configuration Commands
+```bash
+# Get a configuration value
+./manage-config.sh get redis.host
+
+# Set a configuration value
+./manage-config.sh set agent.log_level "debug"
+
+# List all configurations
+./manage-config.sh list
+
+# Reset to defaults
+./manage-config.sh reset
+```
+
+## Dependency Check
+```bash
+./check-dependencies.sh
+```
+
+## Permissions
+```bash
+chmod +x manage-config.sh
+chmod +x check-dependencies.sh
+```
+
+## Security Notes
+- Configuration is stored in `~/.claude-flow-config.json`
+- Validated against JSON schema
+- Atomic updates prevent race conditions