claude-code-templates 1.21.6 → 1.21.8

package/components/commands/automation/workflow-orchestrator.md

@@ -1,576 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [workflow-name] | create | run | schedule | monitor
-description: Orchestrate complex automation workflows with task dependencies, scheduling, and cross-platform execution
-model: sonnet
----
-
-# Workflow Orchestrator
-
-Orchestrate complex automation workflows: $ARGUMENTS
-
-## Current Workflow State
-
-- Existing workflows: !`find . -name "*.workflow.json" -o -name "workflow.yml" -o -name "Taskfile.yml" | head -5`
-- Cron jobs: !`crontab -l 2>/dev/null || echo "No crontab found"`
-- Running processes: !`ps aux | grep -E "(workflow|task|job)" | head -3`
-- System capabilities: !`which docker node python3 | head -3`
-- Configuration: @.workflow-config.json or @workflows/ (if exists)
-
-## Task
-
-Create and manage complex automation workflows with dependency management, scheduling, and monitoring.
-
-## Workflow Definition Structure
-
-### Basic Workflow Schema
-```json
-{
-  "name": "deployment-workflow",
-  "version": "1.0.0",
-  "description": "Complete deployment automation with testing and rollback",
-  "trigger": {
-    "type": "manual|schedule|webhook|file_change",
-    "config": {
-      "schedule": "0 2 * * *",
-      "files": ["src/**/*", "package.json"],
-      "webhook": "/trigger/deploy"
-    }
-  },
-  "environment": {
-    "NODE_ENV": "production",
-    "LOG_LEVEL": "info"
-  },
-  "tasks": [
-    {
-      "id": "pre-build",
-      "name": "Pre-build validation",
-      "type": "shell",
-      "command": "npm run validate",
-      "timeout": 300,
-      "retry": {
-        "attempts": 3,
-        "delay": 5000
-      }
-    },
-    {
-      "id": "build",
-      "name": "Build application",
-      "type": "shell",
-      "command": "npm run build",
-      "depends_on": ["pre-build"],
-      "parallel": false,
-      "timeout": 600
-    },
-    {
-      "id": "test",
-      "name": "Run tests",
-      "type": "shell",
-      "command": "npm run test:ci",
-      "depends_on": ["build"],
-      "condition": "${env.SKIP_TESTS} != 'true'"
-    },
-    {
-      "id": "deploy",
-      "name": "Deploy to staging",
-      "type": "shell",
-      "command": "npm run deploy:staging",
-      "depends_on": ["test"],
-      "on_success": ["notify-success"],
-      "on_failure": ["rollback", "notify-failure"]
-    }
-  ],
-  "notifications": {
-    "channels": ["slack", "email"],
-    "on_completion": true,
-    "on_failure": true
-  }
-}
-```
-
-## Advanced Workflow Features
-
-### 1. **Conditional Execution**
-```json
-{
-  "id": "conditional-deploy",
-  "name": "Deploy if tests pass",
-  "type": "conditional",
-  "condition": "${tasks.test.exit_code} == 0 && ${env.DEPLOY_ENABLED} == 'true'",
-  "then": {
-    "type": "shell",
-    "command": "npm run deploy"
-  },
-  "else": {
-    "type": "shell",
-    "command": "echo 'Skipping deployment'"
-  }
-}
-```
-
-### 2. **Parallel Task Execution**
-```json
-{
-  "id": "parallel-tests",
-  "name": "Run parallel test suites",
-  "type": "parallel",
-  "tasks": [
-    {
-      "id": "unit-tests",
-      "command": "npm run test:unit"
-    },
-    {
-      "id": "integration-tests", 
-      "command": "npm run test:integration"
-    },
-    {
-      "id": "e2e-tests",
-      "command": "npm run test:e2e"
-    }
-  ],
-  "wait_for": "all|any|first",
-  "timeout": 1800
-}
-```
-
-### 3. **Loop and Iteration**
-```json
-{
-  "id": "deploy-multiple-envs",
-  "name": "Deploy to multiple environments",
-  "type": "loop",
-  "items": ["staging", "qa", "production"],
-  "task": {
-    "type": "shell",
-    "command": "npm run deploy -- --env ${item}",
-    "timeout": 300
-  },
-  "parallel": false,
-  "stop_on_failure": true
-}
-```
-
-### 4. **File and Data Processing**
-```json
-{
-  "id": "process-data",
-  "name": "Process data files",
-  "type": "data_processor",
-  "input": {
-    "type": "file",
-    "path": "data/*.json"
-  },
-  "processor": {
-    "type": "javascript",
-    "script": "scripts/process-data.js"
-  },
-  "output": {
-    "type": "file",
-    "path": "processed/output.json"
-  }
-}
-```
-
-## Workflow Orchestration Engine
-
-### Core Engine Implementation
-```javascript
-class WorkflowOrchestrator {
-  constructor(config) {
-    this.config = config;
-    this.tasks = new Map();
-    this.running = new Set();
-    this.completed = new Set();
-    this.failed = new Set();
-    this.logger = new Logger(config.logLevel);
-  }
-
-  async execute(workflowPath) {
-    const workflow = await this.loadWorkflow(workflowPath);
-    
-    try {
-      await this.validateWorkflow(workflow);
-      await this.setupEnvironment(workflow.environment);
-      
-      const result = await this.executeWorkflow(workflow);
-      await this.cleanup();
-      
-      return result;
-    } catch (error) {
-      await this.handleError(error, workflow);
-      throw error;
-    }
-  }
-
-  async executeWorkflow(workflow) {
-    const taskGraph = this.buildDependencyGraph(workflow.tasks);
-    const execution = {
-      id: this.generateExecutionId(),
-      workflow: workflow.name,
-      startTime: Date.now(),
-      tasks: {}
-    };
-
-    while (this.hasRunnableTasks(taskGraph)) {
-      const runnableTasks = this.getRunnableTasks(taskGraph);
-      
-      if (runnableTasks.length === 0) {
-        break; // Circular dependency or all failed
-      }
-
-      await this.executeTaskBatch(runnableTasks, execution);
-    }
-
-    return this.generateExecutionReport(execution);
-  }
-
-  async executeTask(task, execution) {
-    const taskExecution = {
-      id: task.id,
-      name: task.name,
-      startTime: Date.now(),
-      status: 'running'
-    };
-
-    execution.tasks[task.id] = taskExecution;
-    this.running.add(task.id);
-
-    try {
-      // Pre-execution hooks
-      await this.runPreHooks(task);
-      
-      // Task execution
-      const result = await this.runTaskByType(task);
-      
-      // Post-execution hooks
-      await this.runPostHooks(task, result);
-
-      taskExecution.endTime = Date.now();
-      taskExecution.duration = taskExecution.endTime - taskExecution.startTime;
-      taskExecution.status = 'completed';
-      taskExecution.result = result;
-
-      this.completed.add(task.id);
-      this.running.delete(task.id);
-
-      // Handle success callbacks
-      if (task.on_success) {
-        await this.executeCallbacks(task.on_success, taskExecution);
-      }
-
-      return result;
-    } catch (error) {
-      taskExecution.endTime = Date.now();
-      taskExecution.duration = taskExecution.endTime - taskExecution.startTime;
-      taskExecution.status = 'failed';
-      taskExecution.error = error.message;
-
-      this.failed.add(task.id);
-      this.running.delete(task.id);
-
-      // Handle failure callbacks
-      if (task.on_failure) {
-        await this.executeCallbacks(task.on_failure, taskExecution);
-      }
-
-      throw error;
-    }
-  }
-
-  async runTaskByType(task) {
-    switch (task.type) {
-      case 'shell':
-        return await this.executeShellTask(task);
-      case 'http':
-        return await this.executeHttpTask(task);
-      case 'docker':
-        return await this.executeDockerTask(task);
-      case 'javascript':
-        return await this.executeJavaScriptTask(task);
-      case 'python':
-        return await this.executePythonTask(task);
-      default:
-        throw new Error(`Unknown task type: ${task.type}`);
-    }
-  }
-}
-```
-
-### Task Types Implementation
-
-#### Shell Task
-```javascript
-async executeShellTask(task) {
-  const { spawn } = require('child_process');
-  
-  return new Promise((resolve, reject) => {
-    const process = spawn('sh', ['-c', task.command], {
-      cwd: task.cwd || process.cwd(),
-      env: { ...process.env, ...task.environment },
-      stdio: ['pipe', 'pipe', 'pipe']
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    process.stdout.on('data', (data) => {
-      stdout += data.toString();
-      if (task.live_output) {
-        console.log(data.toString());
-      }
-    });
-
-    process.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    const timeout = setTimeout(() => {
-      process.kill('SIGKILL');
-      reject(new Error(`Task timeout after ${task.timeout}ms`));
-    }, task.timeout || 300000);
-
-    process.on('close', (code) => {
-      clearTimeout(timeout);
-      if (code === 0) {
-        resolve({ stdout, stderr, exitCode: code });
-      } else {
-        reject(new Error(`Shell command failed with exit code ${code}: ${stderr}`));
-      }
-    });
-  });
-}
-```
-
-#### HTTP Task
-```javascript
-async executeHttpTask(task) {
-  const axios = require('axios');
-  
-  const config = {
-    method: task.method || 'GET',
-    url: task.url,
-    headers: task.headers || {},
-    timeout: task.timeout || 30000
-  };
-
-  if (task.data) {
-    config.data = task.data;
-  }
-
-  if (task.auth) {
-    config.auth = task.auth;
-  }
-
-  try {
-    const response = await axios(config);
-    return {
-      status: response.status,
-      data: response.data,
-      headers: response.headers
-    };
-  } catch (error) {
-    throw new Error(`HTTP request failed: ${error.message}`);
-  }
-}
-```
-
-## Workflow Scheduling
-
-### Cron Integration
-```bash
-#!/bin/bash
-# setup-workflow-cron.sh
-
-# Daily backup workflow
-0 2 * * * cd /path/to/project && node workflow-engine.js run backup-workflow.json
-
-# Hourly health check
-0 * * * * cd /path/to/project && node workflow-engine.js run health-check.json
-
-# Weekly cleanup
-0 0 * * 0 cd /path/to/project && node workflow-engine.js run cleanup-workflow.json
-```
-
-### Systemd Timer (Linux)
-```ini
-# /etc/systemd/system/workflow-orchestrator.timer
-[Unit]
-Description=Workflow Orchestrator Timer
-Requires=workflow-orchestrator.service
-
-[Timer]
-OnCalendar=*:0/5
-Persistent=true
-
-[Install]
-WantedBy=timers.target
-```
-
-## Monitoring and Alerting
-
-### Workflow Metrics Dashboard
-```javascript
-class WorkflowMonitor {
-  constructor() {
-    this.metrics = {
-      totalRuns: 0,
-      successfulRuns: 0,
-      failedRuns: 0,
-      averageDuration: 0,
-      taskMetrics: new Map()
-    };
-  }
-
-  recordExecution(execution) {
-    this.metrics.totalRuns++;
-    
-    if (execution.status === 'completed') {
-      this.metrics.successfulRuns++;
-    } else {
-      this.metrics.failedRuns++;
-    }
-
-    // Update average duration
-    const totalDuration = this.metrics.averageDuration * (this.metrics.totalRuns - 1) + execution.duration;
-    this.metrics.averageDuration = totalDuration / this.metrics.totalRuns;
-
-    // Record task metrics
-    for (const [taskId, task] of Object.entries(execution.tasks)) {
-      if (!this.metrics.taskMetrics.has(taskId)) {
-        this.metrics.taskMetrics.set(taskId, {
-          runs: 0,
-          failures: 0,
-          averageDuration: 0
-        });
-      }
-
-      const taskMetrics = this.metrics.taskMetrics.get(taskId);
-      taskMetrics.runs++;
-      
-      if (task.status === 'failed') {
-        taskMetrics.failures++;
-      }
-
-      const taskTotalDuration = taskMetrics.averageDuration * (taskMetrics.runs - 1) + task.duration;
-      taskMetrics.averageDuration = taskTotalDuration / taskMetrics.runs;
-    }
-  }
-
-  getHealthReport() {
-    const successRate = (this.metrics.successfulRuns / this.metrics.totalRuns) * 100;
-    
-    return {
-      overall: {
-        successRate: successRate.toFixed(2) + '%',
-        totalRuns: this.metrics.totalRuns,
-        averageDuration: (this.metrics.averageDuration / 1000).toFixed(2) + 's'
-      },
-      tasks: this.getTaskHealthReport()
-    };
-  }
-}
-```
-
-### Alert Configuration
-```json
-{
-  "alerts": [
-    {
-      "name": "workflow-failure",
-      "condition": "execution.status === 'failed'",
-      "channels": ["slack", "email"],
-      "template": "Workflow ${workflow.name} failed: ${error.message}"
-    },
-    {
-      "name": "high-failure-rate",
-      "condition": "metrics.successRate < 90",
-      "channels": ["slack"],
-      "template": "Workflow success rate dropped to ${metrics.successRate}%"
-    },
-    {
-      "name": "long-duration",
-      "condition": "execution.duration > workflow.expected_duration * 2",
-      "channels": ["email"],
-      "template": "Workflow taking unusually long: ${execution.duration}ms"
-    }
-  ]
-}
-```
-
-## CLI Interface
-
-### Command-line Usage
-```bash
-# Create new workflow
-workflow create --name "deployment" --template "web-app"
-
-# Run workflow
-workflow run deployment-workflow.json
-
-# Schedule workflow
-workflow schedule --cron "0 2 * * *" backup-workflow.json
-
-# Monitor workflows
-workflow monitor --live
-
-# View execution history
-workflow history --limit 10
-
-# Get workflow status
-workflow status --execution-id abc123
-
-# Validate workflow
-workflow validate deployment-workflow.json
-
-# Generate workflow from template
-workflow generate --type "ci-cd" --output ci-workflow.json
-```
-
-## Integration Examples
-
-### Slack Integration
-```javascript
-async function sendSlackNotification(message, channel = '#deployments') {
-  const webhook = process.env.SLACK_WEBHOOK_URL;
-  
-  await axios.post(webhook, {
-    channel: channel,
-    text: message,
-    username: 'Workflow Orchestrator',
-    icon_emoji: ':gear:'
-  });
-}
-```
-
-### Docker Integration
-```json
-{
-  "id": "docker-build",
-  "name": "Build Docker image",
-  "type": "docker",
-  "config": {
-    "dockerfile": "Dockerfile",
-    "context": ".",
-    "tags": ["myapp:latest", "myapp:${env.BUILD_NUMBER}"],
-    "build_args": {
-      "NODE_ENV": "production"
-    }
-  }
-}
-```
-
-### Database Integration
-```json
-{
-  "id": "db-migration",
-  "name": "Run database migrations",
-  "type": "database",
-  "config": {
-    "connection": "${env.DATABASE_URL}",
-    "migrations_path": "migrations/",
-    "rollback_on_failure": true
-  }
-}
-```
-
-This workflow orchestrator provides enterprise-grade automation capabilities with dependency management, monitoring, and cross-platform execution support.

package/components/commands/database/supabase-backup-manager.md

@@ -1,37 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [operation] | --backup | --restore | --schedule | --validate | --cleanup
-description: Manage Supabase database backups with automated scheduling and recovery procedures
-model: sonnet
----
-
-# Supabase Backup Manager
-
-Manage comprehensive Supabase database backups with automated scheduling and recovery validation: **$ARGUMENTS**
-
-## Current Backup Context
-
-- Supabase project: MCP integration for backup operations and status monitoring
-- Backup storage: Current backup configuration and storage capacity
-- Recovery testing: Last backup validation and recovery procedure verification
-- Automation status: !`find . -name "*.yml" -o -name "*.json" | xargs grep -l "backup\|cron" 2>/dev/null | head -3` scheduled backup configuration
-
-## Task
-
-Execute comprehensive backup management with automated procedures and recovery validation:
-
-**Backup Operation**: Use $ARGUMENTS to specify backup creation, data restoration, schedule management, backup validation, or cleanup procedures
-
-**Backup Management Framework**:
-1. **Backup Strategy** - Design backup schedules, implement retention policies, configure incremental backups, optimize storage usage
-2. **Automated Backup** - Create database snapshots, export schema and data, validate backup integrity, monitor backup completion
-3. **Recovery Procedures** - Test restore processes, validate data integrity, implement point-in-time recovery, optimize recovery time
-4. **Schedule Management** - Configure automated backup schedules, implement backup monitoring, setup failure notifications, optimize backup windows
-5. **Storage Optimization** - Manage backup storage, implement compression strategies, archive old backups, monitor storage costs
-6. **Disaster Recovery** - Plan disaster recovery procedures, test recovery scenarios, document recovery processes, validate business continuity
-
-**Advanced Features**: Automated backup validation, recovery time optimization, cross-region backup replication, backup encryption, compliance reporting.
-
-**Monitoring Integration**: Backup success monitoring, failure alerting, storage usage tracking, recovery time measurement, compliance reporting.
-
-**Output**: Complete backup management system with automated schedules, recovery procedures, validation reports, and disaster recovery planning.

package/components/commands/database/supabase-data-explorer.md

@@ -1,37 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [table-name] | --query [sql] | --export | --inspect
-description: Explore and analyze Supabase database data with intelligent querying and visualization
-model: sonnet
----
-
-# Supabase Data Explorer
-
-Explore and analyze Supabase database with intelligent querying and data insights: **$ARGUMENTS**
-
-## Current Data Context
-
-- Supabase MCP: Connected with read-only access for safe data exploration
-- Target table: Analysis of $ARGUMENTS for data exploration scope
-- Local queries: !`find . -name "*.sql" | head -5` existing SQL files for reference
-- Data models: !`find . -name "types" -o -name "models" -type d | head -3` application data structures
-
-## Task
-
-Execute comprehensive database exploration with intelligent analysis and insights:
-
-**Exploration Focus**: Use $ARGUMENTS to specify table inspection, SQL query execution, data export, or comprehensive database inspection
-
-**Data Exploration Framework**:
-1. **Database Discovery** - Explore table structures, analyze relationships, identify data patterns, assess data quality metrics
-2. **Intelligent Querying** - Execute read-only queries via MCP, optimize query performance, provide result analysis, suggest query improvements
-3. **Data Analysis** - Generate data insights, identify trends and anomalies, calculate statistical summaries, analyze data distribution
-4. **Schema Inspection** - Examine table schemas, analyze foreign key relationships, assess index effectiveness, review constraint validations
-5. **Export & Visualization** - Export data in multiple formats, create data visualizations, generate summary reports, optimize data presentation
-6. **Performance Analysis** - Analyze query execution plans, identify performance bottlenecks, suggest optimization strategies, monitor resource usage
-
-**Advanced Features**: Interactive data exploration, automated insight generation, data quality assessment, relationship mapping, trend analysis.
-
-**Safety Features**: Read-only operations, query validation, result limiting, performance monitoring, error handling.
-
-**Output**: Comprehensive data exploration with insights, optimized queries, export files, and performance recommendations.

package/components/commands/database/supabase-migration-assistant.md

@@ -1,37 +0,0 @@
----
-allowed-tools: Read, Write, Edit, Bash
-argument-hint: [migration-type] | --create | --alter | --seed | --rollback
-description: Generate and manage Supabase database migrations with automated testing and validation
-model: sonnet
----
-
-# Supabase Migration Assistant
-
-Generate and manage Supabase migrations with comprehensive testing and validation: **$ARGUMENTS**
-
-## Current Migration Context
-
-- Supabase project: MCP integration for migration management and validation
-- Migration files: !`find . -name "*migrations*" -type d -o -name "*.sql" | head -5` existing migration structure
-- Schema version: Current database schema state and migration history
-- Local changes: !`git diff --name-only | grep -E "\\.sql$|\\.ts$" | head -3` pending database modifications
-
-## Task
-
-Execute comprehensive migration management with automated validation and testing:
-
-**Migration Type**: Use $ARGUMENTS to specify table creation, schema alterations, data seeding, or migration rollback
-
-**Migration Management Framework**:
-1. **Migration Planning** - Analyze schema requirements, design migration strategy, identify dependencies, plan rollback procedures
-2. **Code Generation** - Generate migration SQL files, create TypeScript types, implement safety checks, optimize execution order
-3. **Validation Testing** - Test migration on development data, validate schema changes, verify data integrity, check constraint violations
-4. **Supabase Integration** - Apply migrations via MCP server, monitor execution status, handle error conditions, validate final state
-5. **Type Generation** - Generate TypeScript types, update application interfaces, sync with client-side schemas, maintain type safety
-6. **Rollback Strategy** - Create rollback migrations, test rollback procedures, implement data preservation, validate recovery process
-
-**Advanced Features**: Automated type generation, migration testing, performance impact analysis, team collaboration, CI/CD integration.
-
-**Safety Measures**: Pre-migration backups, dry-run validation, rollback testing, data integrity checks, performance monitoring.
-
-**Output**: Complete migration suite with SQL files, TypeScript types, test validation, rollback procedures, and deployment documentation.