claude-flow-novice 2.18.6 → 2.18.7

package/.claude/hooks/SKILL.md.backup

@@ -1,471 +0,0 @@
-# Post-Edit Validation Skill
-
-Validates files after modifications with syntax, formatting, and linting checks.
-
-## Overview
-
-The Post-Edit Validation Skill ensures code quality and correctness after edit operations by running configurable validation pipelines. It detects syntax errors, formatting issues, and code quality problems with real-time feedback.
-
-## Features
-
-- **Multi-Format Support**: TypeScript, JavaScript, JSON, Bash, Markdown, Python
-- **Syntax Validation**: Detects syntax errors in JSON and type errors in TypeScript
-- **Formatting Checks**: Detects trailing whitespace, mixed line endings, mixed indentation
-- **Code Quality**: Detects duplication, complexity patterns, and best practice violations
-- **Configurable Pipeline**: Enable/disable checks per file type
-- **Blocking Mode**: Optional enforcement of validation rules
-- **Non-Blocking Feedback**: Warnings and suggestions without blocking workflow
-
-## Architecture
-
-### Validation Pipeline
-
-```
-File Input
-    ↓
-Type Detection (.ts, .js, .json, .sh, etc.)
-    ↓
-Type-Specific Validation (syntax, type checking)
-    ↓
-Common Checks (formatting, duplication)
-    ↓
-Result Aggregation (errors, warnings, suggestions)
-    ↓
-Feedback Generation
-```
-
-### Configuration
-
-Default config: `.claude/hooks/cfn-post-edit.config.json`
-
-```json
-{
-  "enabled": true,
-  "blocking": false,
-  "validation": {
-    "typescript": {
-      "enabled": true,
-      "noEmit": true,
-      "skipLibCheck": true
-    },
-    "bash": {
-      "enabled": true,
-      "validators": ["pipe-safety", "dependency-checker", "line-endings"],
-      "timeout": 5000
-    }
-  },
-  "feedback": {
-    "provideSuggestions": true,
-    "autoFixable": ["LINT_ISSUES"],
-    "nonBlocking": ["TYPE_WARNING", "LINT_ISSUES", "BASH_VALIDATOR_WARNING"],
-    "blocking": ["SYNTAX_ERROR", "BASH_VALIDATOR_ERROR"]
-  }
-}
-```
-
-## TypeScript API
-
-### PostEditValidator Class
-
-```typescript
-import { PostEditValidator, ValidationResult } from '@/hooks/post-edit-validator';
-
-const validator = new PostEditValidator(projectRoot);
-
-// Load configuration
-const config = await validator.loadConfig();
-
-// Validate a file
-const result: ValidationResult = await validator.validateFile(filePath, agentId);
-// Result: {
-//   passed: true,
-//   errors: [],
-//   warnings: ["Mixed tabs and spaces detected"],
-//   suggestions: ["1 lines have trailing whitespace"],
-//   timestamp: "2024-11-20T10:30:45.123Z",
-//   filePath: "/project/src/file.ts",
-//   executionTime: 145
-// }
-
-// Run custom validation pipeline
-const customResult = await validator.runValidationPipeline(filePath);
-
-// Get human-readable summary
-const summary = validator.getValidationSummary(result);
-console.log(summary);
-// Output:
-// ✅ Validation passed
-// Warnings (1):
-//   - Mixed tabs and spaces detected
-// Suggestions (1):
-//   - 1 lines have trailing whitespace
-// Execution time: 145ms
-```
-
-### ValidationResult Interface
-
-```typescript
-interface ValidationResult {
-  passed: boolean;              // Overall validation status
-  errors: string[];             // Blocking issues
-  warnings: string[];           // Non-blocking concerns
-  suggestions: string[];        // Improvement recommendations
-  timestamp: string;            // ISO 8601 timestamp
-  filePath: string;             // Validated file path
-  executionTime: number;        // Milliseconds
-}
-```
-
-## CLI Interface
-
-### Post-Edit Hook CLI
-
-Validates file after modification:
-
-```bash
-# TypeScript compiled version
-node dist/cli/post-edit-hook.js /path/to/file.ts
-
-# With agent ID
-node dist/cli/post-edit-hook.js /path/to/file.ts --agent-id agent-123
-
-# Blocking mode (exit 1 on failure)
-node dist/cli/post-edit-hook.js /path/to/file.ts --blocking
-
-# Output
-# {
-#   "passed": true,
-#   "errors": [],
-#   "warnings": [],
-#   "suggestions": [],
-#   "timestamp": "2024-11-20T10:30:45.123Z",
-#   "filePath": "/path/to/file.ts",
-#   "executionTime": 145
-# }
-```
-
-### Bash Wrapper
-
-For agent compatibility:
-
-```bash
-# Primary wrapper (tries TypeScript, falls back to bash)
-./.claude/hooks/cfn-invoke-post-edit-ts.sh /path/to/file.ts
-
-# With agent ID
-./.claude/hooks/cfn-invoke-post-edit-ts.sh /path/to/file.ts --agent-id agent-123
-
-# Blocking mode
-./.claude/hooks/cfn-invoke-post-edit-ts.sh /path/to/file.ts --blocking
-
-# Legacy bash-only wrapper
-./.claude/hooks/cfn-invoke-post-edit.sh /path/to/file.ts
-```
-
-## Validators by File Type
-
-### TypeScript/JavaScript
-
-```typescript
-// Checks:
-// - Type errors (via tsc --noEmit)
-// - Syntax errors
-// - Import/export correctness
-// - Undefined symbols
-
-const result = await validator.validateFile('src/component.ts');
-if (!result.passed) {
-  result.errors.forEach(err => console.error(err));
-}
-```
-
-### JSON
-
-```typescript
-// Checks:
-// - JSON syntax validity
-// - Schema structure
-// - Special character handling
-
-const result = await validator.validateFile('config.json');
-// Detects: { invalid json }
-```
-
-### Bash Scripts
-
-```typescript
-// Checks:
-// - Unquoted variable usage
-// - Pipe-to-while-read patterns
-// - Missing strict mode (set -euo pipefail)
-// - Line endings (LF vs CRLF)
-
-const result = await validator.validateFile('script.sh');
-// Warnings: "unquoted variables", "pipe-to-while-read", "missing strict mode"
-```
-
-### Formatting Checks (All Types)
-
-```typescript
-// Checks run on all file types:
-// - Trailing whitespace
-// - Mixed line endings (CRLF + LF)
-// - Mixed indentation (tabs + spaces)
-
-const result = await validator.validateFile('any-file.ts');
-if (result.warnings.some(w => w.includes('trailing'))) {
-  // Fix trailing whitespace
-}
-```
-
-### Duplication Detection
-
-When enabled:
-
-```typescript
-// Checks:
-// - Identical consecutive lines (>20 chars)
-// - Copy-paste patterns
-// - Duplicate functions/methods
-
-const result = await validator.validateFile('file.ts');
-result.suggestions.forEach(s => {
-  if (s.includes('Duplicate')) {
-    // Consider refactoring duplicated code
-  }
-});
-```
-
-## Integration
-
-### In Agent Workflows
-
-Post-edit validation is automatically called via hooks after Edit/Write operations:
-
-```bash
-# After Edit or Write operation
-./.claude/hooks/cfn-invoke-post-edit-ts.sh "$FILE_PATH" --agent-id "$AGENT_ID"
-
-# In blocking mode (fails the workflow if validation fails)
-./.claude/hooks/cfn-invoke-post-edit-ts.sh "$FILE_PATH" --agent-id "$AGENT_ID" --blocking
-```
-
-### Redis Publishing
-
-When enabled, validation results are published to Redis:
-
-```json
-{
-  "channel": "swarm:hooks:post-edit",
-  "message": {
-    "file": "/path/to/file.ts",
-    "agentId": "agent-123",
-    "exitCode": 0,
-    "timestamp": "1700000000"
-  }
-}
-```
-
-## Use Cases
-
-### 1. Type Safety
-
-```typescript
-// Catch type errors immediately
-const result = await validator.validateFile('app.ts');
-
-if (!result.passed) {
-  console.error('Type errors detected:');
-  result.errors.forEach(e => console.error(`  - ${e}`));
-  process.exit(1);
-}
-```
-
-### 2. Code Quality Gates
-
-```typescript
-// Enforce formatting standards
-const result = await validator.validateFile('src/utils.ts');
-
-if (result.warnings.length > 0) {
-  console.warn('Code quality issues found:');
-  result.warnings.forEach(w => console.warn(`  - ${w}`));
-}
-```
-
-### 3. Pre-Commit Validation
-
-```bash
-#!/bin/bash
-# Pre-commit hook
-
-FILES=$(git diff --cached --name-only --diff-filter=ACM)
-
-for file in $FILES; do
-  result=$(./.claude/hooks/cfn-invoke-post-edit-ts.sh "$file" --blocking)
-  if [ $? -ne 0 ]; then
-    echo "Validation failed for $file"
-    exit 1
-  fi
-done
-```
-
-### 4. Agent Feedback Loop
-
-```typescript
-// Provide actionable feedback to agents
-const result = await validator.validateFile(filePath, agentId);
-const summary = validator.getValidationSummary(result);
-
-console.log('Validation Report:');
-console.log(summary);
-console.log('\nNext Steps:');
-
-if (result.errors.length > 0) {
-  console.log('Fix errors above before proceeding');
-} else if (result.suggestions.length > 0) {
-  console.log('Consider addressing suggestions for better code quality');
-}
-```
-
-## Configuration
-
-### Enable/Disable Checks
-
-```bash
-# Disable TypeScript checking
-export TS_VALIDATION_ENABLED=false
-
-# Enable formatting checks only
-export CHECK_FORMATTING=true
-export CHECK_SYNTAX=false
-
-# Strict mode (all checks blocking)
-export BLOCKING_VALIDATION=true
-```
-
-### Custom Pipeline
-
-```typescript
-// Create custom validator with specific rules
-const validator = new PostEditValidator(projectRoot);
-validator.config = {
-  checkSyntax: true,
-  checkFormatting: true,
-  checkDuplication: true,
-  blockingValidation: false,
-  typescript: { enabled: true, noEmit: true, skipLibCheck: true },
-  bash: { enabled: true, validators: ['pipe-safety'], timeout: 5000 },
-};
-
-const result = await validator.runValidationPipeline(filePath);
-```
-
-## Testing
-
-Run tests with Jest:
-
-```bash
-npm test tests/post-edit-validator.test.ts
-
-# With coverage
-npm test tests/post-edit-validator.test.ts -- --coverage
-
-# Specific test suite
-npm test tests/post-edit-validator.test.ts -t "validateJSON"
-```
-
-Test coverage includes:
-- JSON syntax validation
-- Bash script validation
-- Formatting checks (whitespace, line endings, indentation)
-- Duplication detection
-- File type detection
-- Configuration loading
-- Result aggregation
-- Error handling
-- Edge cases (empty files, large files, special characters)
-
-## Performance
-
-- **JSON Validation**: <5ms
-- **Bash Validation**: <20ms
-- **TypeScript Check**: 100-500ms (depends on project size)
-- **Formatting Checks**: <10ms
-- **Full Pipeline**: <600ms typical
-
-## Troubleshooting
-
-### TypeScript Check Fails
-
-```bash
-# Verify TypeScript is installed
-npm ls typescript
-
-# Check tsconfig.json
-cat tsconfig.json
-
-# Run tsc directly
-npx tsc --noEmit
-```
-
-### JSON Validation Issues
-
-```bash
-# Validate JSON syntax with jq
-jq . < file.json
-
-# Pretty-print and check
-jq '.' < file.json > /tmp/formatted.json
-```
-
-### Bash Validation Warnings
-
-```bash
-# Check bash syntax directly
-bash -n script.sh
-
-# Verify strict mode
-grep 'set -euo pipefail' script.sh
-
-# Fix unquoted variables
-sed -i 's/\$\([a-zA-Z_][a-zA-Z0-9_]*\)/"$\1"/g' script.sh
-```
-
-## Configuration Reference
-
-### cfn-post-edit.config.json
-
-```json
-{
-  "enabled": true,
-  "version": "2.0.0",
-  "blocking": false,
-  "validation": {
-    "typescript": {
-      "enabled": true,
-      "noEmit": true,
-      "skipLibCheck": true
-    },
-    "bash": {
-      "enabled": true,
-      "validators": ["pipe-safety", "dependency-checker", "line-endings"],
-      "timeout": 5000
-    }
-  },
-  "feedback": {
-    "provideSuggestions": true,
-    "autoFixable": ["LINT_ISSUES"],
-    "nonBlocking": ["TYPE_WARNING", "LINT_ISSUES"],
-    "blocking": ["SYNTAX_ERROR", "BASH_VALIDATOR_ERROR"]
-  }
-}
-```
-
-## References
-
-- **Configuration**: `.claude/hooks/cfn-post-edit.config.json`
-- **Tests**: `tests/post-edit-validator.test.ts`
-- **CLI Entry**: `src/cli/post-edit-hook.ts`
-- **Hook Wrappers**: `.claude/hooks/cfn-invoke-post-edit*.sh`
-- **Pre-Edit Backup**: `.claude/skills/pre-edit-backup/SKILL.md`

package/.claude/hooks/cfn-post-execution/memory-cleanup.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# CFN Post-Execution Memory Cleanup Hook
-# Automatically cleans up memory resources after CFN operations
-
-set -euo pipefail
-
-# Hook configuration
-HOOK_SCRIPT_PATH="$(dirname "$0")/memory-cleanup.sh"
-MEMORY_MANAGEMENT_SKILL="$(dirname "$0")/../../skills/cfn-memory-management/cleanup-memory.sh"
-
-# Use the memory management skill if available, otherwise use local fallback
-if [[ -f "$MEMORY_MANAGEMENT_SKILL" ]]; then
-    exec "$MEMORY_MANAGEMENT_SKILL" "$@"
-elif [[ -f "$HOOK_SCRIPT_PATH" ]]; then
-    exec "$HOOK_SCRIPT_PATH" "$@"
-else
-    echo "WARNING: Memory cleanup scripts not found, skipping cleanup"
-    exit 0
-fi

package/.claude/hooks/cfn-pre-execution/SESSION_START_README.md

@@ -1,87 +0,0 @@
-# Session Start Context Hook
-
-## Purpose
-
-Automatically loads project context at the beginning of each Claude Code session by reading `CLAUDE.md` and displaying key project guidelines, CFN Loop configuration, and environment status.
-
-## Location
-
-`.claude/hooks/cfn-pre-execution/session-start-context.sh`
-
-## Trigger
-
-This hook is designed to run automatically at session initialization when integrated with Claude Code's hook system.
-
-## Manual Execution
-
-```bash
-bash .claude/hooks/cfn-pre-execution/session-start-context.sh
-```
-
-## What It Does
-
-1. **Reads CLAUDE.md** from project root
-2. **Extracts Key Information:**
-   - Available CFN Loop execution modes (Task vs CLI)
-   - CTO Delegation persona guidelines
-   - Test-driven validation thresholds (v3.0+)
-3. **Checks Environment:**
-   - Custom provider routing status
-   - Redis CLI availability
-   - Docker availability
-4. **Displays Quick Reference** for immediate context
-
-## Example Output
-
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📋 SESSION START: Loading Project Context
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-✅ CLAUDE.md loaded
-   Location: /path/to/project/CLAUDE.md
-
-📌 Quick Reference:
-
-   CFN Loop Modes Available:
-   • /cfn-loop-task (Task Mode - Debugging, Full Visibility)
-   • /cfn-loop-cli  (CLI Mode - Production, 64% Cost Savings)
-
-   Active Persona: CTO Delegation
-   • Delegate all non-trivial work (>3 steps)
-   • Use CFN Loop slash commands for complex tasks
-   • Define success criteria, not adoption metrics
-
-   Test-Driven Gates (v3.0+):
-   • Standard Mode: ≥0.95 pass rate (Loop 3), ≥0.90 consensus (Loop 2)
-   • MVP Mode: ≥0.70 pass rate, ≥0.80 consensus
-   • Enterprise: ≥0.98 pass rate, ≥0.95 consensus
-
-🔧 Environment Status:
-   • Custom Provider Routing: DISABLED (default)
-   • Redis CLI: Available
-   • Docker: Available
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-✨ Ready to delegate. Use /cfn-loop-cli or /cfn-loop-task for complex work.
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-```
-
-## Integration with Claude Code
-
-To enable automatic execution at session start, this hook would need to be registered with Claude Code's hook system. The exact integration method depends on Claude Code's session lifecycle hooks implementation.
-
-## Benefits
-
-- **Immediate Context**: No need to manually reference CLAUDE.md
-- **Quick Reference**: Key patterns and modes displayed upfront
-- **Environment Awareness**: Instant visibility into available tools
-- **Consistency**: All sessions start with same baseline context
-
-## Customization
-
-Edit `.claude/hooks/cfn-pre-execution/session-start-context.sh` to:
-- Add/remove extracted sections from CLAUDE.md
-- Modify environment checks
-- Change output formatting
-- Add project-specific context

package/.claude/hooks/cfn-pre-execution/TEST_SESSION_START.md

@@ -1,128 +0,0 @@
-# Testing Session Start Hook
-
-## How to Verify It Works
-
-The session start hook will automatically execute in these scenarios:
-
-### 1. **New Session** (startup)
-When you first start Claude Code:
-```bash
-claude-code
-```
-
-You should see the context output displayed before the first prompt:
-```
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📋 SESSION START: Loading Project Context
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-...
-```
-
-### 2. **Resume Session** (resume)
-When you resume a saved session:
-```bash
-claude-code --resume
-claude-code --continue
-# or use /resume command
-```
-
-The hook will run again, showing current project context.
-
-### 3. **Clear Session** (clear)
-After running `/clear` command:
-```
-User: /clear
-[Session cleared]
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-📋 SESSION START: Loading Project Context
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-...
-```
-
-## Quick Test (Manual)
-
-If you want to see what the output looks like right now:
-
-```bash
-bash .claude/hooks/cfn-pre-execution/session-start-context.sh
-```
-
-Expected output:
-- ✅ CLAUDE.md loaded confirmation
-- 📌 Quick reference with CFN Loop modes
-- CTO Delegation guidelines
-- Test-driven gate thresholds
-- Environment status (Redis, Docker, custom routing)
-
-## What You'll See
-
-**Successful Hook Execution:**
-- Context summary appears at session start
-- Key project patterns displayed
-- Environment status visible
-- Ready to work message
-
-**Hook Not Working:**
-- No output at session start
-- Check `.claude/hooks.json` configuration
-- Verify hook script is executable: `ls -l .claude/hooks/cfn-pre-execution/session-start-context.sh`
-- Check for errors: `bash -x .claude/hooks/cfn-pre-execution/session-start-context.sh`
-
-## Troubleshooting
-
-### Hook doesn't run automatically
-1. Check hooks configuration:
-   ```bash
-   cat .claude/hooks.json | grep -A 10 "SessionStart"
-   ```
-
-2. Verify script permissions:
-   ```bash
-   chmod +x .claude/hooks/cfn-pre-execution/session-start-context.sh
-   ```
-
-3. Test manually:
-   ```bash
-   bash .claude/hooks/cfn-pre-execution/session-start-context.sh
-   ```
-
-### Script errors
-Check for line ending issues (CRLF vs LF):
-```bash
-file .claude/hooks/cfn-pre-execution/session-start-context.sh
-# Should show: "with LF line terminators" (not CRLF)
-
-# Fix if needed:
-sed -i 's/\r$//' .claude/hooks/cfn-pre-execution/session-start-context.sh
-```
-
-## Configuration
-
-Hook configuration in `.claude/hooks.json`:
-```json
-{
-  "hooks": {
-    "SessionStart": [
-      {
-        "matcher": "startup|resume|clear",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "bash \"$CLAUDE_PROJECT_DIR/.claude/hooks/cfn-pre-execution/session-start-context.sh\"",
-            "description": "Load project context from CLAUDE.md at session start"
-          }
-        ]
-      }
-    ]
-  }
-}
-```
-
-## Next Session Test
-
-**To verify the hook is working:**
-1. End current session
-2. Start new Claude Code session
-3. Look for the context output before first prompt
-4. If you see the formatted output with CLAUDE.md content → ✅ Working!
-5. If you don't see anything → Check troubleshooting steps above