claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/cfn-extras/skills/google-sheets-decomposition/decompose.sh

@@ -1,313 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Google Sheets Request Decomposition Script
-# Breaks complex requests into atomic micro-sprints with dependencies
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Configuration
-MAX_SPRINTS=15
-MAX_OPS_PER_SPRINT=5
-MAX_OPS_INTEGRATION=3
-MAX_OPS_AUTOMATION=3
-MAX_API_CALLS_TOTAL=100
-
-# Default values
-REQUEST=""
-MODE="standard"
-OUTPUT_FILE=""
-CURRENT_STATE=""
-
-# Parse arguments
-while [[ $# -gt 0 ]]; do
-  case $1 in
-    --request)
-      REQUEST="$2"
-      shift 2
-      ;;
-    --mode)
-      MODE="$2"
-      shift 2
-      ;;
-    --output)
-      OUTPUT_FILE="$2"
-      shift 2
-      ;;
-    --current-state)
-      CURRENT_STATE="$2"
-      shift 2
-      ;;
-    *)
-      echo "Unknown option: $1" >&2
-      exit 1
-      ;;
-  esac
-done
-
-# Validate required arguments
-if [[ -z "$REQUEST" ]]; then
-  echo "Error: --request is required" >&2
-  exit 1
-fi
-
-# Validate request is not too vague
-if [[ ${#REQUEST} -lt 10 ]]; then
-  cat <<EOF
-{
-  "error": "INVALID_REQUEST",
-  "message": "Request too vague: '$REQUEST'",
-  "suggestion": "Specify concrete operations (e.g., 'add revenue column', 'create pivot table')"
-}
-EOF
-  exit 1
-fi
-
-# Function to classify operation into sprint type
-classify_operation() {
-  local operation="$1"
-
-  # Schema operations
-  if echo "$operation" | grep -qiE "create sheet|add column|rename|define range|structure"; then
-    echo "schema"
-    return
-  fi
-
-  # Data operations
-  if echo "$operation" | grep -qiE "import|transform|merge|clean|populate|data"; then
-    echo "data"
-    return
-  fi
-
-  # Formula operations
-  if echo "$operation" | grep -qiE "formula|calculate|sum|average|validation|vlookup"; then
-    echo "formula"
-    return
-  fi
-
-  # Formatting operations
-  if echo "$operation" | grep -qiE "format|style|color|conditional format|width|height"; then
-    echo "formatting"
-    return
-  fi
-
-  # Integration operations
-  if echo "$operation" | grep -qiE "api|import.*from|connect|external|database|importrange"; then
-    echo "integration"
-    return
-  fi
-
-  # Automation operations
-  if echo "$operation" | grep -qiE "script|trigger|automat|custom function|apps script"; then
-    echo "automation"
-    return
-  fi
-
-  # Default to data if unclear
-  echo "data"
-}
-
-# Function to extract operations from request
-extract_operations() {
-  local request="$1"
-
-  # Simple extraction: split by common delimiters
-  # In production, this would use NLP or more sophisticated parsing
-  echo "$request" | sed 's/[,;.]/\n/g' | sed 's/and /\n/g' | sed '/^$/d'
-}
-
-# Function to generate sprint ID
-generate_sprint_id() {
-  local sprint_type="$1"
-  local counter="$2"
-  printf "%s_%03d" "$sprint_type" "$counter"
-}
-
-# Function to estimate API calls for operation
-estimate_api_calls() {
-  local operation="$1"
-  local sprint_type="$2"
-
-  case "$sprint_type" in
-    schema) echo "1" ;;
-    data) echo "2" ;;
-    formula) echo "1" ;;
-    formatting) echo "1" ;;
-    integration) echo "3" ;;
-    automation) echo "2" ;;
-    *) echo "1" ;;
-  esac
-}
-
-# Main decomposition logic
-decompose_request() {
-  local request="$1"
-
-  # Extract operations
-  mapfile -t operations < <(extract_operations "$request")
-
-  if [[ ${#operations[@]} -eq 0 ]]; then
-    cat <<EOF
-{
-  "error": "NO_OPERATIONS_FOUND",
-  "message": "Could not extract operations from request",
-  "request": "$request"
-}
-EOF
-    return 1
-  fi
-
-  # Classify and group operations
-  declare -A sprint_groups
-  declare -A sprint_counters=(
-    [schema]=1
-    [data]=1
-    [formula]=1
-    [formatting]=1
-    [integration]=1
-    [automation]=1
-  )
-
-  for op in "${operations[@]}"; do
-    # Skip empty lines
-    [[ -z "$op" ]] && continue
-
-    # Trim whitespace
-    op="$(echo "$op" | xargs)"
-
-    # Classify operation
-    sprint_type=$(classify_operation "$op")
-
-    # Get current counter
-    counter=${sprint_counters[$sprint_type]}
-    sprint_id=$(generate_sprint_id "$sprint_type" "$counter")
-
-    # Add to group
-    if [[ -z "${sprint_groups[$sprint_id]:-}" ]]; then
-      sprint_groups[$sprint_id]="$op"
-    else
-      sprint_groups[$sprint_id]="${sprint_groups[$sprint_id]}|$op"
-    fi
-
-    # Check if we need to start a new sprint (max operations reached)
-    op_count=$(echo "${sprint_groups[$sprint_id]}" | tr '|' '\n' | wc -l)
-    max_ops=$MAX_OPS_PER_SPRINT
-
-    if [[ "$sprint_type" == "integration" ]]; then
-      max_ops=$MAX_OPS_INTEGRATION
-    elif [[ "$sprint_type" == "automation" ]]; then
-      max_ops=$MAX_OPS_AUTOMATION
-    fi
-
-    if [[ $op_count -ge $max_ops ]]; then
-      sprint_counters[$sprint_type]=$((counter + 1))
-    fi
-  done
-
-  # Check total sprint count
-  total_sprints=${#sprint_groups[@]}
-  if [[ $total_sprints -gt $MAX_SPRINTS ]]; then
-    cat <<EOF
-{
-  "error": "EXCEEDS_COMPLEXITY_LIMIT",
-  "message": "Request requires $total_sprints sprints, maximum is $MAX_SPRINTS",
-  "suggestion": "Break into multiple user requests or simplify scope"
-}
-EOF
-    return 1
-  fi
-
-  # Generate JSON output
-  echo "{"
-  echo "  \"request_summary\": \"$request\","
-  echo "  \"total_sprints\": $total_sprints,"
-  echo "  \"sprints\": ["
-
-  local sprint_index=0
-  local total_api_calls=0
-
-  # Sort sprints by dependency order (schema → data → formula → formatting → integration → automation)
-  local -a ordered_types=(schema data formula formatting integration automation)
-
-  for sprint_type in "${ordered_types[@]}"; do
-    for sprint_id in $(echo "${!sprint_groups[@]}" | tr ' ' '\n' | grep "^${sprint_type}_" | sort); do
-      [[ $sprint_index -gt 0 ]] && echo ","
-
-      # Extract operations for this sprint
-      IFS='|' read -ra ops <<< "${sprint_groups[$sprint_id]}"
-
-      # Determine dependencies
-      local dependencies="[]"
-      case "$sprint_type" in
-        data)
-          dependencies='["schema"]'
-          ;;
-        formula)
-          dependencies='["schema", "data"]'
-          ;;
-        formatting)
-          dependencies='["data"]'
-          ;;
-        integration)
-          dependencies='["schema"]'
-          ;;
-        automation)
-          dependencies='["schema", "data", "formula", "formatting", "integration"]'
-          ;;
-      esac
-
-      # Generate success criteria
-      local success_criteria="["
-      local criteria_index=0
-      for op in "${ops[@]}"; do
-        [[ $criteria_index -gt 0 ]] && success_criteria+=", "
-        success_criteria+="\"Operation completed: $op\""
-        criteria_index=$((criteria_index + 1))
-      done
-      success_criteria+="]"
-
-      # Estimate API calls
-      local api_calls=0
-      for op in "${ops[@]}"; do
-        api_calls=$((api_calls + $(estimate_api_calls "$op" "$sprint_type")))
-      done
-      total_api_calls=$((total_api_calls + api_calls))
-
-      # Output sprint JSON
-      cat <<EOF
-    {
-      "sprint_id": "$sprint_id",
-      "sprint_type": "$sprint_type",
-      "operations": [$(printf '"%s"' "${ops[0]}"; printf ', "%s"' "${ops[@]:1}")],
-      "dependencies": $dependencies,
-      "success_criteria": $success_criteria,
-      "estimated_api_calls": $api_calls
-    }
-EOF
-
-      sprint_index=$((sprint_index + 1))
-    done
-  done
-
-  echo ""
-  echo "  ],"
-  echo "  \"total_estimated_api_calls\": $total_api_calls"
-  echo "}"
-
-  # Check API quota
-  if [[ $total_api_calls -gt $MAX_API_CALLS_TOTAL ]]; then
-    echo "Warning: Estimated API calls ($total_api_calls) exceeds quota limit ($MAX_API_CALLS_TOTAL)" >&2
-  fi
-}
-
-# Execute decomposition
-RESULT=$(decompose_request "$REQUEST")
-
-# Output to file or stdout
-if [[ -n "$OUTPUT_FILE" ]]; then
-  echo "$RESULT" > "$OUTPUT_FILE"
-  echo "Decomposition written to: $OUTPUT_FILE" >&2
-else
-  echo "$RESULT"
-fi

package/claude-assets/cfn-extras/skills/google-sheets-formula-builder/SKILL.md

@@ -1,237 +0,0 @@
----
-name: google-sheets-formula-builder
-version: 1.0.0
-category: coordination
-tags: [google-sheets, formulas, templates, formula-validation]
-status: approved
-author: CFN Team
-description: Constructs and validates Google Sheets formulas from templates with syntax checking
-dependencies: [jq, bash]
-created: 2025-11-18
-updated: 2025-11-18
-complexity: Medium
-keywords: [formula-generation, formula-validation, sheets-api, syntax-validation]
-triggers: [loop-3-formula-application, formula-creation, data-calculation]
-performance_targets:
-  execution_time_ms: 1000
-  success_rate: 0.98
----
-
-# Google Sheets Formula Builder Skill
-
-## Purpose
-
-Constructs Google Sheets formulas from templates and validates syntax before application. Enables safe formula generation with type checking, cell reference validation, and error prevention.
-
-## Problem Solved
-
-Manual formula creation is error-prone. Formulas with syntax errors, invalid references, or circular logic cause cascading failures in spreadsheets. This skill provides template-based formula generation with comprehensive validation ensuring only correct formulas are applied.
-
-## When to Use
-
-- During formula application sprint phase
-- When generating aggregate calculations (SUM, AVERAGE, COUNT)
-- For conditional logic (IF, IFS, SWITCH)
-- When building lookup operations (VLOOKUP, INDEX/MATCH)
-- For array formula generation
-- Before applying formulas to production sheets
-
-## Interface
-
-### Primary Script: `build-formula.sh`
-
-**Required Parameters:**
-- `--formula-type`: Type of formula to build: SUM, AVERAGE, VLOOKUP, IF, ARRAY (required)
-- `--range`: Cell range for formula, e.g., A2:C10
-- `--target-cell`: Target cell for formula placement, e.g., D2
-
-**Optional Parameters:**
-- `--condition`: Condition for IF formulas, e.g., "A2>100"
-- `--criteria`: Criteria for formula, e.g., "Status=Complete"
-- `--output-only`: Output formula only, don't apply (default: true)
-- `--validate-only`: Validate formula syntax without applying
-
-**Usage:**
-
-```bash
-# Generate SUM formula
-./.claude/cfn-extras/skills/google-sheets-formula-builder/build-formula.sh \
-  --formula-type SUM \
-  --range A2:C10 \
-  --target-cell D2
-
-# Generate IF formula
-./.claude/cfn-extras/skills/google-sheets-formula-builder/build-formula.sh \
-  --formula-type IF \
-  --range A2:C10 \
-  --condition "A2>100" \
-  --target-cell D2
-
-# Generate VLOOKUP formula
-./.claude/cfn-extras/skills/google-sheets-formula-builder/build-formula.sh \
-  --formula-type VLOOKUP \
-  --range A2:C10 \
-  --criteria "Lookup" \
-  --target-cell D2
-
-# Validate syntax only
-./.claude/cfn-extras/skills/google-sheets-formula-builder/build-formula.sh \
-  --formula-type SUM \
-  --range A2:C10 \
-  --validate-only
-```
-
-## Supported Formula Types
-
-### SUM
-Sums values in a range with optional conditions.
-
-```json
-{
-  "type": "SUM",
-  "formula": "=SUM(A2:C10)",
-  "description": "Sum of range A2:C10",
-  "complexity": "basic"
-}
-```
-
-### AVERAGE
-Calculates average of values in range.
-
-```json
-{
-  "type": "AVERAGE",
-  "formula": "=AVERAGE(A2:C10)",
-  "description": "Average of range A2:C10",
-  "complexity": "basic"
-}
-```
-
-### VLOOKUP
-Looks up value in first column of range.
-
-```json
-{
-  "type": "VLOOKUP",
-  "formula": "=VLOOKUP(\"Lookup\",A2:C10,2,FALSE)",
-  "description": "Lookup value in range",
-  "complexity": "intermediate"
-}
-```
-
-### IF
-Conditional formula with true/false branches.
-
-```json
-{
-  "type": "IF",
-  "formula": "=IF(A2>100,\"High\",\"Low\")",
-  "description": "If A2>100 then High else Low",
-  "complexity": "intermediate"
-}
-```
-
-### ARRAY
-Array formula with multiple return values.
-
-```json
-{
-  "type": "ARRAY",
-  "formula": "=ARRAYFORMULA(IF(A2:A>0,B2:B*C2:C,\"\"))",
-  "description": "Array formula calculating range",
-  "complexity": "advanced"
-}
-```
-
-## Output Format
-
-```json
-{
-  "success": true,
-  "confidence": 0.96,
-  "formula": "=SUM(A2:C10)",
-  "formula_type": "SUM",
-  "target_cell": "D2",
-  "syntax_valid": true,
-  "validation": {
-    "syntax": true,
-    "references": true,
-    "circular_refs": false,
-    "error_cells": 0
-  },
-  "deliverables": ["formula_definition"],
-  "errors": []
-}
-```
-
-## Validation Rules
-
-1. **Syntax validation** - Formula parses correctly
-2. **Reference validation** - Cell references exist and are valid
-3. **Circular reference detection** - No self-referencing formulas
-4. **Type checking** - Function arguments match expected types
-5. **Range validation** - Ranges are properly formatted
-6. **Function existence** - All functions are Google Sheets functions
-
-## Integration with CFN Loop
-
-### Loop 3 Agents (Formula Phase)
-
-```bash
-# Generate formula
-FORMULA=$(./.claude/cfn-extras/skills/google-sheets-formula-builder/build-formula.sh \
-  --formula-type SUM \
-  --range A2:C100 \
-  --target-cell D2)
-
-# Validate formula
-if echo "$FORMULA" | jq -e '.syntax_valid == true' >/dev/null; then
-  echo "Formula generated and validated successfully"
-else
-  echo "Formula validation failed"
-fi
-```
-
-### Loop 2 Validators
-
-```bash
-# Review generated formulas
-VALIDATION=$(./.claude/cfn-extras/skills/google-sheets-formula-builder/build-formula.sh \
-  --formula-type VLOOKUP \
-  --range A2:C100 \
-  --validate-only)
-
-if echo "$VALIDATION" | jq -e '.validation.syntax == true' >/dev/null; then
-  echo "Formula syntax valid, passing validation"
-fi
-```
-
-## Best Practices
-
-1. **Validate before applying** - Always validate formula syntax first
-2. **Use templates** - Leverage formula templates for consistency
-3. **Test ranges** - Verify cell ranges exist before formula generation
-4. **Document formulas** - Include comment explaining complex formulas
-5. **Version formulas** - Track formula changes in progress state
-
-## Anti-Patterns
-
-❌ **Manual formula strings** - Always use builder script
-❌ **Skipping validation** - Always validate before applying
-❌ **Hardcoded ranges** - Use parameterized ranges
-❌ **Complex nested formulas** - Break into helper columns
-❌ **No error handling** - Check for error cells in results
-
-## Success Criteria
-
-- **Pass rate**: ≥0.98 (standard mode)
-- **Syntax accuracy**: 100% correct Google Sheets syntax
-- **Reference validation**: 0 false negatives on invalid references
-- **Performance**: Formula generation <1000ms
-- **Error detection**: Catches all syntax errors
-
-## References
-
-- **Google Sheets API**: https://developers.google.com/sheets/api/reference/rest
-- **Formula Validation**: `google-sheets-validation` skill
-- **CFN Loop Guide**: `.claude/commands/CFN_LOOP_TASK_MODE.md`