claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/skills/cfn-deployment-lifecycle/lib/deployment/SKILL.md

@@ -1,293 +0,0 @@
----
-name: cfn-deployment
-version: 1.0.0
-description: Automated skill deployment pipeline for CFN Loop integration
-author: Task 1.1 Implementation Team
-dependencies: []
-tags: [deployment, automation, skills, pipeline]
----
-
-# CFN Deployment Skill
-
-Automated skill deployment pipeline that transitions approved skills from APPROVED → DEPLOYED state with atomic cross-database transactions, validation, and rollback capability.
-
-## Purpose
-
-This skill enables CFN Loop agents to deploy skills to production through a fully automated pipeline that ensures:
-- Validation before deployment
-- Atomic transactions across databases
-- Automatic version management
-- Comprehensive audit trail
-- Rollback capability on failure
-
-## Usage
-
-### Basic Deployment
-
-```bash
-# Deploy a skill from approved directory
-./scripts/deploy-approved-skills.sh .claude/skills/authentication
-```
-
-### Advanced Deployment
-
-```bash
-# Deploy with explicit version
-./scripts/deploy-approved-skills.sh .claude/skills/authentication --version=2.0.0
-
-# Deploy with user attribution
-./scripts/deploy-approved-skills.sh .claude/skills/authentication --deployed-by=admin@example.com
-
-# Skip validation (admin only, dangerous)
-./scripts/deploy-approved-skills.sh .claude/skills/authentication --skip-validation
-```
-
-## Integration with TypeScript
-
-```typescript
-import { DatabaseService } from './src/lib/database-service';
-import { SkillDeploymentPipeline } from './src/services/skill-deployment';
-
-const dbService = new DatabaseService({
-  sqlite: {
-    type: 'sqlite',
-    database: './data/cfn-loop.db',
-  },
-});
-
-await dbService.connect();
-
-const pipeline = new SkillDeploymentPipeline(dbService);
-
-const result = await pipeline.deploySkill({
-  skillPath: '.claude/skills/authentication',
-  deployedBy: 'system',
-});
-
-if (result.success) {
-  console.log(`Deployed: ${result.skillName} v${result.version}`);
-} else {
-  console.error(`Deployment failed: ${result.error}`);
-}
-
-await dbService.disconnect();
-```
-
-## Validation Checks
-
-Before deployment, the pipeline validates:
-
-1. **Content Path**: Skill directory exists with required files
-2. **Schema Compliance**: SKILL.md frontmatter is valid
-3. **Name Uniqueness**: No existing skill with same name
-4. **Version Conflict**: Version doesn't already exist
-5. **Execute Script**: execute.sh is executable
-6. **Tests**: test.sh exists and is executable (warning only)
-
-## Deployment Workflow
-
-```
-APPROVED → DEPLOYING → DEPLOYED (success)
-                     → FAILED (validation/error)
-                     → ROLLED_BACK (rollback triggered)
-```
-
-### Atomic Deployment
-
-Deployment is atomic across:
-- SQLite Skills DB (skills table)
-- SQLite Audit Trail (deployment_audit table)
-
-All operations succeed or all are rolled back.
-
-## Rollback
-
-```typescript
-// Rollback a deployment
-const success = await pipeline.rollbackDeployment(deploymentId);
-
-if (success) {
-  console.log('Deployment rolled back successfully');
-}
-```
-
-## Deployment History
-
-```typescript
-// Get deployment history for a skill
-const history = await pipeline.getDeploymentHistory('authentication', 10);
-
-history.forEach(audit => {
-  console.log(`${audit.deployed_at}: ${audit.from_status} → ${audit.to_status}`);
-});
-```
-
-## Error Handling
-
-The pipeline provides detailed error messages:
-
-```typescript
-const result = await pipeline.deploySkill({ skillPath: '/invalid/path' });
-
-if (!result.success) {
-  console.error('Error:', result.error);
-
-  if (result.validationResult) {
-    result.validationResult.errors.forEach(err => {
-      console.error(`- ${err.code}: ${err.message}`);
-    });
-  }
-}
-```
-
-## Audit Trail
-
-All deployment operations are recorded in the `deployment_audit` table:
-
-```sql
-SELECT
-  skill_id,
-  from_status,
-  to_status,
-  version,
-  success,
-  deployed_by,
-  deployed_at,
-  error_message
-FROM deployment_audit
-WHERE skill_id = 'skill-authentication-1.0.0-1234567890'
-ORDER BY deployed_at DESC;
-```
-
-## Security Considerations
-
-- **Validation Required**: Always validate skills before deployment (use `--skip-validation` sparingly)
-- **User Attribution**: Track who deployed each skill via `--deployed-by` parameter
-- **Version Control**: Prevent version conflicts through automatic checking
-- **Rollback Capability**: Recover from failed deployments quickly
-
-## Performance
-
-- Deployment completes in <1 second for typical skills
-- Validation adds ~200ms overhead
-- Database transaction commits are atomic and fast
-
-## Integration Points
-
-### Phase 4 Workflow Patterns
-
-The deployment pipeline integrates with Phase 4 workflow patterns (future enhancement):
-
-```typescript
-// Future: Deploy to PostgreSQL workflow_patterns table
-const tx = await dbService.executeTransaction([
-  {
-    database: 'sqlite',
-    operation: async (adapter) => {
-      return adapter.insert('skills', { ... });
-    },
-  },
-  {
-    database: 'postgres',
-    operation: async (adapter) => {
-      return adapter.insert('workflow_patterns', {
-        skill_id: skillId,
-        version: version,
-        status: 'DEPLOYED',
-      });
-    },
-  },
-]);
-```
-
-### CFN Loop Integration
-
-CFN coordinators can use this skill to automate skill deployment:
-
-```bash
-# In CFN Loop coordinator agent
-SKILL_PATH=".claude/skills/new-skill"
-
-if [[ -f "$SKILL_PATH/SKILL.md" ]]; then
-  ./scripts/deploy-approved-skills.sh "$SKILL_PATH" --deployed-by="cfn-coordinator"
-  echo "Skill deployed successfully"
-fi
-```
-
-## Monitoring Dashboard (Future)
-
-Planned dashboard features:
-- Recent deployments
-- Success/failure rate
-- Deployment timeline
-- Version history
-- Failed deployment analysis
-
-## Testing
-
-Comprehensive test coverage (95%+) ensures:
-- Validation logic correctness
-- Atomic transaction behavior
-- Rollback functionality
-- Error handling
-- Edge case coverage
-
-Run tests:
-
-```bash
-npm test -- tests/skill-deployment.test.ts
-```
-
-## Troubleshooting
-
-### Deployment Fails with "Name Not Unique"
-
-**Problem**: Skill with same name already exists
-
-**Solution**: Either:
-- Choose a different skill name
-- Archive the existing skill
-- Update the existing skill instead of creating new one
-
-### Deployment Fails with "Version Conflict"
-
-**Problem**: Version already exists for this skill
-
-**Solution**: Either:
-- Use auto-versioning (don't specify `--version`)
-- Specify a different explicit version
-- Increment version in SKILL.md frontmatter
-
-### Validation Fails with "Execute Script Not Executable"
-
-**Problem**: execute.sh doesn't have execute permissions
-
-**Solution**:
-```bash
-chmod +x .claude/skills/your-skill/execute.sh
-```
-
-### Database Connection Error
-
-**Problem**: SQLite database not accessible
-
-**Solution**:
-- Check database path exists
-- Verify file permissions
-- Ensure database is not locked
-
-## Related Documentation
-
-- [Skill Validator](../../src/services/skill-validator.ts) - Validation logic
-- [Skill Versioning](../../src/services/skill-versioning.ts) - Version management
-- [Database Service](../../src/lib/database-service/) - Database abstraction
-- [Integration Plan](../../docs/DATABASE_QUERY_ABSTRACTION.md) - Overall architecture
-
-## Future Enhancements
-
-- PostgreSQL workflow_patterns integration
-- Deployment webhooks/notifications
-- Automated rollback on health check failures
-- A/B deployment testing
-- Deployment dashboard UI
-- Git integration for deployment commits

package/claude-assets/skills/cfn-deployment-lifecycle/lib/deployment/execute.sh

@@ -1,21 +0,0 @@
-#!/bin/bash
-# CFN Deployment Skill - Execute Script
-# Part of Task 1.1: Automated Skill Deployment Pipeline
-
-set -euo pipefail
-
-# Get skill path from argument or environment
-SKILL_PATH="${1:-}"
-
-if [[ -z "$SKILL_PATH" ]]; then
-  echo "Error: Skill path is required"
-  echo "Usage: $0 <skill-path> [--deployed-by=<user>] [--version=<version>]"
-  exit 1
-fi
-
-# Get script directory
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
-
-# Forward to deployment script
-exec "$PROJECT_ROOT/scripts/deploy-approved-skills.sh" "$@"

package/claude-assets/skills/cfn-deployment-lifecycle/lib/promotion/SKILL.md

@@ -1,305 +0,0 @@
----
-name: cfn-promotion
-version: 1.0.0
-description: Skill Promotion Workflow - Atomic promotion from staging to production
-author: CFN Integration Team
-tags: [promotion, deployment, staging, production, sla]
-dependencies: [cfn-coordination, cfn-deployment]
----
-
-# Skill Promotion Workflow
-
-Manages atomic promotion of skills from staging directory to production with validation, SLA enforcement, and optional auto-deployment.
-
-## Overview
-
-The skill promotion workflow automates the process of moving generated skills from the staging directory to production, ensuring:
-
-- **Atomic Operations**: Skills are moved atomically to prevent partial promotions
-- **Pre-Promotion Validation**: Content integrity, schema compliance, and test execution
-- **SLA Enforcement**: Skills older than 48 hours in staging trigger alerts
-- **Git Integration**: Optional automatic commit with promotion metadata
-- **Auto-Deployment**: Optional integration with deployment pipeline (Task 1.1)
-
-## Architecture
-
-```
-.claude/skills/
-├── staging/              # Skills pending promotion (temporary)
-│   ├── auth-v2/
-│   │   ├── SKILL.md
-│   │   ├── execute.sh
-│   │   └── test.sh
-│   └── logging-v3/
-│       └── ...
-└── [production]/         # Production skills (after promotion)
-    ├── authentication/
-    ├── logging/
-    └── ...
-```
-
-## Usage
-
-### CLI Script
-
-```bash
-# List all staged skills
-./scripts/promote-staged-skills.sh --list
-
-# Check for stale skills (>48h)
-./scripts/promote-staged-skills.sh --check-stale
-
-# Promote a specific skill (with confirmation prompt)
-./scripts/promote-staged-skills.sh .claude/skills/staging/auth-v2
-
-# Auto-promote if validation passes (no prompt)
-./scripts/promote-staged-skills.sh .claude/skills/staging/auth-v2 --auto
-
-# Promote with git commit and deployment
-./scripts/promote-staged-skills.sh .claude/skills/staging/auth-v2 --auto --git-commit --deploy
-
-# Force promotion (skip validation - admin only)
-./scripts/promote-staged-skills.sh .claude/skills/staging/auth-v2 --force --auto
-```
-
-### TypeScript API
-
-```typescript
-import { SkillPromotionService } from './src/services/skill-promotion';
-import { DatabaseService } from './src/lib/database-service';
-
-const dbService = new DatabaseService({ type: 'sqlite', path: './data/cfn.db' });
-const promotionService = new SkillPromotionService(dbService);
-
-// Promote a skill
-const result = await promotionService.promoteSkill(
-  '.claude/skills/staging/auth-v2',
-  {
-    autoDeploy: true,
-    gitCommit: true,
-    notify: true,
-    promotedBy: 'admin@example.com'
-  }
-);
-
-if (result.success) {
-  console.log(`Skill promoted: ${result.skillName}`);
-  console.log(`Production path: ${result.productionPath}`);
-  console.log(`Deployment ID: ${result.deploymentId}`);
-} else {
-  console.error(`Promotion failed: ${result.error}`);
-}
-
-// List staged skills
-const stagedSkills = await promotionService.listStagedSkills();
-console.log(`${stagedSkills.length} skills in staging`);
-
-// Check for stale skills (>48h)
-const staleSkills = await promotionService.checkStaleness();
-if (staleSkills.length > 0) {
-  console.log(`WARNING: ${staleSkills.length} stale skills detected`);
-  for (const skill of staleSkills) {
-    console.log(`  - ${skill.name} (${skill.ageHours}h, ${skill.slaBreachHours}h over SLA)`);
-  }
-}
-```
-
-## Validation Checks
-
-The promotion validator performs the following checks:
-
-### 1. Content Integrity
-- `SKILL.md` exists and is readable
-- `execute.sh` exists and is executable
-- Optional: `test.sh`, `README.md` (warnings if missing)
-
-### 2. Schema Compliance
-- Frontmatter is valid YAML
-- Required fields: `name`, `description`, `version`
-- Version follows semantic versioning (X.Y.Z)
-- Optional fields: `author`, `tags`, `dependencies`
-
-### 3. Test Execution
-- If `test.sh` exists, it must be executable
-- Tests run with 30-second timeout
-- Test failures generate warnings (non-fatal, allow --force)
-
-### 4. Conflict Detection
-- Check if production skill already exists
-- Compare versions (staging vs production)
-- Warn if overwriting (require --overwrite flag)
-
-## SLA Enforcement
-
-Skills in staging for >48 hours trigger SLA breach alerts:
-
-### Manual Checking
-```bash
-./scripts/promote-staged-skills.sh --check-stale
-```
-
-### Automated Checking (Cron Job)
-```bash
-# Run daily at 9am to check for stale skills
-0 9 * * * cd /path/to/project && ./scripts/promote-staged-skills.sh --check-stale
-```
-
-### Background Job (TypeScript)
-```typescript
-import { PromotionSLAEnforcer } from './src/jobs/promotion-sla-enforcer';
-
-const enforcer = new PromotionSLAEnforcer(dbService, {
-  autoPromote: true,  // Auto-promote stale skills
-  notifyStale: true,  // Send notifications
-});
-
-await enforcer.enforceSLA();
-```
-
-## Configuration
-
-Environment variables:
-
-```bash
-# SLA threshold (hours)
-CFN_PROMOTION_SLA_THRESHOLD=48
-
-# Auto-promote stale skills
-CFN_PROMOTION_AUTO_PROMOTE=true
-
-# Enable git commits
-CFN_PROMOTION_GIT_COMMIT=true
-
-# Enable auto-deployment
-CFN_PROMOTION_AUTO_DEPLOY=true
-```
-
-## Monitoring
-
-### Database Queries
-
-```sql
--- Skills currently in staging
-SELECT name, created_at,
-       ROUND((julianday('now') - julianday(created_at)) * 24, 1) as age_hours
-FROM staged_skills
-WHERE promoted = 0
-ORDER BY created_at ASC;
-
--- Promotion success rate (last 30 days)
-SELECT
-  COUNT(*) as total_promotions,
-  SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as successful,
-  ROUND(100.0 * SUM(success) / COUNT(*), 2) as success_rate
-FROM skill_promotions
-WHERE promoted_at > datetime('now', '-30 days');
-
--- SLA breaches (skills >48h in staging)
-SELECT COUNT(*) as sla_breaches
-FROM staged_skills
-WHERE promoted = 0
-  AND created_at < datetime('now', '-48 hours');
-```
-
-### Dashboard Metrics
-
-- **Staged Skills Count**: Number of skills awaiting promotion
-- **Average Time in Staging**: Mean age of staged skills
-- **SLA Breach Count**: Skills >48h in staging
-- **Promotion Success Rate**: Successful promotions / total attempts
-- **Auto-Deploy Success Rate**: Successful deployments / total promotions
-
-## Integration Points
-
-### Task 1.1: Skill Deployment Pipeline
-After promotion, skills can be automatically deployed:
-
-```typescript
-const result = await promotionService.promoteSkill(stagingPath, {
-  autoDeploy: true  // Triggers SkillDeploymentPipeline
-});
-```
-
-### Task 0.5: Utilities
-- `file-operations.ts`: Atomic moves, file locking
-- `logging.ts`: Structured logging
-- `errors.ts`: Error handling
-
-### Phase 4: Skill Generation
-Generated skills are placed in staging directory:
-
-```typescript
-// Skill generator outputs to staging
-const stagingPath = await skillGenerator.generate({
-  output: '.claude/skills/staging/new-skill'
-});
-
-// Later: promote to production
-await promotionService.promoteSkill(stagingPath);
-```
-
-## Error Handling
-
-### Promotion Failures
-- Validation errors: Fix skill and retry
-- Conflicts: Use `--overwrite` or resolve manually
-- Test failures: Use `--force` (admin only) or fix tests
-
-### Rollback
-If promotion fails mid-operation:
-
-1. Staging skill remains in staging (atomic move failed)
-2. Production skill is unchanged (or restored from backup)
-3. Database records rollback
-4. Git commits are not created
-
-### Manual Rollback
-```bash
-# If promotion succeeded but deployment failed
-rm -rf .claude/skills/production-skill
-mv .claude/skills/staging/backup-skill .claude/skills/staging/production-skill
-```
-
-## Troubleshooting
-
-### "Validation failed: Missing required file: execute.sh"
-**Solution**: Add execute.sh to staged skill
-
-### "execute.sh is not executable"
-**Solution**: Run `chmod +x execute.sh`
-
-### "Tests failed (non-fatal)"
-**Solution**: Fix tests or use `--force` to skip
-
-### "Skill already exists in production"
-**Solution**: Use `--overwrite` flag or choose different name
-
-### "Git commit failed"
-**Solution**: Ensure git repo is initialized and configured
-
-## Best Practices
-
-1. **Always validate before promotion** (don't use --force unless necessary)
-2. **Run tests in staging** before promotion
-3. **Monitor SLA breaches** (check stale skills daily)
-4. **Use git commits** for audit trail
-5. **Enable auto-deployment** for production readiness
-6. **Backup production skills** before overwriting
-7. **Test promotions in dev environment** first
-
-## Future Enhancements
-
-- [ ] Webhook notifications (Slack, email)
-- [ ] Multi-stage promotion (staging → qa → production)
-- [ ] Approval workflows (require manual approval for production)
-- [ ] Promotion rollback automation
-- [ ] Integration with CI/CD pipelines
-- [ ] Promotion scheduling (promote at specific times)
-- [ ] Batch promotion (promote multiple skills at once)
-
-## Related Documentation
-
-- **Task 1.1**: `.claude/skills/cfn-deployment/SKILL.md`
-- **Task 0.5**: `docs/IMPLEMENTATION_UTILITIES.md`
-- **Phase 4**: `docs/SKILL_GENERATION.md` (future)
-- **Operational Guide**: `docs/SKILL_PROMOTION_WORKFLOW.md`

package/claude-assets/skills/cfn-docker-runtime/SKILL.md

@@ -1,84 +0,0 @@
----
-name: cfn-docker-runtime
-description: Docker container orchestration for CFN Loop - spawning, coordination, logging, wave execution
-version: 1.0.0
-tags: [mega-skill, docker, containers, orchestration]
-status: production
----
-
-# Docker Runtime Skill (Mega-Skill)
-
-**Version:** 1.0.0
-**Purpose:** Docker container orchestration for CFN Loop
-**Status:** Production
-**Consolidates:** cfn-docker-agent-spawning, cfn-docker-coordination, cfn-docker-logging, cfn-docker-loop-orchestration, cfn-docker-skill-mcp-selection, cfn-docker-wave-execution
-
----
-
-## Overview
-
-This mega-skill provides complete Docker container management for CFN Loop:
-- **Spawning** - Container-based agent deployment
-- **Coordination** - Redis-based container coordination
-- **Logging** - Container log collection and storage
-- **Orchestration** - Docker-mode loop execution
-- **MCP** - Skill-based MCP container selection
-- **Waves** - Wave-based parallel execution
-
----
-
-## Directory Structure
-
-```
-docker-runtime/
-├── SKILL.md
-├── lib/
-│   ├── spawning/         # From cfn-docker-agent-spawning
-│   ├── coordination/     # From cfn-docker-coordination
-│   ├── logging/          # From cfn-docker-logging
-│   ├── orchestration/    # From cfn-docker-loop-orchestration
-│   ├── mcp/              # From cfn-docker-skill-mcp-selection
-│   └── waves/            # From cfn-docker-wave-execution
-└── cli/
-    ├── spawn-container.sh
-    ├── coordinate.sh
-    └── execute-wave.sh
-```
-
----
-
-## Quick Start
-
-### Spawn Container Agent
-```bash
-./.claude/skills/docker-runtime/lib/spawning/spawn-agent.sh \
-  --agent-type backend-developer \
-  --task-id task-123
-```
-
-### Execute Wave
-```bash
-./.claude/skills/docker-runtime/lib/waves/execute-wave.sh \
-  --wave-id wave-1 \
-  --agents "backend-developer,tester"
-```
-
----
-
-## Migration Paths
-
-| Old Path | New Path |
-|----------|----------|
-| cfn-docker-agent-spawning/ | docker-runtime/lib/spawning/ |
-| cfn-docker-coordination/ | docker-runtime/lib/coordination/ |
-| cfn-docker-logging/ | docker-runtime/lib/logging/ |
-| cfn-docker-loop-orchestration/ | docker-runtime/lib/orchestration/ |
-| cfn-docker-skill-mcp-selection/ | docker-runtime/lib/mcp/ |
-| cfn-docker-wave-execution/ | docker-runtime/lib/waves/ |
-
----
-
-## Version History
-
-### 1.0.0 (2025-12-02)
-- Consolidated 6 Docker skills into mega-skill