claude-flow-novice 2.0.0 → 2.0.1

package/.claude/commands/cfn-loop-document.md

@@ -0,0 +1,441 @@
+---
+description: "Update documentation files in /readme based on completed sprint/epic implementation"
+argument-hint: "[--sprint=name] [--epic=name] [--phase=name]"
+allowed-tools: ["Task", "TodoWrite", "Read", "Write", "Edit", "Grep", "Glob", "Bash"]
+---
+
+# CFN Loop Document - Automated Documentation Updates
+
+Update documentation files in `/readme` directory based on completed sprint/epic implementations, following sparse language patterns.
+
+🚨 **AUTONOMOUS DOCUMENTATION GENERATION**
+
+**Scope**: $ARGUMENTS
+
+## Command Modes
+
+```bash
+/cfn-loop-document                           # Auto-detect completed work from git log
+/cfn-loop-document --sprint=auth-system      # Document specific sprint
+/cfn-loop-document --epic=e-commerce-v1      # Document entire epic
+/cfn-loop-document --phase=user-auth         # Document single phase
+```
+
+## Execution Pattern
+
+### Step 1: Detect Completed Work
+```bash
+# Auto-detect from recent commits
+git log -20 --pretty=format:"%s%n%b" | grep -E "feat\(cfn-loop\)|Complete (Sprint|Epic|Phase)"
+
+# Extract implementation details
+git diff HEAD~10..HEAD --stat | grep -E "\.(ts|js|md)$"
+```
+
+### Step 2: Analyze Implementation
+```javascript
+// Spawn analyst agent to examine implementation
+Task("Documentation Analyst", `
+  ANALYZE IMPLEMENTATION:
+
+  1. Read recent commits and changes
+  2. Identify new features, APIs, commands
+  3. Extract key functionality and patterns
+  4. Determine which readme files need updates
+
+  OUTPUT:
+  {
+    "new_features": [...],
+    "new_commands": [...],
+    "api_changes": [...],
+    "affected_docs": [...]
+  }
+`, "analyst")
+```
+
+### Step 3: Generate Documentation Updates
+```javascript
+// Spawn specialized documentation agents
+mcp__claude-flow-novice__swarm_init({
+  topology: "mesh",
+  maxAgents: 4,
+  strategy: "balanced"
+})
+
+Task("Command Docs", `
+  UPDATE: /readme/logs-slash-commands.md
+
+  RULES:
+  - Sparse language (AI agent readability)
+  - Active voice, present tense
+  - Code examples must work
+  - Follow existing patterns
+
+  NEW COMMANDS: ${newCommands}
+`, "coder")
+
+Task("Feature Docs", `
+  UPDATE: /readme/logs-features.md
+
+  Focus: High-level feature descriptions
+  Pattern: Purpose → Usage → Integration
+
+  NEW FEATURES: ${newFeatures}
+`, "coder")
+
+Task("API Docs", `
+  UPDATE: /readme/logs-api.md
+
+  Document new REST endpoints, MCP tools
+  Include: signatures, parameters, examples
+
+  API CHANGES: ${apiChanges}
+`, "api-docs")
+
+Task("CLI Docs", `
+  UPDATE: /readme/logs-cli-redis.md
+
+  Document CLI commands, Redis integration
+  Follow existing command patterns
+
+  CLI CHANGES: ${cliChanges}
+`, "coder")
+```
+
+### Step 4: Update Index
+```bash
+# Update documentation index with new sections
+node << 'EOF'
+const fs = require('fs');
+const index = fs.readFileSync('/readme/logs-documentation-index.md', 'utf8');
+
+// Add new entries maintaining alphabetical order
+const newEntries = [
+  '- [Recovery Commands](./logs-slash-commands.md#recovery-commands)',
+  '- [Crash Detection](./logs-features.md#crash-detection)'
+];
+
+// Merge and sort
+const updatedIndex = mergeAndSort(index, newEntries);
+fs.writeFileSync('/readme/logs-documentation-index.md', updatedIndex);
+EOF
+```
+
+### Step 5: Validate Documentation
+```bash
+# Run markdown validation
+node config/hooks/markdown-validator.js readme/ --ci
+
+# Verify all links work
+node config/hooks/markdown-validator.js --check-links
+
+# Check for sparse language violations
+grep -r "will be\|is used\|can be used" readme/ && {
+  echo "⚠️  Warning: Non-sparse language detected"
+}
+```
+
+## Documentation Patterns (Sparse Language)
+
+### ❌ Verbose Style (Avoid)
+```markdown
+This function can be used to initialize the swarm. It will create a
+new swarm instance that is configured with the topology you specify.
+You should use this before spawning any agents.
+```
+
+### ✅ Sparse Style (Required)
+```markdown
+## swarmInit
+
+Initialize swarm with specified topology. Required before agent spawning.
+
+**Signature**: `swarmInit(topology, maxAgents) -> swarmId`
+
+**Example**:
+\`\`\`javascript
+const id = swarmInit('mesh', 5);
+\`\`\`
+```
+
+### Command Documentation Template
+```markdown
+### /command-name [options]
+
+**Purpose**: Single sentence describing what it does
+
+**Usage**:
+\`\`\`bash
+/command-name --flag value
+\`\`\`
+
+**Flags**:
+- `--flag`: Description (type, default)
+
+**Output**: What the command returns
+
+**Example**:
+\`\`\`bash
+/command-name --example input
+# Output: result
+\`\`\`
+```
+
+### Feature Documentation Template
+```markdown
+## Feature Name
+
+**Purpose**: Problem this solves
+
+**Implementation**: Key technical details
+
+**Usage**:
+\`\`\`javascript
+// Minimal working example
+featureFunction(params);
+\`\`\`
+
+**Integration**: How it connects to other features
+
+**Configuration**: Available settings (if applicable)
+```
+
+### API Documentation Template
+```markdown
+### POST /endpoint
+
+**Purpose**: What this endpoint does
+
+**Request**:
+\`\`\`json
+{"field": "type"}
+\`\`\`
+
+**Response**:
+\`\`\`json
+{"status": "success", "data": {}}
+\`\`\`
+
+**Errors**: Status codes and meanings
+
+**Example**:
+\`\`\`bash
+curl -X POST /endpoint -d '{"field":"value"}'
+\`\`\`
+```
+
+## File Targets
+
+### /readme/logs-slash-commands.md
+**Updates**: New slash commands, command flags, usage examples
+
+**Pattern**: Command signature → Purpose → Example
+
+### /readme/logs-features.md
+**Updates**: New features, capabilities, system behaviors
+
+**Pattern**: Feature name → Purpose → Implementation → Integration
+
+### /readme/logs-api.md
+**Updates**: REST endpoints, MCP tools, API changes
+
+**Pattern**: Endpoint → Request/Response → Example → Errors
+
+### /readme/logs-cli-redis.md
+**Updates**: CLI commands, Redis operations, coordination patterns
+
+**Pattern**: Command → Flags → Output → Integration
+
+### /readme/logs-functions.md
+**Updates**: Core functions, utilities, helper methods
+
+**Pattern**: Signature → Parameters → Returns → Example
+
+### /readme/logs-mcp.md
+**Updates**: MCP server tools, protocols, integrations
+
+**Pattern**: Tool name → Protocol → Usage → Example
+
+### /readme/additional-commands.md
+**Updates**: Specialized commands, infrequent operations
+
+**Pattern**: Category → Commands → Use cases
+
+### /readme/logs-documentation-index.md
+**Updates**: Table of contents, cross-references, navigation
+
+**Pattern**: Category → Alphabetical links
+
+## Auto-Detection Logic
+
+```javascript
+// Analyze git history to detect what to document
+const detectChanges = () => {
+  const commits = execSync('git log -20 --pretty=format:"%s"').toString();
+
+  const changes = {
+    newCommands: commits.match(/\/[a-z-]+/g) || [],
+    newFeatures: commits.match(/feat\([^)]+\)/g) || [],
+    apiChanges: commits.match(/api|endpoint|route/gi) || [],
+    cliChanges: commits.match(/cli|command/gi) || []
+  };
+
+  return {
+    shouldUpdateCommands: changes.newCommands.length > 0,
+    shouldUpdateFeatures: changes.newFeatures.length > 0,
+    shouldUpdateAPI: changes.apiChanges.length > 0,
+    shouldUpdateCLI: changes.cliChanges.length > 0
+  };
+};
+```
+
+## Sparse Language Rules
+
+### Active Voice (Required)
+- ✅ "Returns data from Redis"
+- ❌ "Data is returned from Redis"
+
+### Present Tense (Required)
+- ✅ "Initializes swarm"
+- ❌ "Will initialize swarm"
+
+### No Fluff (Required)
+- ✅ "Monitor CI/CD pipeline status"
+- ❌ "This command can be used to monitor your CI/CD pipeline status"
+
+### Minimal Examples (Required)
+- ✅ `swarmInit('mesh', 5)`
+- ❌ Long multi-line examples with excessive comments
+
+### Direct Description (Required)
+- ✅ "Execute autonomous workflow"
+- ❌ "This feature allows you to execute a workflow autonomously"
+
+## Output Format
+
+```
+Analyzing completed work...
+
+Detected changes:
+- Sprint: CFN Loop Recovery System
+- New commands: 3
+- New features: 5
+- API changes: 2
+- CLI updates: 4
+
+Spawning documentation agents...
+✅ Command docs agent (logs-slash-commands.md)
+✅ Feature docs agent (logs-features.md)
+✅ API docs agent (logs-api.md)
+✅ CLI docs agent (logs-cli-redis.md)
+
+Updating documentation...
+
+logs-slash-commands.md
+  + /recovery-status
+  + /recovery-resume
+  + /github-commit
+
+logs-features.md
+  + Crash Detection
+  + Git Checkpoint Recovery
+  + API Key Rotation
+
+logs-api.md
+  + POST /api/recovery/status
+  + GET /api/checkpoints
+
+logs-cli-redis.md
+  + recovery:status
+  + recovery:resume
+
+Updating index...
+✅ logs-documentation-index.md updated
+
+Validating documentation...
+✅ Markdown validation passed
+✅ All links valid
+✅ Sparse language compliance: 100%
+
+Documentation update complete.
+```
+
+## Integration with CFN Loop
+
+### Auto-Trigger Conditions
+```javascript
+// Automatically trigger documentation after:
+if (
+  epicComplete ||                    // Epic completion
+  sprintComplete ||                  // Sprint completion
+  majorPhaseComplete ||              // Major phase completion
+  newSlashCommandAdded ||            // New slash command
+  publicAPIChanged                   // Public API change
+) {
+  executeCommand('/cfn-loop-document');
+}
+```
+
+### Memory Integration
+```javascript
+// Store documentation updates in swarm memory
+mcp__claude-flow-novice__memory_usage({
+  action: "store",
+  namespace: "documentation",
+  key: "last-update",
+  value: JSON.stringify({
+    timestamp: Date.now(),
+    sprint: sprintName,
+    filesUpdated: updatedFiles,
+    newCommands: commandsList
+  })
+})
+```
+
+## Safety Features
+
+### Backup Before Update
+```bash
+# Create backup of all readme files
+for file in readme/*.md; do
+  cp "$file" "$file.backup-$(date +%s)"
+done
+```
+
+### Validation Gates
+- Markdown syntax validation (no broken markup)
+- Link validation (all internal links work)
+- Code example testing (examples execute correctly)
+- Sparse language check (pattern compliance)
+
+### Rollback Capability
+```bash
+# Rollback documentation updates if validation fails
+if [ "$VALIDATION_FAILED" = true ]; then
+  git restore readme/
+  echo "❌ Documentation update failed validation"
+  echo "Changes rolled back"
+  exit 1
+fi
+```
+
+## Example Workflow
+
+```bash
+# After completing CFN Loop epic
+git log -1
+# Output: feat(cfn-loop): Complete Epic - Recovery System v1.0
+
+# Auto-trigger documentation
+/cfn-loop-document --epic=recovery-system
+
+# Agents analyze implementation
+# - Read 50+ commits
+# - Identify 12 new features
+# - Find 8 new commands
+# - Detect 5 API changes
+
+# Update all affected documentation files
+# Validate changes
+# Commit updates automatically
+```

package/.claude/commands/github-commit.md

@@ -0,0 +1,289 @@
+---
+description: "Analyze staged changes, commit, push, and monitor CI/CD pipeline status"
+argument-hint: "[--chat|--full]"
+allowed-tools: ["Bash", "Read", "Grep", "Glob", "BashOutput", "TodoWrite"]
+---
+
+# GitHub Commit - Automated Git Workflow with CI/CD Monitoring
+
+Analyze staged changes, create commits, push to remote, and monitor CI/CD pipeline execution.
+
+🚨 **AUTOMATED GIT WORKFLOW WITH CI/CD MONITORING**
+
+**Options**: $ARGUMENTS
+
+## Command Modes
+
+```bash
+/github-commit              # Analyze all staged changes in repository
+/github-commit --chat       # Only analyze changes made in current chat session
+/github-commit --full       # Full repository analysis with detailed metrics
+```
+
+## Execution Pattern
+
+### Step 1: Analyze Changes
+```bash
+# Determine scope based on flags
+if [[ "$ARGUMENTS" == *"--chat"* ]]; then
+  # Get files modified in current session
+  git diff --name-only HEAD
+else
+  # Get all staged changes
+  git status --porcelain
+  git diff --staged
+fi
+```
+
+### Step 2: Generate Commit Message
+```bash
+# Analyze changes and draft commit message
+git diff --staged --stat
+git log -3 --oneline  # Match repository commit style
+
+# Generate commit message following conventional commits:
+# - feat: New feature
+# - fix: Bug fix
+# - refactor: Code refactoring
+# - docs: Documentation updates
+# - test: Test additions/modifications
+# - chore: Maintenance tasks
+```
+
+### Step 3: Create Commit
+```bash
+git add <relevant-files>
+git commit -m "$(cat <<'EOF'
+<type>(<scope>): <subject>
+
+<body - explain WHY not WHAT>
+
+
+
+
+EOF
+)"
+```
+
+### Step 4: Push to Remote
+```bash
+# Get current branch
+BRANCH=$(git rev-parse --abbrev-ref HEAD)
+
+# Push with upstream tracking
+git push -u origin "$BRANCH"
+```
+
+### Step 5: Monitor CI/CD Pipeline
+```bash
+# Wait for CI/CD to start (5 second delay)
+sleep 5
+
+# Monitor GitHub Actions workflow status
+gh run list --branch "$BRANCH" --limit 1 --json status,conclusion,name,databaseId
+
+# Poll every 10 seconds until completion
+while true; do
+  STATUS=$(gh run view --json status,conclusion -q '.status,.conclusion')
+
+  if [[ "$STATUS" == *"completed"* ]]; then
+    # Check if successful or failed
+    if [[ "$STATUS" == *"success"* ]]; then
+      echo "✅ CI/CD Pipeline PASSED"
+      break
+    else
+      echo "❌ CI/CD Pipeline FAILED"
+      gh run view --log-failed
+      exit 1
+    fi
+  fi
+
+  sleep 10
+done
+```
+
+## Flags
+
+### --chat (Session Scope)
+**Purpose**: Only commit changes made during current chat session
+
+**Implementation**:
+```bash
+# Get session start time (approximate)
+SESSION_START=$(date -d "30 minutes ago" +%s)
+
+# Find files modified after session start
+git diff --name-only HEAD | while read file; do
+  FILE_MTIME=$(stat -c %Y "$file")
+  if [ "$FILE_MTIME" -gt "$SESSION_START" ]; then
+    echo "$file"
+  fi
+done
+```
+
+### --full (Comprehensive Analysis)
+**Purpose**: Full repository analysis with metrics
+
+**Implementation**:
+```bash
+# Generate comprehensive change analysis
+echo "## Change Summary"
+git diff --staged --stat
+git diff --staged --shortstat
+
+echo "## File Changes"
+git diff --staged --name-status
+
+echo "## Impact Analysis"
+# Count lines added/removed by file type
+git diff --staged --numstat | awk '
+  {
+    files++
+    add += $1
+    del += $2
+
+    if ($3 ~ /\.ts$|\.tsx$/) ts++
+    if ($3 ~ /\.js$|\.jsx$/) js++
+    if ($3 ~ /\.md$/) docs++
+  }
+  END {
+    print "Files modified: " files
+    print "Lines added: " add
+    print "Lines removed: " del
+    print "TypeScript files: " ts
+    print "JavaScript files: " js
+    print "Documentation: " docs
+  }
+'
+```
+
+## CI/CD Monitoring
+
+### Supported Platforms
+- **GitHub Actions** (via `gh` CLI)
+- **GitLab CI** (via `glab` CLI)
+- **CircleCI** (via API)
+- **Jenkins** (via API)
+
+### Failure Handling
+```bash
+# On CI/CD failure
+if [[ "$CI_STATUS" == "failure" ]]; then
+  echo "❌ Pipeline failed. Retrieving logs..."
+
+  # Get failed job logs
+  gh run view --log-failed
+
+  # Offer rollback option
+  echo ""
+  echo "Options:"
+  echo "1. Fix locally and push again"
+  echo "2. Revert commit: git revert HEAD && git push"
+  echo "3. Force fix: git commit --amend && git push --force-with-lease"
+fi
+```
+
+## Output Format
+
+```
+Analyzing staged changes...
+
+Files to commit (--chat scope):
+  M src/cfn-loop/crash-detector.ts
+  M src/cli/commands/recovery-resume.ts
+  A tests/cfn-loop/crash-detection.test.ts
+
+Commit message:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+feat(cfn-loop): Add crash detection and recovery
+
+Implement crash detection system with automatic
+recovery and resume capabilities for interrupted
+CFN Loop executions.
+
+
+
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Creating commit...
+✅ Commit created: abc1234
+
+Pushing to origin/main...
+✅ Push successful
+
+Monitoring CI/CD pipeline...
+⏳ GitHub Actions workflow starting...
+⏳ Running tests (1/3 jobs complete)...
+⏳ Running build (2/3 jobs complete)...
+⏳ Running deploy (3/3 jobs complete)...
+
+✅ CI/CD Pipeline PASSED (2m 34s)
+
+All checks passed. Changes successfully deployed.
+```
+
+## Safety Features
+
+### Pre-Commit Validation
+```bash
+# Run pre-commit hooks if configured
+if [ -f .git/hooks/pre-commit ]; then
+  .git/hooks/pre-commit
+fi
+
+# Validate no secrets in staged files
+git diff --staged | grep -i -E "(api[_-]?key|password|secret|token)" && {
+  echo "⚠️  Warning: Potential secrets detected in staged changes"
+  echo "Please review before committing"
+  exit 1
+}
+```
+
+### Branch Protection
+```bash
+# Never force push to protected branches
+PROTECTED_BRANCHES=("main" "master" "production")
+
+if [[ " ${PROTECTED_BRANCHES[@]} " =~ " ${BRANCH} " ]]; then
+  echo "⚠️  Warning: Pushing to protected branch '$BRANCH'"
+  echo "Force push disabled for safety"
+  git push origin "$BRANCH"  # No --force
+fi
+```
+
+## Integration with Other Commands
+
+- **Pre-commit**: Runs `/hooks post-edit` validation
+- **Post-push**: Triggers `/github workflow status` monitoring
+- **On failure**: Suggests `/github pr create` for review before merge
+- **Documentation**: Auto-triggers `/cfn-loop-document` on epic completion
+
+## Example Workflows
+
+### Daily Development
+```bash
+# Make changes throughout the day
+# Ready to commit
+/github-commit --chat
+
+# Output: Commits only files modified in current session
+```
+
+### Feature Completion
+```bash
+# Completed feature implementation
+/github-commit --full
+
+# Output: Full analysis with metrics, CI/CD monitoring
+```
+
+### Hotfix Deployment
+```bash
+# Critical bug fix
+/github-commit
+
+# Monitors CI/CD closely
+# On success: Auto-deploys to production
+# On failure: Immediately shows logs and rollback options
+```