claude-flow-novice 2.18.6 → 2.18.8

package/.claude/skills/cfn-docker-runtime/lib/coordination/src/volume-manager.ts

@@ -1,389 +0,0 @@
-/**
- * Volume Manager
- * Handles Docker volume creation and cleanup for CFN agents
- */
-
-import Docker from 'dockerode';
-import { DockerError, VolumeInfo } from './types';
-
-/**
- * Docker volume manager for persistent storage
- */
-export class VolumeManager {
-  private docker: Docker;
-
-  /**
-   * Initialize volume manager
-   * @param socketPath Path to Docker socket
-   */
-  constructor(socketPath: string = '/var/run/docker.sock') {
-    this.docker = new Docker({
-      socketPath: socketPath
-    });
-  }
-
-  /**
-   * Create a named volume
-   * @param volumeName Name of the volume
-   * @param driver Volume driver (default: local)
-   * @param labels Volume labels for organization
-   * @returns Volume object
-   */
-  async createVolume(
-    volumeName: string,
-    driver: string = 'local',
-    labels?: Record<string, string>
-  ): Promise<Docker.Volume> {
-    try {
-      // Check if volume already exists
-      try {
-        return await this.getVolume(volumeName);
-      } catch {
-        // Volume doesn't exist, create it
-      }
-
-      await this.docker.createVolume({
-        Name: volumeName,
-        Driver: driver,
-        Labels: {
-          'cfn-managed': 'true',
-          ...labels
-        }
-      });
-
-      // Return the volume object after creation
-      return await this.getVolume(volumeName);
-    } catch (error) {
-      throw new DockerError(
-        `Failed to create volume: ${volumeName}`,
-        'CREATE_VOLUME_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Get volume by name
-   * @param volumeName Volume name
-   * @returns Volume object
-   */
-  async getVolume(volumeName: string): Promise<Docker.Volume> {
-    try {
-      return this.docker.getVolume(volumeName);
-    } catch (error) {
-      throw new DockerError(
-        `Volume not found: ${volumeName}`,
-        'VOLUME_NOT_FOUND',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * List all volumes
-   * @param dangling Only list dangling volumes
-   * @returns Array of volume information
-   */
-  async listVolumes(dangling: boolean = false): Promise<VolumeInfo[]> {
-    try {
-      const filters = dangling ? { dangling: ['true'] } : undefined;
-      const result = await this.docker.listVolumes({ filters });
-
-      return result.Volumes?.map(v => this.convertToVolumeInfo(v)) || [];
-    } catch (error) {
-      throw new DockerError(
-        'Failed to list volumes',
-        'LIST_VOLUMES_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * List all CFN-managed volumes
-   * @returns Array of CFN volume information
-   */
-  async listCfnVolumes(): Promise<VolumeInfo[]> {
-    try {
-      const result = await this.docker.listVolumes();
-
-      return (result.Volumes || [])
-        .filter(v => v.Labels?.['cfn-managed'] === 'true')
-        .map(v => this.convertToVolumeInfo(v));
-    } catch (error) {
-      throw new DockerError(
-        'Failed to list CFN volumes',
-        'LIST_CFN_VOLUMES_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Remove a volume
-   * @param volume Docker volume instance
-   * @param force Force remove even if in use
-   */
-  async removeVolume(volume: Docker.Volume, force: boolean = false): Promise<void> {
-    try {
-      await volume.remove({ force });
-    } catch (error) {
-      throw new DockerError(
-        'Failed to remove volume',
-        'REMOVE_VOLUME_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Remove volume by name
-   * @param volumeName Volume name
-   * @param force Force remove even if in use
-   */
-  async removeVolumeByName(volumeName: string, force: boolean = false): Promise<void> {
-    try {
-      const volume = await this.getVolume(volumeName);
-      await this.removeVolume(volume, force);
-    } catch (error) {
-      throw new DockerError(
-        `Failed to remove volume: ${volumeName}`,
-        'REMOVE_VOLUME_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Remove all dangling volumes
-   * @returns Number of volumes removed
-   */
-  async removeDanglingVolumes(): Promise<number> {
-    try {
-      const volumes = await this.listVolumes(true);
-      let removed = 0;
-
-      for (const volumeInfo of volumes) {
-        try {
-          const volume = await this.getVolume(volumeInfo.name);
-          await this.removeVolume(volume, true);
-          removed++;
-        } catch {
-          // Continue with next volume
-        }
-      }
-
-      return removed;
-    } catch (error) {
-      throw new DockerError(
-        'Failed to remove dangling volumes',
-        'REMOVE_DANGLING_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Get volume information
-   * @param volume Docker volume instance
-   * @returns Volume information
-   */
-  async getVolumeInfo(volume: Docker.Volume): Promise<VolumeInfo> {
-    try {
-      const inspect = await volume.inspect();
-      return this.convertToVolumeInfo(inspect);
-    } catch (error) {
-      throw new DockerError(
-        'Failed to inspect volume',
-        'INSPECT_VOLUME_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Check if volume exists
-   * @param volumeName Volume name
-   * @returns true if volume exists
-   */
-  async volumeExists(volumeName: string): Promise<boolean> {
-    try {
-      await this.getVolume(volumeName);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Create or get volume
-   * @param volumeName Volume name
-   * @param driver Volume driver
-   * @param labels Volume labels
-   * @returns Volume object
-   */
-  async ensureVolume(
-    volumeName: string,
-    driver: string = 'local',
-    labels?: Record<string, string>
-  ): Promise<Docker.Volume> {
-    const exists = await this.volumeExists(volumeName);
-
-    if (exists) {
-      return await this.getVolume(volumeName);
-    }
-
-    return await this.createVolume(volumeName, driver, labels);
-  }
-
-  /**
-   * Prune unused volumes
-   * @returns Number of volumes removed and space reclaimed
-   */
-  async pruneVolumes(): Promise<{
-    VolumesDeleted: string[];
-    SpaceReclaimed: number;
-  }> {
-    try {
-      const result = await this.docker.pruneVolumes();
-      return {
-        VolumesDeleted: result.VolumesDeleted || [],
-        SpaceReclaimed: result.SpaceReclaimed || 0
-      };
-    } catch (error) {
-      throw new DockerError(
-        'Failed to prune volumes',
-        'PRUNE_VOLUMES_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Create volume for agent
-   * @param agentId Agent ID
-   * @param agentType Agent type
-   * @returns Volume object
-   */
-  async createAgentVolume(
-    agentId: string,
-    agentType: string
-  ): Promise<Docker.Volume> {
-    const volumeName = `cfn-${agentId}`;
-
-    return await this.createVolume(volumeName, 'local', {
-      'cfn-agent-id': agentId,
-      'cfn-agent-type': agentType,
-      'cfn-created': new Date().toISOString()
-    });
-  }
-
-  /**
-   * Remove agent volume
-   * @param agentId Agent ID
-   * @param force Force removal
-   */
-  async removeAgentVolume(agentId: string, force: boolean = false): Promise<void> {
-    const volumeName = `cfn-${agentId}`;
-    await this.removeVolumeByName(volumeName, force);
-  }
-
-  /**
-   * Get agent volumes
-   * @param agentId Agent ID filter (optional)
-   * @returns Array of agent volume information
-   */
-  async getAgentVolumes(agentId?: string): Promise<VolumeInfo[]> {
-    try {
-      const cfnVolumes = await this.listCfnVolumes();
-
-      if (agentId) {
-        return cfnVolumes.filter(v =>
-          v.labels?.['cfn-agent-id'] === agentId
-        );
-      }
-
-      return cfnVolumes.filter(v =>
-        v.labels?.['cfn-agent-id'] !== undefined
-      );
-    } catch (error) {
-      throw new DockerError(
-        'Failed to get agent volumes',
-        'GET_AGENT_VOLUMES_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Cleanup all agent volumes
-   * @param agentId Optional agent ID to filter
-   * @param force Force removal
-   * @returns Number of volumes removed
-   */
-  async cleanupAgentVolumes(agentId?: string, force: boolean = false): Promise<number> {
-    try {
-      const volumes = await this.getAgentVolumes(agentId);
-      let removed = 0;
-
-      for (const volumeInfo of volumes) {
-        try {
-          await this.removeVolumeByName(volumeInfo.name, force);
-          removed++;
-        } catch {
-          // Continue with next volume
-        }
-      }
-
-      return removed;
-    } catch (error) {
-      throw new DockerError(
-        'Failed to cleanup agent volumes',
-        'CLEANUP_VOLUMES_ERROR',
-        error instanceof Error ? error : undefined
-      );
-    }
-  }
-
-  /**
-   * Convert Docker volume inspect result to VolumeInfo
-   * @param volume Docker volume inspect result
-   * @returns VolumeInfo object
-   */
-  private convertToVolumeInfo(volume: Docker.VolumeInspectInfo): VolumeInfo {
-    return {
-      name: volume.Name,
-      driver: volume.Driver,
-      mountpoint: volume.Mountpoint,
-      labels: volume.Labels,
-      dangling: Object.keys(volume.UsageData || {}).length === 0,
-      size: (volume.UsageData as any)?.Size
-    };
-  }
-
-  /**
-   * Get volume mount string for Docker API
-   * @param volumeName Volume name
-   * @param containerPath Path inside container
-   * @returns Mount string in format "volume:/path"
-   */
-  static getVolumeMount(volumeName: string, containerPath: string): string {
-    return `${volumeName}:${containerPath}`;
-  }
-
-  /**
-   * Get bind mount string for Docker API
-   * @param hostPath Host filesystem path
-   * @param containerPath Path inside container
-   * @param readOnly Whether to mount as read-only
-   * @returns Mount string in format "host:/container" or "host:/container:ro"
-   */
-  static getBindMount(
-    hostPath: string,
-    containerPath: string,
-    readOnly: boolean = false
-  ): string {
-    const mode = readOnly ? ':ro' : '';
-    return `${hostPath}:${containerPath}${mode}`;
-  }
-}

package/.claude/skills/cfn-edit-safety/lib/backup/SKILL.md.backup

@@ -1,277 +0,0 @@
-# Pre-Edit Backup Skill
-
-Creates and manages file backups before edit operations in agent workflows.
-
-## Overview
-
-The Pre-Edit Backup Skill safely preserves file content before modifications, enabling safe recovery if edits encounter issues. It maintains a structured backup directory with metadata and verification capabilities.
-
-## Features
-
-- **Atomic Backup Creation**: Creates timestamped backups with file hash validation
-- **Metadata Storage**: JSON metadata tracks backup timestamp, original path, agent ID, and file stats
-- **Hash Verification**: SHA256 hash generation (8-char truncated) for change detection
-- **Automatic Cleanup**: Removes old backups (24h TTL by default, configurable)
-- **Revert Capability**: Restore files to backed-up state
-- **Concurrent Safety**: Handles parallel backup operations safely
-
-## Architecture
-
-### Directory Structure
-```
-.backups/
-├── agent-id-1/
-│   ├── 1700000000000_a1b2c3d4/
-│   │   ├── original-file.ts          (backed-up file)
-│   │   ├── metadata.json             (backup metadata)
-│   │   └── revert.sh                 (restoration script)
-│   └── 1700000010000_e5f6g7h8/
-│       ├── original-file.ts
-│       ├── metadata.json
-│       └── revert.sh
-└── agent-id-2/
-    └── 1700000020000_i9j0k1l2/
-        ├── different-file.ts
-        ├── metadata.json
-        └── revert.sh
-```
-
-### Metadata Format
-```json
-{
-  "timestamp": "2024-11-20T10:30:45.123Z",
-  "agentId": "backend-dev-123",
-  "originalFile": "/absolute/path/to/file.ts",
-  "fileHash": "a1b2c3d4",
-  "backupPath": "/absolute/path/.backups/agent-id/timestamp_hash",
-  "createdAt": "2024-11-20T10:30:45.000Z",
-  "fileSize": 2048,
-  "lineCount": 42
-}
-```
-
-## TypeScript API
-
-### BackupManager Class
-
-```typescript
-import { BackupManager, BackupResult } from '@/hooks/backup-manager';
-
-const manager = new BackupManager(projectRoot, {
-  retentionHours: 24,
-  maxBackups: 10,
-  backupDir: '.backups',
-});
-
-// Create backup
-const result: BackupResult = await manager.createBackup(filePath, agentId);
-// Result: {
-//   backupPath: "/project/.backups/agent-123/1700000000000_a1b2c3d4",
-//   timestamp: "2024-11-20T10:30:45.123Z",
-//   fileHash: "a1b2c3d4",
-//   originalPath: "/project/src/file.ts",
-//   metadata: { ... }
-// }
-
-// List all backups for a file
-const backups = await manager.listBackups(filePath);
-// Returns sorted by most recent first
-
-// Revert to most recent backup
-await manager.revertFile(filePath, agentId);
-
-// Verify backup integrity
-const isValid = await manager.verifyBackup(backupPath);
-
-// Clean old backups
-const deletedCount = await manager.cleanOldBackups(agentId);
-```
-
-## CLI Interface
-
-### Pre-Edit Hook CLI
-
-Creates backup before file edits:
-
-```bash
-# TypeScript compiled version
-node dist/cli/pre-edit-hook.js /path/to/file.ts --agent-id agent-123
-
-# Output: /project/.backups/agent-123/1700000000000_a1b2c3d4
-```
-
-### Bash Wrapper
-
-For agent compatibility, use the bash wrapper:
-
-```bash
-# Primary wrapper (tries TypeScript, falls back to bash)
-./.claude/hooks/cfn-invoke-pre-edit-ts.sh /path/to/file.ts --agent-id agent-123
-
-# Legacy bash-only wrapper
-./.claude/hooks/cfn-invoke-pre-edit.sh /path/to/file.ts --agent-id agent-123
-```
-
-## Integration
-
-### In Agent Prompts
-
-Pre-edit backup is automatically injected into agent prompts via `src/cli/agent-prompt-builder.ts`:
-
-```bash
-# Before any Edit/Write operation
-BACKUP_PATH=$(./.claude/hooks/cfn-invoke-pre-edit.sh "$FILE_PATH" --agent-id "$AGENT_ID")
-
-# On validation failure, revert
-./.claude/skills/pre-edit-backup/revert-file.sh "$FILE_PATH" --agent-id "$AGENT_ID"
-```
-
-### Configuration
-
-Backup behavior is configured in agent initialization:
-
-```typescript
-interface BackupConfig {
-  retentionHours: number;  // Default: 24
-  maxBackups: number;      // Default: 10
-  backupDir: string;       // Default: '.backups'
-}
-```
-
-## Use Cases
-
-### 1. Safe File Modifications
-
-```typescript
-// Create backup before risky edit
-const backup = await manager.createBackup(filePath, agentId);
-
-try {
-  // Perform complex transformations
-  await modifyFile(filePath, changes);
-} catch (error) {
-  // Restore on error
-  await manager.revertFile(filePath, agentId);
-  throw error;
-}
-```
-
-### 2. Change Tracking
-
-```typescript
-// Get file history for an agent
-const backups = await manager.listBackups(filePath);
-
-backups.forEach((backup) => {
-  console.log(`Modified by ${backup.metadata.agentId} at ${backup.timestamp}`);
-  console.log(`  Size: ${backup.metadata.fileSize} bytes`);
-  console.log(`  Hash: ${backup.metadata.fileHash}`);
-});
-```
-
-### 3. Parallel Agent Safety
-
-```typescript
-// Multiple agents backing up same file
-const promises = agents.map((agent) =>
-  manager.createBackup(filePath, agent.id)
-);
-const results = await Promise.all(promises);
-// Each backup isolated by agent ID
-```
-
-## Testing
-
-Run tests with Jest:
-
-```bash
-npm test tests/backup-manager.test.ts
-
-# With coverage
-npm test tests/backup-manager.test.ts -- --coverage
-```
-
-Test coverage includes:
-- Backup creation and directory structure
-- Metadata generation and storage
-- File hash generation and consistency
-- Revert functionality
-- List operations and sorting
-- Cleanup (age-based and count-based)
-- Verification and integrity checks
-- Edge cases (empty files, large files, special characters, concurrency)
-
-## Performance
-
-- **Backup Creation**: <50ms typical (mostly file I/O)
-- **Hash Generation**: <5ms for typical files
-- **Cleanup**: <100ms for 10 backups
-- **List Operations**: Linear in number of backups
-- **Concurrent Backups**: Safe, isolated by agent ID
-
-## Troubleshooting
-
-### Backup Creation Fails
-
-```bash
-# Check file exists and is readable
-ls -lah "$FILE_PATH"
-
-# Check backup directory is writable
-touch .backups/test-write && rm .backups/test-write
-
-# Check disk space
-df -h
-```
-
-### Cannot Revert
-
-```bash
-# List available backups
-node -e "
-  const { BackupManager } = require('./dist/hooks/backup-manager.js');
-  const m = new BackupManager('.');
-  m.listBackups('$FILE_PATH').then(b => console.log(JSON.stringify(b, null, 2)))
-"
-
-# Verify backup integrity
-node -e "
-  const { BackupManager } = require('./dist/hooks/backup-manager.js');
-  const m = new BackupManager('.');
-  m.verifyBackup('$BACKUP_PATH').then(r => console.log(r ? '✅ Valid' : '❌ Corrupted'))
-"
-```
-
-### Old Backups Not Cleaning
-
-```bash
-# Manual cleanup with custom retention
-const manager = new BackupManager('.', { retentionHours: 12 });
-const deleted = await manager.cleanOldBackups(agentId);
-console.log(`Deleted ${deleted} old backups`);
-```
-
-## Migration Guide
-
-### From Bash to TypeScript
-
-The TypeScript implementation maintains compatibility with bash:
-
-1. **Existing bash hooks continue working** via wrapper scripts
-2. **TypeScript implementation is opt-in** via environment check in wrappers
-3. **Gradual rollout**: Use `CFN_USE_TS_HOOKS=true` to enable globally
-
-```bash
-# Enable TypeScript hooks for new workflows
-export CFN_USE_TS_HOOKS=true
-
-# Old bash API still works
-./.claude/hooks/cfn-invoke-pre-edit.sh file.ts --agent-id agent-1
-```
-
-## References
-
-- **CLI Configuration**: `.claude/hooks/cfn-post-edit.config.json`
-- **Agent Prompt Builder**: `src/cli/agent-prompt-builder.ts`
-- **Tests**: `tests/backup-manager.test.ts`
-- **Hook Wrappers**: `.claude/hooks/cfn-invoke-pre-edit*.sh`