claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/cfn-extras/skills/google-sheets-sprint-order/SKILL.md

@@ -1,277 +0,0 @@
-# Google Sheets Sprint Ordering
-
-## Overview
-Resolves sprint dependencies and generates optimal execution order using topological sorting to ensure micro-sprints execute in the correct sequence.
-
-## Purpose
-Prevents execution failures by ensuring prerequisite sprints complete before dependent sprints begin. Creates a directed acyclic graph (DAG) of sprint dependencies.
-
-## Dependency Rules
-
-### Sprint Type Dependencies
-
-| Sprint Type | Depends On | Reason |
-|-------------|------------|--------|
-| Schema | None | Foundation sprint |
-| Data | Schema | Requires defined columns/structure |
-| Formula | Schema, Data | Requires columns and populated data |
-| Formatting | Data | Requires data to format |
-| Integration | Schema | Requires defined structure for external data |
-| Automation | All | Scripts reference all previous work |
-
-### Custom Dependencies
-In addition to type-based dependencies, specific sprints may have explicit dependencies based on operation content:
-- Formula referencing imported data → depends on Integration sprint
-- Conditional formatting based on formula → depends on Formula sprint
-- Script accessing specific sheet → depends on Schema sprint creating that sheet
-
-## Ordering Algorithm
-
-### Input
-Sprints JSON from decomposition skill:
-```json
-{
-  "sprints": [
-    {
-      "sprint_id": "schema_001",
-      "sprint_type": "schema",
-      "dependencies": []
-    },
-    {
-      "sprint_id": "data_001",
-      "sprint_type": "data",
-      "dependencies": ["schema"]
-    }
-  ]
-}
-```
-
-### Process
-1. **Build Dependency Graph:** Create adjacency list of sprint dependencies
-2. **Detect Cycles:** Ensure no circular dependencies exist
-3. **Topological Sort:** Order sprints using Kahn's algorithm
-4. **Identify Parallelizable Sprints:** Find sprints at same level (can run in parallel)
-5. **Generate Execution Plan:** Output ordered list with parallelization hints
-
-### Output
-```json
-{
-  "execution_order": [
-    {
-      "level": 0,
-      "parallel_group": [
-        {
-          "sprint_id": "schema_001",
-          "sprint_type": "schema",
-          "can_parallelize": false
-        }
-      ]
-    },
-    {
-      "level": 1,
-      "parallel_group": [
-        {
-          "sprint_id": "data_001",
-          "sprint_type": "data",
-          "can_parallelize": false
-        },
-        {
-          "sprint_id": "integration_001",
-          "sprint_type": "integration",
-          "can_parallelize": true
-        }
-      ]
-    }
-  ],
-  "total_levels": 4,
-  "critical_path_length": 6,
-  "parallelization_opportunities": 2
-}
-```
-
-## Usage
-
-### CLI
-```bash
-./.claude/cfn-extras/skills/google-sheets-sprint-order/order-sprints.sh \
-  --sprints-json /tmp/google-sheets-sprints.json \
-  --output /tmp/execution-plan.json
-```
-
-### From Coordinator
-```bash
-# Generate execution plan
-EXEC_PLAN=$(bash ./.claude/cfn-extras/skills/google-sheets-sprint-order/order-sprints.sh \
-  --sprints-json "$SPRINTS_JSON_PATH")
-
-# Extract level count
-LEVELS=$(echo "$EXEC_PLAN" | jq -r '.total_levels')
-
-# Execute level by level
-for level in $(seq 0 $((LEVELS - 1))); do
-  PARALLEL_GROUP=$(echo "$EXEC_PLAN" | jq -r ".execution_order[$level].parallel_group")
-
-  # Spawn sprints in this level (can parallelize if multiple)
-  # ...
-done
-```
-
-## Cycle Detection
-
-### Valid DAG
-```
-schema_001 → data_001 → formula_001 → automation_001
-           ↘ integration_001 ↗
-```
-
-### Invalid (Circular Dependency)
-```
-formula_001 → automation_001 → data_001 → formula_001
-```
-
-**Error Output:**
-```json
-{
-  "error": "CIRCULAR_DEPENDENCY",
-  "message": "Cycle detected in sprint dependencies",
-  "cycle_path": ["formula_001", "automation_001", "data_001", "formula_001"],
-  "suggestion": "Remove dependency or restructure operations"
-}
-```
-
-## Parallelization Strategy
-
-### Safe to Parallelize
-Sprints at the same dependency level with:
-- Different target sheets
-- No shared named ranges
-- Different data sources
-- Independent formulas
-
-### Not Safe to Parallelize
-Sprints that:
-- Write to same sheet
-- Reference same cells
-- Modify shared named ranges
-- Have API quota concerns (serialize to stay under limit)
-
-## Critical Path Analysis
-
-**Critical Path:** Longest sequence of dependent sprints
-**Importance:** Determines minimum execution time
-
-**Example:**
-```
-Sprint Sequence: schema_001 → data_001 → formula_001 → formula_002 → automation_001
-Critical Path Length: 5 sprints
-Estimated Time: 5 * avg_sprint_duration
-```
-
-**Optimization Opportunities:**
-- Parallelize non-critical sprints
-- Batch operations within sprints
-- Use bulk API calls where possible
-
-## Integration with CFN Loop
-
-### Coordinator Workflow
-```bash
-# 1. Get decomposed sprints
-SPRINTS_JSON=$(decompose.sh --request "$USER_REQUEST")
-
-# 2. Generate execution plan
-EXEC_PLAN=$(order-sprints.sh --sprints-json <(echo "$SPRINTS_JSON"))
-
-# 3. Execute by level
-LEVELS=$(echo "$EXEC_PLAN" | jq -r '.total_levels')
-
-for level in $(seq 0 $((LEVELS - 1))); do
-  echo "Executing level $level..."
-
-  # Get sprints at this level
-  SPRINT_IDS=$(echo "$EXEC_PLAN" | jq -r ".execution_order[$level].parallel_group[].sprint_id")
-
-  # Execute sprints (parallel if multiple)
-  for sprint_id in $SPRINT_IDS; do
-    # Spawn CFN Loop for this sprint
-    ./.claude/skills/cfn-loop-orchestration/orchestrate.sh \
-      --task-id "$TASK_ID" \
-      --sprint "$sprint_id" \
-      --mode standard &
-  done
-
-  # Wait for level completion
-  wait
-done
-```
-
-## Validation Rules
-
-### Pre-Execution
-- No circular dependencies
-- All referenced dependencies exist
-- Dependency types are valid (e.g., Data can't depend on Automation)
-
-### Post-Ordering
-- All sprints appear exactly once in execution order
-- Sprint count matches input
-- Levels are sequential (0, 1, 2, ...)
-- Dependencies satisfied (dependent sprint appears after prerequisite)
-
-## Error Handling
-
-### Missing Dependency
-```json
-{
-  "error": "MISSING_DEPENDENCY",
-  "message": "Sprint 'formula_001' depends on 'data_002' which does not exist",
-  "sprint_id": "formula_001",
-  "missing_dependency": "data_002"
-}
-```
-
-### Invalid Dependency Type
-```json
-{
-  "error": "INVALID_DEPENDENCY",
-  "message": "Schema sprint cannot depend on Automation sprint (reverse dependency)",
-  "sprint_id": "schema_002",
-  "invalid_dependency": "automation_001"
-}
-```
-
-## Testing
-
-Test script: `./.claude/cfn-extras/skills/google-sheets-sprint-order/test-ordering.sh`
-
-**Test Cases:**
-1. Simple linear dependency chain
-2. Multiple parallel sprints at same level
-3. Complex DAG with multiple paths
-4. Circular dependency detection
-5. Missing dependency handling
-6. Critical path calculation
-
-**Expected Pass Rate:** ≥0.95 (Standard mode)
-
-## Performance
-
-### Time Complexity
-- Cycle Detection: O(V + E) where V = sprints, E = dependencies
-- Topological Sort: O(V + E)
-- Overall: O(V + E)
-
-### Space Complexity
-- Adjacency List: O(V + E)
-- Visit Tracking: O(V)
-- Overall: O(V + E)
-
-### Scalability
-- Tested with up to 50 sprints
-- Sub-second execution for typical workloads (5-15 sprints)
-- Scales linearly with sprint count
-
-## References
-- Kahn's Algorithm: https://en.wikipedia.org/wiki/Topological_sorting#Kahn's_algorithm
-- DAG Validation: `./.claude/cfn-extras/docs/DEPENDENCY_VALIDATION.md`
-- CFN Loop Integration: `CLAUDE.md` Section 4

package/claude-assets/cfn-extras/skills/google-sheets-sprint-order/order-sprints.sh

@@ -1,233 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Google Sheets Sprint Ordering Script
-# Resolves dependencies and generates execution plan using topological sort
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Default values
-SPRINTS_JSON=""
-OUTPUT_FILE=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --sprints-json)
-      SPRINTS_JSON="$2"
-      shift 2
-      ;;
-    --output)
-      OUTPUT_FILE="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [[ -z "$SPRINTS_JSON" ]]; then
-  echo "Error: --sprints-json is required" >&2
-  exit 1
-fi
-
-# Read sprints JSON (from file or stdin)
-if [[ -f "$SPRINTS_JSON" ]]; then
-  SPRINTS_DATA=$(cat "$SPRINTS_JSON")
-else
-  SPRINTS_DATA="$SPRINTS_JSON"
-fi
-
-# Validate JSON
-if ! echo "$SPRINTS_DATA" | jq empty 2>/dev/null; then
-  echo "Error: Invalid JSON in sprints data" >&2
-  exit 1
-fi
-
-# Extract sprints array
-SPRINTS=$(echo "$SPRINTS_DATA" | jq -c '.sprints')
-TOTAL_SPRINTS=$(echo "$SPRINTS" | jq 'length')
-
-if [[ $TOTAL_SPRINTS -eq 0 ]]; then
-  echo "Error: No sprints found in input" >&2
-  exit 1
-fi
-
-# Build dependency graph
-declare -A adjacency_list
-declare -A in_degree
-declare -A sprint_types
-
-for i in $(seq 0 $((TOTAL_SPRINTS - 1))); do
-  SPRINT=$(echo "$SPRINTS" | jq -c ".[$i]")
-  SPRINT_ID=$(echo "$SPRINT" | jq -r '.sprint_id')
-  SPRINT_TYPE=$(echo "$SPRINT" | jq -r '.sprint_type')
-  DEPENDENCIES=$(echo "$SPRINT" | jq -r '.dependencies[]' 2>/dev/null || true)
-
-  # Store sprint type
-  sprint_types[$SPRINT_ID]="$SPRINT_TYPE"
-
-  # Initialize in-degree
-  in_degree[$SPRINT_ID]=0
-
-  # Process dependencies
-  for dep_type in $DEPENDENCIES; do
-    # Find all sprints of this dependency type
-    for j in $(seq 0 $((TOTAL_SPRINTS - 1))); do
-      DEP_SPRINT=$(echo "$SPRINTS" | jq -c ".[$j]")
-      DEP_SPRINT_ID=$(echo "$DEP_SPRINT" | jq -r '.sprint_id')
-      DEP_SPRINT_TYPE=$(echo "$DEP_SPRINT" | jq -r '.sprint_type')
-
-      if [[ "$DEP_SPRINT_TYPE" == "$dep_type" ]]; then
-        # Add edge from dependency to current sprint
-        if [[ -z "${adjacency_list[$DEP_SPRINT_ID]:-}" ]]; then
-          adjacency_list[$DEP_SPRINT_ID]="$SPRINT_ID"
-        else
-          adjacency_list[$DEP_SPRINT_ID]="${adjacency_list[$DEP_SPRINT_ID]} $SPRINT_ID"
-        fi
-
-        # Increment in-degree
-        in_degree[$SPRINT_ID]=$((in_degree[$SPRINT_ID] + 1))
-      fi
-    done
-  done
-done
-
-# Ensure all sprints have an in-degree entry
-for i in $(seq 0 $((TOTAL_SPRINTS - 1))); do
-  SPRINT_ID=$(echo "$SPRINTS" | jq -r ".[$i].sprint_id")
-  if [[ -z "${in_degree[$SPRINT_ID]:-}" ]]; then
-    in_degree[$SPRINT_ID]=0
-  fi
-done
-
-# Kahn's algorithm for topological sort
-declare -a execution_levels
-declare -a current_level
-declare -a next_level
-
-# Find all sprints with in-degree 0 (no dependencies)
-for sprint_id in "${!in_degree[@]}"; do
-  if [[ ${in_degree[$sprint_id]} -eq 0 ]]; then
-    current_level+=("$sprint_id")
-  fi
-done
-
-level=0
-total_processed=0
-
-while [[ ${#current_level[@]} -gt 0 ]]; do
-  # Store current level
-  execution_levels[$level]="${current_level[*]}"
-
-  # Process each sprint in current level
-  for sprint_id in "${current_level[@]}"; do
-    total_processed=$((total_processed + 1))
-
-    # Get all dependents (children) of this sprint
-    dependents="${adjacency_list[$sprint_id]:-}"
-
-    for dependent in $dependents; do
-      # Decrement in-degree
-      in_degree[$dependent]=$((in_degree[$dependent] - 1))
-
-      # If in-degree becomes 0, add to next level
-      if [[ ${in_degree[$dependent]} -eq 0 ]]; then
-        next_level+=("$dependent")
-      fi
-    done
-  done
-
-  # Move to next level
-  current_level=("${next_level[@]}")
-  next_level=()
-  level=$((level + 1))
-done
-
-# Check for cycles (if not all sprints processed)
-if [[ $total_processed -ne $TOTAL_SPRINTS ]]; then
-  # Find remaining sprints (part of cycle)
-  remaining_sprints=()
-  for i in $(seq 0 $((TOTAL_SPRINTS - 1))); do
-    SPRINT_ID=$(echo "$SPRINTS" | jq -r ".[$i].sprint_id")
-    if [[ ${in_degree[$SPRINT_ID]} -gt 0 ]]; then
-      remaining_sprints+=("$SPRINT_ID")
-    fi
-  done
-
-  cat <<EOF
-{
-  "error": "CIRCULAR_DEPENDENCY",
-  "message": "Cycle detected in sprint dependencies",
-  "sprints_in_cycle": [$(printf '"%s"' "${remaining_sprints[0]}"; printf ', "%s"' "${remaining_sprints[@]:1}")],
-  "suggestion": "Remove dependency or restructure operations"
-}
-EOF
-  exit 1
-fi
-
-# Generate execution plan JSON
-echo "{"
-echo "  \"execution_order\": ["
-
-for lvl in $(seq 0 $((level - 1))); do
-  [[ $lvl -gt 0 ]] && echo ","
-
-  IFS=' ' read -ra sprint_ids <<< "${execution_levels[$lvl]}"
-
-  echo "    {"
-  echo "      \"level\": $lvl,"
-  echo "      \"parallel_group\": ["
-
-  for idx in "${!sprint_ids[@]}"; do
-    sprint_id="${sprint_ids[$idx]}"
-    sprint_type="${sprint_types[$sprint_id]}"
-
-    # Determine if can parallelize (safe if multiple sprints at same level and different sheets)
-    can_parallelize="false"
-    if [[ ${#sprint_ids[@]} -gt 1 ]]; then
-      can_parallelize="true"
-    fi
-
-    [[ $idx -gt 0 ]] && echo ","
-
-    cat <<EOF
-        {
-          "sprint_id": "$sprint_id",
-          "sprint_type": "$sprint_type",
-          "can_parallelize": $can_parallelize
-        }
-EOF
-  done
-
-  echo "      ]"
-  echo -n "    }"
-done
-
-echo ""
-echo "  ],"
-
-# Calculate critical path (longest path)
-critical_path_length=0
-for lvl in $(seq 0 $((level - 1))); do
-  IFS=' ' read -ra sprint_ids <<< "${execution_levels[$lvl]}"
-  critical_path_length=$((critical_path_length + 1))
-done
-
-# Count parallelization opportunities
-parallelization_opportunities=0
-for lvl in $(seq 0 $((level - 1))); do
-  IFS=' ' read -ra sprint_ids <<< "${execution_levels[$lvl]}"
-  if [[ ${#sprint_ids[@]} -gt 1 ]]; then
-    parallelization_opportunities=$((parallelization_opportunities + 1))
-  fi
-done
-
-echo "  \"total_levels\": $level,"
-echo "  \"critical_path_length\": $critical_path_length,"
-echo "  \"parallelization_opportunities\": $parallelization_opportunities"
-echo "}"