claude-flow-novice 1.5.2 → 1.5.4

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/memory-bank.md

@@ -0,0 +1,16 @@
+# Memory Bank
+
+## Overview
+This file serves as a persistent memory bank for important project context that should be retained across sessions.
+
+## Project Context
+<!-- Add project-specific information here -->
+
+## Key Decisions
+<!-- Document important decisions and their rationale -->
+
+## Code Patterns
+<!-- Document established patterns and conventions -->
+
+## Session History
+<!-- Track significant session outcomes -->

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/readme-files.js

@@ -0,0 +1,72 @@
+// readme-files.js - README templates for various directories
+
+export function createAgentsReadme() {
+  return `# Agent Memory Storage
+
+## Purpose
+This directory stores agent-specific memory data, configurations, and persistent state information for individual Claude agents in the orchestration system.
+
+## Structure
+Each agent gets its own subdirectory for isolated memory storage:
+
+\`\`\`
+memory/agents/
+├── agent_001/
+│   ├── state.json           # Agent state and configuration
+│   ├── knowledge.md         # Agent-specific knowledge base
+│   ├── tasks.json          # Completed and active tasks
+│   └── calibration.json    # Agent-specific calibrations
+├── agent_002/
+│   └── ...
+└── shared/
+    ├── common_knowledge.md  # Shared knowledge across agents
+    └── global_config.json  # Global agent configurations
+\`\`\`
+
+## Usage Guidelines
+1. **Agent Isolation**: Each agent should only read/write to its own directory
+2. **Shared Resources**: Use the \`shared/\` directory for cross-agent information
+3. **State Persistence**: Update state.json whenever agent status changes
+4. **Knowledge Sharing**: Document discoveries in knowledge.md files
+5. **Cleanup**: Remove directories for terminated agents periodically
+
+## Last Updated
+${new Date().toISOString()}
+`;
+}
+
+export function createSessionsReadme() {
+  return `# Session Memory Storage
+
+## Purpose
+This directory stores session-based memory data, conversation history, and contextual information for development sessions using the Claude-Flow orchestration system.
+
+## Structure
+Sessions are organized by date and session ID for easy retrieval:
+
+\`\`\`
+memory/sessions/
+├── 2024-01-10/
+│   ├── session_001/
+│   │   ├── metadata.json        # Session metadata and configuration
+│   │   ├── conversation.md      # Full conversation history
+│   │   ├── decisions.md         # Key decisions and rationale
+│   │   ├── artifacts/           # Generated files and outputs
+│   │   └── coordination_state/  # Coordination system snapshots
+│   └── ...
+└── shared/
+    ├── patterns.md              # Common session patterns
+    └── templates/               # Session template files
+\`\`\`
+
+## Usage Guidelines
+1. **Session Isolation**: Each session gets its own directory
+2. **Metadata Completeness**: Always fill out session metadata
+3. **Conversation Logging**: Document all significant interactions
+4. **Artifact Organization**: Structure generated files clearly
+5. **State Preservation**: Snapshot coordination state regularly
+
+## Last Updated
+${new Date().toISOString()}
+`;
+}

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/safe-hook-patterns.js

@@ -0,0 +1,430 @@
+/**
+ * Safe Hook Patterns - Templates for safe Claude Code hook configurations
+ *
+ * These patterns prevent infinite loops that could cost thousands of dollars
+ * by avoiding recursive hook execution when hooks call 'claude' commands.
+ */
+
+/**
+ * DANGEROUS PATTERN - DO NOT USE
+ * This creates an infinite loop that can cost thousands of dollars!
+ */
+export const DANGEROUS_PATTERN_EXAMPLE = {
+  name: 'DANGEROUS: Stop hook calling claude command',
+  description: '❌ NEVER USE THIS - Creates infinite recursion loop',
+  pattern: {
+    hooks: {
+      Stop: [
+        {
+          matcher: '',
+          hooks: [
+            {
+              type: 'command',
+              command: 'claude -c -p "Update all changes to history.md"',
+            },
+          ],
+        },
+      ],
+    },
+  },
+  problems: [
+    '🚨 Creates infinite loop: Stop → claude command → Stop → claude command...',
+    '💰 Can cost $3600+ per day by bypassing rate limits',
+    '🚫 Makes system unresponsive',
+    '⚡ No built-in protection in Claude Code',
+  ],
+};
+
+/**
+ * SAFE PATTERN 1: Flag-based updates
+ * Set a flag instead of calling claude directly
+ */
+export const SAFE_FLAG_PATTERN = {
+  name: 'Safe Pattern: Flag-based updates',
+  description: '✅ Set flag when update needed, run manually',
+  pattern: {
+    hooks: {
+      Stop: [
+        {
+          matcher: '',
+          hooks: [
+            {
+              type: 'command',
+              command:
+                'bash -c \'echo "History update needed at $(date)" > ~/.claude/needs_update && echo "📝 History update flagged. Run: claude -c -p \\"Update history.md\\""\'',
+            },
+          ],
+        },
+      ],
+    },
+  },
+  benefits: [
+    '✅ No recursion - just sets a flag',
+    '💰 Zero risk of infinite API calls',
+    '🔄 User controls when update runs',
+    '📝 Clear instructions for manual execution',
+  ],
+  usage: [
+    '1. Hook sets flag when update is needed',
+    '2. User sees notification',
+    '3. User manually runs: claude -c -p "Update history.md"',
+    '4. Update runs once safely',
+  ],
+};
+
+/**
+ * SAFE PATTERN 2: PostToolUse hooks instead of Stop hooks
+ * React to specific tool usage rather than session end
+ */
+export const SAFE_POST_TOOL_PATTERN = {
+  name: 'Safe Pattern: PostToolUse hooks',
+  description: '✅ React to specific file operations instead of Stop events',
+  pattern: {
+    hooks: {
+      PostToolUse: [
+        {
+          matcher: 'Write|Edit|MultiEdit',
+          hooks: [
+            {
+              type: 'command',
+              command: "echo 'File modified: {file}' >> ~/.claude/modifications.log",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  benefits: [
+    '✅ Only triggers on actual file changes',
+    '🎯 More precise than Stop hooks',
+    '📝 Logs specific modifications',
+    '🔄 No risk of Stop hook recursion',
+  ],
+  usage: [
+    '1. Triggers only when files are written/edited',
+    '2. Logs the specific file that was modified',
+    '3. Can be used for change tracking',
+    '4. Safe to use with any logging command',
+  ],
+};
+
+/**
+ * SAFE PATTERN 3: Conditional execution with skip-hooks
+ * Check for hook context before executing claude commands
+ */
+export const SAFE_CONDITIONAL_PATTERN = {
+  name: 'Safe Pattern: Conditional execution with context check',
+  description: '✅ Check if running in hook context before calling claude',
+  pattern: {
+    hooks: {
+      Stop: [
+        {
+          matcher: '',
+          hooks: [
+            {
+              type: 'command',
+              command:
+                'bash -c \'if [ -z "$CLAUDE_HOOK_CONTEXT" ]; then claude -c -p "Update history.md" --skip-hooks; else echo "Skipping update - in hook context"; fi\'',
+            },
+          ],
+        },
+      ],
+    },
+  },
+  benefits: [
+    '✅ Checks hook context before execution',
+    '🛡️ Uses --skip-hooks flag for safety',
+    '🔄 Prevents recursive hook calls',
+    '📊 Provides clear feedback',
+  ],
+  usage: [
+    '1. Checks CLAUDE_HOOK_CONTEXT environment variable',
+    '2. Only runs claude if not in hook context',
+    '3. Uses --skip-hooks to prevent triggering more hooks',
+    '4. Shows clear message when skipping',
+  ],
+};
+
+/**
+ * SAFE PATTERN 4: Batch processing with scheduled execution
+ * Accumulate changes and process them on a schedule
+ */
+export const SAFE_BATCH_PATTERN = {
+  name: 'Safe Pattern: Batch processing with scheduled execution',
+  description: '✅ Accumulate changes and process them separately',
+  pattern: {
+    hooks: {
+      Stop: [
+        {
+          matcher: '',
+          hooks: [
+            {
+              type: 'command',
+              command: 'echo "$(date): Session ended" >> ~/.claude/session_log.txt',
+            },
+          ],
+        },
+      ],
+    },
+  },
+  additionalSetup: {
+    cronJob: '# Add to crontab (run every hour):\n# 0 * * * * /path/to/update-history.sh',
+    updateScript: `#!/bin/bash
+# update-history.sh - Safe batch update script
+LOCK_FILE="~/.claude/update.lock"
+LOG_FILE="~/.claude/session_log.txt"
+
+# Check if update is already running
+if [ -f "$LOCK_FILE" ]; then
+    echo "Update already in progress"
+    exit 1
+fi
+
+# Create lock file
+touch "$LOCK_FILE"
+
+# Check if there are new sessions to process
+if [ -f "$LOG_FILE" ] && [ -s "$LOG_FILE" ]; then
+    echo "Processing accumulated changes..."
+    claude -c -p "Update history.md with recent session data" --skip-hooks
+    
+    # Archive the log
+    mv "$LOG_FILE" "~/.claude/session_log_$(date +%Y%m%d_%H%M%S).txt"
+fi
+
+# Remove lock file
+rm "$LOCK_FILE"`,
+  },
+  benefits: [
+    '✅ No risk of recursion',
+    '⏰ Scheduled processing prevents overload',
+    '🔒 Lock file prevents concurrent updates',
+    '📦 Batches multiple sessions efficiently',
+  ],
+};
+
+/**
+ * SAFE PATTERN 5: Database/file-based queue system
+ * Use external queue for processing commands
+ */
+export const SAFE_QUEUE_PATTERN = {
+  name: 'Safe Pattern: Queue-based command processing',
+  description: '✅ Queue commands for external processing',
+  pattern: {
+    hooks: {
+      Stop: [
+        {
+          matcher: '',
+          hooks: [
+            {
+              type: 'command',
+              command:
+                'echo \'{"command": "update-history", "timestamp": "\'$(date -Iseconds)\'", "session": "\'$CLAUDE_SESSION_ID\'"}\' >> ~/.claude/command_queue.jsonl',
+            },
+          ],
+        },
+      ],
+    },
+  },
+  processor: `#!/usr/bin/env python3
+# queue-processor.py - Safe command queue processor
+import json
+import subprocess
+import time
+import os
+from pathlib import Path
+
+QUEUE_FILE = Path.home() / '.claude' / 'command_queue.jsonl'
+PROCESSING_INTERVAL = 300  # 5 minutes
+
+def process_queue():
+    if not QUEUE_FILE.exists():
+        return
+    
+    # Read and clear queue atomically
+    with open(QUEUE_FILE, 'r') as f:
+        lines = f.readlines()
+    
+    # Clear the queue
+    QUEUE_FILE.unlink()
+    
+    # Process commands
+    for line in lines:
+        try:
+            cmd_data = json.loads(line.strip())
+            if cmd_data['command'] == 'update-history':
+                print(f"Processing history update for session {cmd_data['session']}")
+                subprocess.run([
+                    'claude', '-c', '-p', 'Update history.md', '--skip-hooks'
+                ], check=True)
+                time.sleep(2)  # Rate limiting
+        except Exception as e:
+            print(f"Error processing command: {e}")
+
+if __name__ == '__main__':
+    while True:
+        try:
+            process_queue()
+            time.sleep(PROCESSING_INTERVAL)
+        except KeyboardInterrupt:
+            break`,
+  benefits: [
+    '✅ Complete separation of hook and claude execution',
+    '⏰ Rate limited processing',
+    '🔄 Handles multiple queued commands',
+    '🛡️ No risk of infinite loops',
+  ],
+};
+
+/**
+ * Get all safe patterns for documentation generation
+ */
+export const ALL_SAFE_PATTERNS = [
+  SAFE_FLAG_PATTERN,
+  SAFE_POST_TOOL_PATTERN,
+  SAFE_CONDITIONAL_PATTERN,
+  SAFE_BATCH_PATTERN,
+  SAFE_QUEUE_PATTERN,
+];
+
+/**
+ * Generate safe hooks documentation
+ */
+export function generateSafeHooksGuide() {
+  return `# 🛡️ Safe Hook Patterns for Claude Code
+
+⚠️ **CRITICAL WARNING**: Stop hooks that call 'claude' commands create infinite loops that can cost thousands of dollars per day!
+
+## 🚨 DANGEROUS PATTERN (NEVER USE)
+
+${DANGEROUS_PATTERN_EXAMPLE.description}
+
+\`\`\`json
+${JSON.stringify(DANGEROUS_PATTERN_EXAMPLE.pattern, null, 2)}
+\`\`\`
+
+**Problems:**
+${DANGEROUS_PATTERN_EXAMPLE.problems.map((p) => `- ${p}`).join('\n')}
+
+---
+
+## ✅ SAFE PATTERNS
+
+${ALL_SAFE_PATTERNS.map(
+  (pattern) => `
+### ${pattern.name}
+
+${pattern.description}
+
+**Configuration:**
+\`\`\`json
+${JSON.stringify(pattern.pattern, null, 2)}
+\`\`\`
+
+**Benefits:**
+${pattern.benefits.map((b) => `- ${b}`).join('\n')}
+
+${
+  pattern.usage
+    ? `**Usage:**
+${pattern.usage.map((u, i) => `${i + 1}. ${u}`).join('\n')}`
+    : ''
+}
+
+${
+  pattern.additionalSetup
+    ? `**Additional Setup:**
+${
+  pattern.additionalSetup.cronJob
+    ? `
+**Cron Job:**
+\`\`\`bash
+${pattern.additionalSetup.cronJob}
+\`\`\`
+`
+    : ''
+}
+
+${
+  pattern.additionalSetup.updateScript
+    ? `
+**Update Script:**
+\`\`\`bash
+${pattern.additionalSetup.updateScript}
+\`\`\`
+`
+    : ''
+}`
+    : ''
+}
+
+${
+  pattern.processor
+    ? `
+**Queue Processor:**
+\`\`\`python
+${pattern.processor}
+\`\`\`
+`
+    : ''
+}
+
+---
+`,
+).join('')}
+
+## 🚀 Quick Migration Guide
+
+### If you currently have this DANGEROUS pattern:
+\`\`\`json
+{
+  "hooks": {
+    "Stop": [{"hooks": [{"type": "command", "command": "claude -c -p 'Update history'"}]}]
+  }
+}
+\`\`\`
+
+### Replace with this SAFE pattern:
+\`\`\`json
+{
+  "hooks": {
+    "Stop": [{"hooks": [{"type": "command", "command": "touch ~/.claude/needs_update && echo 'Run: claude -c -p \"Update history\"'"}]}]
+  }
+}
+\`\`\`
+
+## 🛡️ Hook Safety Tools
+
+Use claude-flow's built-in safety tools:
+
+\`\`\`bash
+# Check your configuration for dangerous patterns
+claude-flow-novice hook-safety validate
+
+# Enable safe mode (skips all hooks)
+claude-flow-novice hook-safety safe-mode
+
+# Check current safety status
+claude-flow-novice hook-safety status
+
+# Reset circuit breakers if triggered
+claude-flow-novice hook-safety reset
+\`\`\`
+
+## 📚 Additional Resources
+
+- Issue #166: https://github.com/ruvnet/claude-flow/issues/166
+- Claude Code Hooks Documentation: https://docs.anthropic.com/en/docs/claude-code/hooks
+- Reddit Discussion: https://www.reddit.com/r/ClaudeAI/comments/1ltvi6x/anyone_else_accidentally_create_an_infinite_loop/
+
+---
+
+**Remember**: When in doubt, use flag-based patterns or PostToolUse hooks instead of Stop hooks!
+`;
+}
+
+export default {
+  DANGEROUS_PATTERN_EXAMPLE,
+  ALL_SAFE_PATTERNS,
+  generateSafeHooksGuide,
+};

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/settings.json

@@ -0,0 +1,109 @@
+{
+  "env": {
+    "CLAUDE_FLOW_AUTO_COMMIT": "false",
+    "CLAUDE_FLOW_AUTO_PUSH": "false",
+    "CLAUDE_FLOW_HOOKS_ENABLED": "true",
+    "CLAUDE_FLOW_TELEMETRY_ENABLED": "true",
+    "CLAUDE_FLOW_REMOTE_EXECUTION": "true",
+    "CLAUDE_FLOW_CHECKPOINTS_ENABLED": "true"
+  },
+  "permissions": {
+    "allow": [
+      "Bash(npx claude-flow-novice *)",
+      "Bash(npm run lint)",
+      "Bash(npm run test:*)",
+      "Bash(npm test *)",
+      "Bash(git status)",
+      "Bash(git diff *)",
+      "Bash(git log *)",
+      "Bash(git add *)",
+      "Bash(git commit *)",
+      "Bash(git push)",
+      "Bash(git config *)",
+      "Bash(git tag *)",
+      "Bash(git branch *)",
+      "Bash(git checkout *)",
+      "Bash(git stash *)",
+      "Bash(jq *)",
+      "Bash(node *)",
+      "Bash(which *)",
+      "Bash(pwd)",
+      "Bash(ls *)"
+    ],
+    "deny": ["Bash(rm -rf /)", "Bash(curl * | bash)", "Bash(wget * | sh)", "Bash(eval *)"]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "cat | jq -r '.tool_input.command // empty' | tr '\\n' '\\0' | xargs -0 -I {} npx claude-flow@alpha hooks pre-command --command '{}' --validate-safety true --prepare-resources true"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "cat | jq -r '.tool_input.file_path // .tool_input.path // empty' | tr '\\n' '\\0' | xargs -0 -I {} npx claude-flow@alpha hooks pre-edit --file '{}' --auto-assign-agents true --load-context true"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "cat | jq -r '.tool_input.command // empty' | tr '\\n' '\\0' | xargs -0 -I {} npx claude-flow@alpha hooks post-command --command '{}' --track-metrics true --store-results true"
+          }
+        ]
+      },
+      {
+        "matcher": "Write|Edit|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "cat | jq -r '.tool_input.file_path // .tool_input.path // empty' | tr '\\n' '\\0' | xargs -0 -I {} npx claude-flow@alpha hooks post-edit --file '{}' --format true --update-memory true"
+          }
+        ]
+      }
+    ],
+    "PreCompact": [
+      {
+        "matcher": "manual",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/bin/bash -c 'INPUT=$(cat); CUSTOM=$(echo \"$INPUT\" | jq -r \".custom_instructions // \\\"\\\"\"); echo \"🔄 PreCompact Guidance:\"; echo \"📋 IMPORTANT: Review CLAUDE.md in project root for:\"; echo \"   • 54 available agents and concurrent usage patterns\"; echo \"   • Swarm coordination strategies (hierarchical, mesh, adaptive)\"; echo \"   • SPARC methodology workflows with batchtools optimization\"; echo \"   • Critical concurrent execution rules (GOLDEN RULE: 1 MESSAGE = ALL OPERATIONS)\"; if [ -n \"$CUSTOM\" ]; then echo \"🎯 Custom compact instructions: $CUSTOM\"; fi; echo \"✅ Ready for compact operation\"'"
+          }
+        ]
+      },
+      {
+        "matcher": "auto",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "/bin/bash -c 'echo \"🔄 Auto-Compact Guidance (Context Window Full):\"; echo \"📋 CRITICAL: Before compacting, ensure you understand:\"; echo \"   • All 54 agents available in .claude/agents/ directory\"; echo \"   • Concurrent execution patterns from CLAUDE.md\"; echo \"   • Batchtools optimization for 300% performance gains\"; echo \"   • Swarm coordination strategies for complex tasks\"; echo \"⚡ Apply GOLDEN RULE: Always batch operations in single messages\"; echo \"✅ Auto-compact proceeding with full agent context\"'"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "npx claude-flow@alpha hooks session-end --generate-summary true --persist-state true --export-metrics true"
+          }
+        ]
+      }
+    ]
+  },
+  "includeCoAuthoredBy": true,
+  "enabledMcpjsonServers": ["claude-flow", "ruv-swarm"]
+}

package/.claude-flow-novice/dist/src/cli/simple-commands/init/templates/settings.json.enhanced

@@ -0,0 +1,35 @@
+{
+  "hooks": {
+    "pre-task": ".claude/commands/hooks/pre-task.md",
+    "post-task": ".claude/commands/hooks/post-task.md",
+    "pre-edit": ".claude/commands/hooks/pre-edit.md",
+    "post-edit": ".claude/commands/hooks/post-edit.md",
+    "session-start": ".claude/commands/hooks/session-start.md",
+    "session-end": ".claude/commands/hooks/session-end.md"
+  },
+  "permissions": {
+    "allow": ["mcp__ruv-swarm", "mcp__claude-flow"],
+    "autoApprove": {
+      "mcp__ruv-swarm": ["*"],
+      "mcp__claude-flow": ["*"]
+    }
+  },
+  "mcpServers": {
+    "claude-flow": {
+      "command": "npx",
+      "args": ["claude-flow@alpha", "mcp", "start"],
+      "type": "stdio"
+    },
+    "ruv-swarm": {
+      "command": "npx",
+      "args": ["ruv-swarm@latest", "mcp", "start"],
+      "type": "stdio"
+    }
+  },
+  "features": {
+    "hooks": true,
+    "mcpIntegration": true,
+    "autoCompletion": true,
+    "commandPalette": true
+  }
+}