claude-flow-novice 2.15.11 → 2.16.0

package/dist/coordination/store-success-criteria.js

@@ -0,0 +1,68 @@
+import Redis from 'ioredis';
+const argValue = (flag)=>{
+    const index = process.argv.indexOf(flag);
+    if (index === -1 || index + 1 >= process.argv.length) {
+        return undefined;
+    }
+    return process.argv[index + 1];
+};
+const parseArgs = ()=>{
+    const taskId = argValue('--task-id');
+    const criteriaRaw = argValue('--criteria');
+    if (!taskId) throw new Error('--task-id is required');
+    if (!/^[A-Za-z0-9_-]+$/.test(taskId)) {
+        throw new Error('Invalid task id format; use alphanumeric, dash, underscore only');
+    }
+    if (!criteriaRaw) throw new Error('--criteria is required');
+    return {
+        taskId,
+        criteriaRaw,
+        redisHost: process.env.REDIS_HOST || 'localhost',
+        redisPort: Number(process.env.REDIS_PORT || 6379),
+        ttlSeconds: 86400
+    };
+};
+const validateCriteria = (criteria)=>{
+    if (!Array.isArray(criteria.test_suites)) {
+        throw new Error('success criteria must include test_suites array');
+    }
+    if (criteria.test_suites.length === 0) {
+        throw new Error('test_suites cannot be empty');
+    }
+};
+const storeCriteria = async (args)=>{
+    let parsed;
+    try {
+        parsed = JSON.parse(args.criteriaRaw);
+    } catch  {
+        throw new Error('criteria is not valid JSON');
+    }
+    validateCriteria(parsed);
+    const redis = new Redis({
+        host: args.redisHost,
+        port: args.redisPort,
+        lazyConnect: true
+    });
+    try {
+        await redis.connect();
+        const key = `swarm:${args.taskId}:context`;
+        const serialized = JSON.stringify(parsed);
+        await redis.hset(key, 'success-criteria', serialized);
+        await redis.expire(key, args.ttlSeconds);
+        console.log(`✅ Success criteria stored in Redis: ${key}`);
+        console.log(`   Test suites: ${parsed.test_suites.length}`);
+        console.log(`   TTL: ${args.ttlSeconds} seconds`);
+    } finally{
+        redis.disconnect();
+    }
+};
+const main = async ()=>{
+    const args = parseArgs();
+    await storeCriteria(args);
+};
+main().catch((error)=>{
+    console.error(`❌ Failed to store success criteria: ${error.message}`);
+    process.exitCode = 1;
+});
+
+//# sourceMappingURL=store-success-criteria.js.map

package/dist/coordination/store-success-criteria.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/coordination/store-success-criteria.ts"],"sourcesContent":["import Redis from 'ioredis';\n\ninterface SuccessCriteriaArgs {\n  taskId: string;\n  criteriaRaw: string;\n  redisHost: string;\n  redisPort: number;\n  ttlSeconds: number;\n}\n\ntype TestSuite = {\n  name: string;\n  command: string;\n  required?: boolean;\n  pass_threshold?: number;\n};\n\ninterface SuccessCriteria {\n  test_suites: TestSuite[];\n  gate_mode?: string;\n  metadata?: Record<string, unknown>;\n}\n\nconst argValue = (flag: string): string | undefined => {\n  const index = process.argv.indexOf(flag);\n  if (index === -1 || index + 1 >= process.argv.length) {\n    return undefined;\n  }\n  return process.argv[index + 1];\n};\n\nconst parseArgs = (): SuccessCriteriaArgs => {\n  const taskId = argValue('--task-id');\n  const criteriaRaw = argValue('--criteria');\n\n  if (!taskId) throw new Error('--task-id is required');\n  if (!/^[A-Za-z0-9_-]+$/.test(taskId)) {\n    throw new Error('Invalid task id format; use alphanumeric, dash, underscore only');\n  }\n\n  if (!criteriaRaw) throw new Error('--criteria is required');\n\n  return {\n    taskId,\n    criteriaRaw,\n    redisHost: process.env.REDIS_HOST || 'localhost',\n    redisPort: Number(process.env.REDIS_PORT || 6379),\n    ttlSeconds: 86400,\n  };\n};\n\nconst validateCriteria = (criteria: SuccessCriteria) => {\n  if (!Array.isArray(criteria.test_suites)) {\n    throw new Error('success criteria must include test_suites array');\n  }\n  if (criteria.test_suites.length === 0) {\n    throw new Error('test_suites cannot be empty');\n  }\n};\n\nconst storeCriteria = async (args: SuccessCriteriaArgs) => {\n  let parsed: SuccessCriteria;\n  try {\n    parsed = JSON.parse(args.criteriaRaw) as SuccessCriteria;\n  } catch {\n    throw new Error('criteria is not valid JSON');\n  }\n\n  validateCriteria(parsed);\n\n  const redis = new Redis({\n    host: args.redisHost,\n    port: args.redisPort,\n    lazyConnect: true,\n  });\n\n  try {\n    await redis.connect();\n    const key = `swarm:${args.taskId}:context`;\n    const serialized = JSON.stringify(parsed);\n\n    await redis.hset(key, 'success-criteria', serialized);\n    await redis.expire(key, args.ttlSeconds);\n\n    console.log(`✅ Success criteria stored in Redis: ${key}`);\n    console.log(`   Test suites: ${parsed.test_suites.length}`);\n    console.log(`   TTL: ${args.ttlSeconds} seconds`);\n  } finally {\n    redis.disconnect();\n  }\n};\n\nconst main = async () => {\n  const args = parseArgs();\n  await storeCriteria(args);\n};\n\nmain().catch((error) => {\n  console.error(`❌ Failed to store success criteria: ${error.message}`);\n  process.exitCode = 1;\n});\n"],"names":["Redis","argValue","flag","index","process","argv","indexOf","length","undefined","parseArgs","taskId","criteriaRaw","Error","test","redisHost","env","REDIS_HOST","redisPort","Number","REDIS_PORT","ttlSeconds","validateCriteria","criteria","Array","isArray","test_suites","storeCriteria","args","parsed","JSON","parse","redis","host","port","lazyConnect","connect","key","serialized","stringify","hset","expire","console","log","disconnect","main","catch","error","message","exitCode"],"mappings":"AAAA,OAAOA,WAAW,UAAU;AAuB5B,MAAMC,WAAW,CAACC;IAChB,MAAMC,QAAQC,QAAQC,IAAI,CAACC,OAAO,CAACJ;IACnC,IAAIC,UAAU,CAAC,KAAKA,QAAQ,KAAKC,QAAQC,IAAI,CAACE,MAAM,EAAE;QACpD,OAAOC;IACT;IACA,OAAOJ,QAAQC,IAAI,CAACF,QAAQ,EAAE;AAChC;AAEA,MAAMM,YAAY;IAChB,MAAMC,SAAST,SAAS;IACxB,MAAMU,cAAcV,SAAS;IAE7B,IAAI,CAACS,QAAQ,MAAM,IAAIE,MAAM;IAC7B,IAAI,CAAC,mBAAmBC,IAAI,CAACH,SAAS;QACpC,MAAM,IAAIE,MAAM;IAClB;IAEA,IAAI,CAACD,aAAa,MAAM,IAAIC,MAAM;IAElC,OAAO;QACLF;QACAC;QACAG,WAAWV,QAAQW,GAAG,CAACC,UAAU,IAAI;QACrCC,WAAWC,OAAOd,QAAQW,GAAG,CAACI,UAAU,IAAI;QAC5CC,YAAY;IACd;AACF;AAEA,MAAMC,mBAAmB,CAACC;IACxB,IAAI,CAACC,MAAMC,OAAO,CAACF,SAASG,WAAW,GAAG;QACxC,MAAM,IAAIb,MAAM;IAClB;IACA,IAAIU,SAASG,WAAW,CAAClB,MAAM,KAAK,GAAG;QACrC,MAAM,IAAIK,MAAM;IAClB;AACF;AAEA,MAAMc,gBAAgB,OAAOC;IAC3B,IAAIC;IACJ,IAAI;QACFA,SAASC,KAAKC,KAAK,CAACH,KAAKhB,WAAW;IACtC,EAAE,OAAM;QACN,MAAM,IAAIC,MAAM;IAClB;IAEAS,iBAAiBO;IAEjB,MAAMG,QAAQ,IAAI/B,MAAM;QACtBgC,MAAML,KAAKb,SAAS;QACpBmB,MAAMN,KAAKV,SAAS;QACpBiB,aAAa;IACf;IAEA,IAAI;QACF,MAAMH,MAAMI,OAAO;QACnB,MAAMC,MAAM,CAAC,MAAM,EAAET,KAAKjB,MAAM,CAAC,QAAQ,CAAC;QAC1C,MAAM2B,aAAaR,KAAKS,SAAS,CAACV;QAElC,MAAMG,MAAMQ,IAAI,CAACH,KAAK,oBAAoBC;QAC1C,MAAMN,MAAMS,MAAM,CAACJ,KAAKT,KAAKP,UAAU;QAEvCqB,QAAQC,GAAG,CAAC,CAAC,oCAAoC,EAAEN,KAAK;QACxDK,QAAQC,GAAG,CAAC,CAAC,gBAAgB,EAAEd,OAAOH,WAAW,CAAClB,MAAM,EAAE;QAC1DkC,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEf,KAAKP,UAAU,CAAC,QAAQ,CAAC;IAClD,SAAU;QACRW,MAAMY,UAAU;IAClB;AACF;AAEA,MAAMC,OAAO;IACX,MAAMjB,OAAOlB;IACb,MAAMiB,cAAcC;AACtB;AAEAiB,OAAOC,KAAK,CAAC,CAACC;IACZL,QAAQK,KAAK,CAAC,CAAC,oCAAoC,EAAEA,MAAMC,OAAO,EAAE;IACpE3C,QAAQ4C,QAAQ,GAAG;AACrB"}

package/dist/coordination/store-task-context.js

@@ -0,0 +1,65 @@
+import Redis from 'ioredis';
+const argValue = (flag)=>{
+    const index = process.argv.indexOf(flag);
+    if (index === -1 || index + 1 >= process.argv.length) {
+        return undefined;
+    }
+    return process.argv[index + 1];
+};
+const parseArgs = ()=>{
+    const taskId = argValue('--task-id');
+    const description = argValue('--description');
+    const mode = argValue('--mode');
+    const maxIterationsRaw = argValue('--max-iterations');
+    if (!taskId) throw new Error('--task-id is required');
+    if (!/^[A-Za-z0-9_-]+$/.test(taskId)) {
+        throw new Error('Invalid task id format; use alphanumeric, dash, underscore only');
+    }
+    if (!description) throw new Error('--description is required');
+    if (!mode) throw new Error('--mode is required');
+    if (!maxIterationsRaw) throw new Error('--max-iterations is required');
+    const maxIterations = Number(maxIterationsRaw);
+    if (!Number.isFinite(maxIterations) || maxIterations <= 0) {
+        throw new Error('--max-iterations must be a positive number');
+    }
+    return {
+        taskId,
+        description,
+        mode,
+        maxIterations,
+        redisHost: process.env.REDIS_HOST || 'localhost',
+        redisPort: Number(process.env.REDIS_PORT || 6379),
+        ttlSeconds: 86400
+    };
+};
+const storeContext = async (args)=>{
+    const redis = new Redis({
+        host: args.redisHost,
+        port: args.redisPort,
+        lazyConnect: true
+    });
+    try {
+        await redis.connect();
+        const key = `swarm:${args.taskId}:context`;
+        await redis.hset(key, {
+            'task_description': args.description,
+            'mode': args.mode,
+            'max_iterations': String(args.maxIterations)
+        });
+        await redis.expire(key, args.ttlSeconds);
+        console.log(`✅ Task context stored in Redis: ${key}`);
+        console.log(`   TTL: ${args.ttlSeconds} seconds`);
+    } finally{
+        redis.disconnect();
+    }
+};
+const main = async ()=>{
+    const args = parseArgs();
+    await storeContext(args);
+};
+main().catch((error)=>{
+    console.error(`❌ Failed to store task context: ${error.message}`);
+    process.exitCode = 1;
+});
+
+//# sourceMappingURL=store-task-context.js.map

package/dist/coordination/store-task-context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/coordination/store-task-context.ts"],"sourcesContent":["import Redis from 'ioredis';\n\ninterface TaskContextArgs {\n  taskId: string;\n  description: string;\n  mode: string;\n  maxIterations: number;\n  redisHost: string;\n  redisPort: number;\n  ttlSeconds: number;\n}\n\nconst argValue = (flag: string): string | undefined => {\n  const index = process.argv.indexOf(flag);\n  if (index === -1 || index + 1 >= process.argv.length) {\n    return undefined;\n  }\n  return process.argv[index + 1];\n};\n\nconst parseArgs = (): TaskContextArgs => {\n  const taskId = argValue('--task-id');\n  const description = argValue('--description');\n  const mode = argValue('--mode');\n  const maxIterationsRaw = argValue('--max-iterations');\n\n  if (!taskId) throw new Error('--task-id is required');\n  if (!/^[A-Za-z0-9_-]+$/.test(taskId)) {\n    throw new Error('Invalid task id format; use alphanumeric, dash, underscore only');\n  }\n\n  if (!description) throw new Error('--description is required');\n  if (!mode) throw new Error('--mode is required');\n  if (!maxIterationsRaw) throw new Error('--max-iterations is required');\n\n  const maxIterations = Number(maxIterationsRaw);\n  if (!Number.isFinite(maxIterations) || maxIterations <= 0) {\n    throw new Error('--max-iterations must be a positive number');\n  }\n\n  return {\n    taskId,\n    description,\n    mode,\n    maxIterations,\n    redisHost: process.env.REDIS_HOST || 'localhost',\n    redisPort: Number(process.env.REDIS_PORT || 6379),\n    ttlSeconds: 86400,\n  };\n};\n\nconst storeContext = async (args: TaskContextArgs) => {\n  const redis = new Redis({\n    host: args.redisHost,\n    port: args.redisPort,\n    lazyConnect: true,\n  });\n\n  try {\n    await redis.connect();\n    const key = `swarm:${args.taskId}:context`;\n\n    await redis.hset(key, {\n      'task_description': args.description,\n      'mode': args.mode,\n      'max_iterations': String(args.maxIterations),\n    });\n\n    await redis.expire(key, args.ttlSeconds);\n\n    console.log(`✅ Task context stored in Redis: ${key}`);\n    console.log(`   TTL: ${args.ttlSeconds} seconds`);\n  } finally {\n    redis.disconnect();\n  }\n};\n\nconst main = async () => {\n  const args = parseArgs();\n  await storeContext(args);\n};\n\nmain().catch((error) => {\n  console.error(`❌ Failed to store task context: ${error.message}`);\n  process.exitCode = 1;\n});\n"],"names":["Redis","argValue","flag","index","process","argv","indexOf","length","undefined","parseArgs","taskId","description","mode","maxIterationsRaw","Error","test","maxIterations","Number","isFinite","redisHost","env","REDIS_HOST","redisPort","REDIS_PORT","ttlSeconds","storeContext","args","redis","host","port","lazyConnect","connect","key","hset","String","expire","console","log","disconnect","main","catch","error","message","exitCode"],"mappings":"AAAA,OAAOA,WAAW,UAAU;AAY5B,MAAMC,WAAW,CAACC;IAChB,MAAMC,QAAQC,QAAQC,IAAI,CAACC,OAAO,CAACJ;IACnC,IAAIC,UAAU,CAAC,KAAKA,QAAQ,KAAKC,QAAQC,IAAI,CAACE,MAAM,EAAE;QACpD,OAAOC;IACT;IACA,OAAOJ,QAAQC,IAAI,CAACF,QAAQ,EAAE;AAChC;AAEA,MAAMM,YAAY;IAChB,MAAMC,SAAST,SAAS;IACxB,MAAMU,cAAcV,SAAS;IAC7B,MAAMW,OAAOX,SAAS;IACtB,MAAMY,mBAAmBZ,SAAS;IAElC,IAAI,CAACS,QAAQ,MAAM,IAAII,MAAM;IAC7B,IAAI,CAAC,mBAAmBC,IAAI,CAACL,SAAS;QACpC,MAAM,IAAII,MAAM;IAClB;IAEA,IAAI,CAACH,aAAa,MAAM,IAAIG,MAAM;IAClC,IAAI,CAACF,MAAM,MAAM,IAAIE,MAAM;IAC3B,IAAI,CAACD,kBAAkB,MAAM,IAAIC,MAAM;IAEvC,MAAME,gBAAgBC,OAAOJ;IAC7B,IAAI,CAACI,OAAOC,QAAQ,CAACF,kBAAkBA,iBAAiB,GAAG;QACzD,MAAM,IAAIF,MAAM;IAClB;IAEA,OAAO;QACLJ;QACAC;QACAC;QACAI;QACAG,WAAWf,QAAQgB,GAAG,CAACC,UAAU,IAAI;QACrCC,WAAWL,OAAOb,QAAQgB,GAAG,CAACG,UAAU,IAAI;QAC5CC,YAAY;IACd;AACF;AAEA,MAAMC,eAAe,OAAOC;IAC1B,MAAMC,QAAQ,IAAI3B,MAAM;QACtB4B,MAAMF,KAAKP,SAAS;QACpBU,MAAMH,KAAKJ,SAAS;QACpBQ,aAAa;IACf;IAEA,IAAI;QACF,MAAMH,MAAMI,OAAO;QACnB,MAAMC,MAAM,CAAC,MAAM,EAAEN,KAAKhB,MAAM,CAAC,QAAQ,CAAC;QAE1C,MAAMiB,MAAMM,IAAI,CAACD,KAAK;YACpB,oBAAoBN,KAAKf,WAAW;YACpC,QAAQe,KAAKd,IAAI;YACjB,kBAAkBsB,OAAOR,KAAKV,aAAa;QAC7C;QAEA,MAAMW,MAAMQ,MAAM,CAACH,KAAKN,KAAKF,UAAU;QAEvCY,QAAQC,GAAG,CAAC,CAAC,gCAAgC,EAAEL,KAAK;QACpDI,QAAQC,GAAG,CAAC,CAAC,QAAQ,EAAEX,KAAKF,UAAU,CAAC,QAAQ,CAAC;IAClD,SAAU;QACRG,MAAMW,UAAU;IAClB;AACF;AAEA,MAAMC,OAAO;IACX,MAAMb,OAAOjB;IACb,MAAMgB,aAAaC;AACrB;AAEAa,OAAOC,KAAK,CAAC,CAACC;IACZL,QAAQK,KAAK,CAAC,CAAC,gCAAgC,EAAEA,MAAMC,OAAO,EAAE;IAChEtC,QAAQuC,QAAQ,GAAG;AACrB"}

package/dist/hooks/backup-manager.js

@@ -0,0 +1,273 @@
+/**
+ * Backup Manager - File lifecycle backup creation and restoration
+ * Manages pre-edit backups with metadata, hash generation, and cleanup
+ */ import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as crypto from 'crypto';
+export class BackupManager {
+    config;
+    projectRoot;
+    constructor(projectRoot = process.cwd(), config){
+        this.projectRoot = projectRoot;
+        this.config = {
+            retentionHours: config?.retentionHours ?? 24,
+            maxBackups: config?.maxBackups ?? 10,
+            backupDir: config?.backupDir ?? '.backups'
+        };
+    }
+    /**
+   * Generate SHA256 hash of file content (8 char truncated)
+   */ async generateFileHash(filePath) {
+        try {
+            const content = await fs.readFile(filePath);
+            const hash = crypto.createHash('sha256').update(content).digest('hex');
+            return hash.substring(0, 8);
+        } catch (error) {
+            throw new Error(`Failed to generate hash for ${filePath}: ${error}`);
+        }
+    }
+    /**
+   * Count lines in a file
+   */ async countLines(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return content.split('\n').length - 1; // Subtract 1 for trailing newline
+        } catch  {
+            return 0;
+        }
+    }
+    /**
+   * Get file size in bytes
+   */ async getFileSize(filePath) {
+        try {
+            const stat = await fs.stat(filePath);
+            return stat.size;
+        } catch  {
+            return 0;
+        }
+    }
+    /**
+   * Create a backup of a file before editing
+   */ async createBackup(filePath, agentId) {
+        // Validate inputs
+        if (!filePath) {
+            throw new Error('File path is required');
+        }
+        if (!agentId) {
+            throw new Error('Agent ID is required');
+        }
+        // Check if file exists
+        try {
+            await fs.stat(filePath);
+        } catch  {
+            throw new Error(`File does not exist: ${filePath}`);
+        }
+        try {
+            // Generate timestamp and hash
+            const timestamp = new Date().toISOString();
+            const fileHash = await this.generateFileHash(filePath);
+            const unixTimestamp = Date.now();
+            // Create backup directory structure: .backups/agent-id/timestamp_hash/
+            const backupBaseDir = path.join(this.projectRoot, this.config.backupDir, agentId);
+            const backupName = `${unixTimestamp}_${fileHash}`;
+            const fullBackupPath = path.join(backupBaseDir, backupName);
+            // Create backup directory
+            await fs.mkdir(fullBackupPath, {
+                recursive: true
+            });
+            // Copy original file to backup location
+            const originalFileName = path.basename(filePath);
+            const backupFilePath = path.join(fullBackupPath, originalFileName);
+            await fs.copyFile(filePath, backupFilePath);
+            // Gather metadata
+            const fileSize = await this.getFileSize(filePath);
+            const lineCount = await this.countLines(filePath);
+            // Create metadata file
+            const metadata = {
+                timestamp,
+                agentId,
+                originalFile: filePath,
+                fileHash,
+                backupPath: fullBackupPath,
+                createdAt: new Date().toISOString(),
+                fileSize,
+                lineCount
+            };
+            const metadataPath = path.join(fullBackupPath, 'metadata.json');
+            await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
+            // Create revert script
+            const revertScriptPath = path.join(fullBackupPath, 'revert.sh');
+            const revertScript = `#!/bin/bash
+# Auto-generated revert script for ${filePath}
+set -euo pipefail
+
+echo "Reverting: ${filePath}"
+cp "${backupFilePath}" "${filePath}"
+echo "✅ File reverted successfully"
+`;
+            await fs.writeFile(revertScriptPath, revertScript, {
+                mode: 0o755
+            });
+            // Clean up old backups
+            await this.cleanOldBackups(agentId);
+            return {
+                backupPath: fullBackupPath,
+                timestamp: new Date().toISOString(),
+                fileHash,
+                originalPath: filePath,
+                metadata
+            };
+        } catch (error) {
+            throw new Error(`Backup creation failed for ${filePath}: ${error}`);
+        }
+    }
+    /**
+   * Revert a file from its backup
+   */ async revertFile(filePath, agentId) {
+        try {
+            // Find the most recent backup for this file
+            const backups = await this.listBackups(filePath);
+            if (backups.length === 0) {
+                throw new Error(`No backups found for ${filePath}`);
+            }
+            // Get the most recent backup
+            const mostRecentBackup = backups[0];
+            const backupedFile = path.join(mostRecentBackup.metadata.backupPath, path.basename(filePath));
+            // Verify backup file exists
+            await fs.stat(backupedFile);
+            // Restore file
+            await fs.copyFile(backupedFile, filePath);
+        } catch (error) {
+            throw new Error(`Failed to revert ${filePath}: ${error}`);
+        }
+    }
+    /**
+   * List all backups for a given file
+   */ async listBackups(filePath) {
+        try {
+            const backupBaseDir = path.join(this.projectRoot, this.config.backupDir);
+            const fileName = path.basename(filePath);
+            // Recursively search for backups
+            const backups = [];
+            const searchDir = async (dir)=>{
+                try {
+                    const entries = await fs.readdir(dir, {
+                        withFileTypes: true
+                    });
+                    for (const entry of entries){
+                        const fullPath = path.join(dir, entry.name);
+                        if (entry.isDirectory()) {
+                            // Try to read metadata.json
+                            const metadataPath = path.join(fullPath, 'metadata.json');
+                            try {
+                                const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+                                const metadata = JSON.parse(metadataContent);
+                                // Check if this backup is for our file
+                                if (metadata.originalFile === filePath) {
+                                    backups.push({
+                                        backupPath: fullPath,
+                                        timestamp: metadata.timestamp,
+                                        fileHash: metadata.fileHash,
+                                        originalPath: metadata.originalFile,
+                                        metadata
+                                    });
+                                }
+                            } catch  {
+                                // Not a backup directory, recurse
+                                await searchDir(fullPath);
+                            }
+                        }
+                    }
+                } catch (error) {
+                    // Directory doesn't exist or other read error
+                    return;
+                }
+            };
+            await searchDir(backupBaseDir);
+            // Sort by timestamp descending (most recent first)
+            return backups.sort((a, b)=>new Date(b.metadata.createdAt).getTime() - new Date(a.metadata.createdAt).getTime());
+        } catch  {
+            return [];
+        }
+    }
+    /**
+   * Clean up old backups for an agent
+   */ async cleanOldBackups(agentId) {
+        try {
+            const backupDir = path.join(this.projectRoot, this.config.backupDir, agentId);
+            const retentionMs = this.config.retentionHours * 60 * 60 * 1000;
+            const cutoffTime = Date.now() - retentionMs;
+            let deletedCount = 0;
+            // Read agent backup directory
+            let entries = [];
+            try {
+                entries = await fs.readdir(backupDir);
+            } catch  {
+                // Directory doesn't exist
+                return 0;
+            }
+            // Get backup metadata and timestamps
+            const backupTimestamps = [];
+            for (const entry of entries){
+                const fullPath = path.join(backupDir, entry);
+                const metadataPath = path.join(fullPath, 'metadata.json');
+                try {
+                    const metadataContent = await fs.readFile(metadataPath, 'utf-8');
+                    const metadata = JSON.parse(metadataContent);
+                    const timestamp = new Date(metadata.createdAt).getTime();
+                    backupTimestamps.push({
+                        name: entry,
+                        timestamp
+                    });
+                } catch  {
+                // Skip invalid backup directories
+                }
+            }
+            // Sort by timestamp descending
+            backupTimestamps.sort((a, b)=>b.timestamp - a.timestamp);
+            // Remove old backups (either too old or exceed max count)
+            for(let i = 0; i < backupTimestamps.length; i++){
+                const { name, timestamp } = backupTimestamps[i];
+                // Remove if older than retention or if exceeds max count
+                if (timestamp < cutoffTime || i >= this.config.maxBackups) {
+                    const fullPath = path.join(backupDir, name);
+                    try {
+                        await fs.rm(fullPath, {
+                            recursive: true,
+                            force: true
+                        });
+                        deletedCount++;
+                    } catch  {
+                    // Continue with next backup
+                    }
+                }
+            }
+            return deletedCount;
+        } catch  {
+            return 0;
+        }
+    }
+    /**
+   * Verify backup integrity
+   */ async verifyBackup(backupPath) {
+        try {
+            const metadataPath = path.join(backupPath, 'metadata.json');
+            const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+            // Check backup file exists
+            const fileName = path.basename(metadata.originalFile);
+            const backupFilePath = path.join(backupPath, fileName);
+            const stat = await fs.stat(backupFilePath);
+            // Verify size matches metadata
+            if (stat.size !== metadata.fileSize) {
+                return false;
+            }
+            // Verify hash matches
+            const actualHash = await this.generateFileHash(backupFilePath);
+            return actualHash === metadata.fileHash;
+        } catch  {
+            return false;
+        }
+    }
+}
+
+//# sourceMappingURL=backup-manager.js.map

package/dist/hooks/backup-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/hooks/backup-manager.ts"],"sourcesContent":["/**\r\n * Backup Manager - File lifecycle backup creation and restoration\r\n * Manages pre-edit backups with metadata, hash generation, and cleanup\r\n */\r\n\r\nimport * as fs from 'fs/promises';\r\nimport * as path from 'path';\r\nimport * as crypto from 'crypto';\r\nimport { fileURLToPath } from 'url';\r\n\r\ninterface BackupConfig {\r\n  retentionHours: number;\r\n  maxBackups: number;\r\n  backupDir: string;\r\n}\r\n\r\ninterface BackupMetadata {\r\n  timestamp: string;\r\n  agentId: string;\r\n  originalFile: string;\r\n  fileHash: string;\r\n  backupPath: string;\r\n  createdAt: string;\r\n  fileSize: number;\r\n  lineCount: number;\r\n}\r\n\r\ninterface BackupResult {\r\n  backupPath: string;\r\n  timestamp: string;\r\n  fileHash: string;\r\n  originalPath: string;\r\n  metadata: BackupMetadata;\r\n}\r\n\r\nexport class BackupManager {\r\n  private config: BackupConfig;\r\n  private projectRoot: string;\r\n\r\n  constructor(projectRoot: string = process.cwd(), config?: Partial<BackupConfig>) {\r\n    this.projectRoot = projectRoot;\r\n    this.config = {\r\n      retentionHours: config?.retentionHours ?? 24,\r\n      maxBackups: config?.maxBackups ?? 10,\r\n      backupDir: config?.backupDir ?? '.backups',\r\n    };\r\n  }\r\n\r\n  /**\r\n   * Generate SHA256 hash of file content (8 char truncated)\r\n   */\r\n  private async generateFileHash(filePath: string): Promise<string> {\r\n    try {\r\n      const content = await fs.readFile(filePath);\r\n      const hash = crypto.createHash('sha256').update(content).digest('hex');\r\n      return hash.substring(0, 8);\r\n    } catch (error) {\r\n      throw new Error(`Failed to generate hash for ${filePath}: ${error}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Count lines in a file\r\n   */\r\n  private async countLines(filePath: string): Promise<number> {\r\n    try {\r\n      const content = await fs.readFile(filePath, 'utf-8');\r\n      return content.split('\\n').length - 1; // Subtract 1 for trailing newline\r\n    } catch {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Get file size in bytes\r\n   */\r\n  private async getFileSize(filePath: string): Promise<number> {\r\n    try {\r\n      const stat = await fs.stat(filePath);\r\n      return stat.size;\r\n    } catch {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Create a backup of a file before editing\r\n   */\r\n  async createBackup(filePath: string, agentId: string): Promise<BackupResult> {\r\n    // Validate inputs\r\n    if (!filePath) {\r\n      throw new Error('File path is required');\r\n    }\r\n\r\n    if (!agentId) {\r\n      throw new Error('Agent ID is required');\r\n    }\r\n\r\n    // Check if file exists\r\n    try {\r\n      await fs.stat(filePath);\r\n    } catch {\r\n      throw new Error(`File does not exist: ${filePath}`);\r\n    }\r\n\r\n    try {\r\n      // Generate timestamp and hash\r\n      const timestamp = new Date().toISOString();\r\n      const fileHash = await this.generateFileHash(filePath);\r\n      const unixTimestamp = Date.now();\r\n\r\n      // Create backup directory structure: .backups/agent-id/timestamp_hash/\r\n      const backupBaseDir = path.join(this.projectRoot, this.config.backupDir, agentId);\r\n      const backupName = `${unixTimestamp}_${fileHash}`;\r\n      const fullBackupPath = path.join(backupBaseDir, backupName);\r\n\r\n      // Create backup directory\r\n      await fs.mkdir(fullBackupPath, { recursive: true });\r\n\r\n      // Copy original file to backup location\r\n      const originalFileName = path.basename(filePath);\r\n      const backupFilePath = path.join(fullBackupPath, originalFileName);\r\n      await fs.copyFile(filePath, backupFilePath);\r\n\r\n      // Gather metadata\r\n      const fileSize = await this.getFileSize(filePath);\r\n      const lineCount = await this.countLines(filePath);\r\n\r\n      // Create metadata file\r\n      const metadata: BackupMetadata = {\r\n        timestamp,\r\n        agentId,\r\n        originalFile: filePath,\r\n        fileHash,\r\n        backupPath: fullBackupPath,\r\n        createdAt: new Date().toISOString(),\r\n        fileSize,\r\n        lineCount,\r\n      };\r\n\r\n      const metadataPath = path.join(fullBackupPath, 'metadata.json');\r\n      await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));\r\n\r\n      // Create revert script\r\n      const revertScriptPath = path.join(fullBackupPath, 'revert.sh');\r\n      const revertScript = `#!/bin/bash\r\n# Auto-generated revert script for ${filePath}\r\nset -euo pipefail\r\n\r\necho \"Reverting: ${filePath}\"\r\ncp \"${backupFilePath}\" \"${filePath}\"\r\necho \"✅ File reverted successfully\"\r\n`;\r\n      await fs.writeFile(revertScriptPath, revertScript, { mode: 0o755 });\r\n\r\n      // Clean up old backups\r\n      await this.cleanOldBackups(agentId);\r\n\r\n      return {\r\n        backupPath: fullBackupPath,\r\n        timestamp: new Date().toISOString(),\r\n        fileHash,\r\n        originalPath: filePath,\r\n        metadata,\r\n      };\r\n    } catch (error) {\r\n      throw new Error(`Backup creation failed for ${filePath}: ${error}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Revert a file from its backup\r\n   */\r\n  async revertFile(filePath: string, agentId: string): Promise<void> {\r\n    try {\r\n      // Find the most recent backup for this file\r\n      const backups = await this.listBackups(filePath);\r\n      if (backups.length === 0) {\r\n        throw new Error(`No backups found for ${filePath}`);\r\n      }\r\n\r\n      // Get the most recent backup\r\n      const mostRecentBackup = backups[0];\r\n      const backupedFile = path.join(\r\n        mostRecentBackup.metadata.backupPath,\r\n        path.basename(filePath)\r\n      );\r\n\r\n      // Verify backup file exists\r\n      await fs.stat(backupedFile);\r\n\r\n      // Restore file\r\n      await fs.copyFile(backupedFile, filePath);\r\n    } catch (error) {\r\n      throw new Error(`Failed to revert ${filePath}: ${error}`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * List all backups for a given file\r\n   */\r\n  async listBackups(filePath: string): Promise<BackupResult[]> {\r\n    try {\r\n      const backupBaseDir = path.join(this.projectRoot, this.config.backupDir);\r\n      const fileName = path.basename(filePath);\r\n\r\n      // Recursively search for backups\r\n      const backups: BackupResult[] = [];\r\n      const searchDir = async (dir: string) => {\r\n        try {\r\n          const entries = await fs.readdir(dir, { withFileTypes: true });\r\n\r\n          for (const entry of entries) {\r\n            const fullPath = path.join(dir, entry.name);\r\n\r\n            if (entry.isDirectory()) {\r\n              // Try to read metadata.json\r\n              const metadataPath = path.join(fullPath, 'metadata.json');\r\n              try {\r\n                const metadataContent = await fs.readFile(metadataPath, 'utf-8');\r\n                const metadata: BackupMetadata = JSON.parse(metadataContent);\r\n\r\n                // Check if this backup is for our file\r\n                if (metadata.originalFile === filePath) {\r\n                  backups.push({\r\n                    backupPath: fullPath,\r\n                    timestamp: metadata.timestamp,\r\n                    fileHash: metadata.fileHash,\r\n                    originalPath: metadata.originalFile,\r\n                    metadata,\r\n                  });\r\n                }\r\n              } catch {\r\n                // Not a backup directory, recurse\r\n                await searchDir(fullPath);\r\n              }\r\n            }\r\n          }\r\n        } catch (error) {\r\n          // Directory doesn't exist or other read error\r\n          return;\r\n        }\r\n      };\r\n\r\n      await searchDir(backupBaseDir);\r\n\r\n      // Sort by timestamp descending (most recent first)\r\n      return backups.sort(\r\n        (a, b) =>\r\n          new Date(b.metadata.createdAt).getTime() -\r\n          new Date(a.metadata.createdAt).getTime()\r\n      );\r\n    } catch {\r\n      return [];\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Clean up old backups for an agent\r\n   */\r\n  async cleanOldBackups(agentId: string): Promise<number> {\r\n    try {\r\n      const backupDir = path.join(this.projectRoot, this.config.backupDir, agentId);\r\n      const retentionMs = this.config.retentionHours * 60 * 60 * 1000;\r\n      const cutoffTime = Date.now() - retentionMs;\r\n      let deletedCount = 0;\r\n\r\n      // Read agent backup directory\r\n      let entries: string[] = [];\r\n      try {\r\n        entries = await fs.readdir(backupDir);\r\n      } catch {\r\n        // Directory doesn't exist\r\n        return 0;\r\n      }\r\n\r\n      // Get backup metadata and timestamps\r\n      const backupTimestamps: Array<{ name: string; timestamp: number }> = [];\r\n\r\n      for (const entry of entries) {\r\n        const fullPath = path.join(backupDir, entry);\r\n        const metadataPath = path.join(fullPath, 'metadata.json');\r\n\r\n        try {\r\n          const metadataContent = await fs.readFile(metadataPath, 'utf-8');\r\n          const metadata: BackupMetadata = JSON.parse(metadataContent);\r\n          const timestamp = new Date(metadata.createdAt).getTime();\r\n\r\n          backupTimestamps.push({ name: entry, timestamp });\r\n        } catch {\r\n          // Skip invalid backup directories\r\n        }\r\n      }\r\n\r\n      // Sort by timestamp descending\r\n      backupTimestamps.sort((a, b) => b.timestamp - a.timestamp);\r\n\r\n      // Remove old backups (either too old or exceed max count)\r\n      for (let i = 0; i < backupTimestamps.length; i++) {\r\n        const { name, timestamp } = backupTimestamps[i];\r\n\r\n        // Remove if older than retention or if exceeds max count\r\n        if (timestamp < cutoffTime || i >= this.config.maxBackups) {\r\n          const fullPath = path.join(backupDir, name);\r\n          try {\r\n            await fs.rm(fullPath, { recursive: true, force: true });\r\n            deletedCount++;\r\n          } catch {\r\n            // Continue with next backup\r\n          }\r\n        }\r\n      }\r\n\r\n      return deletedCount;\r\n    } catch {\r\n      return 0;\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Verify backup integrity\r\n   */\r\n  async verifyBackup(backupPath: string): Promise<boolean> {\r\n    try {\r\n      const metadataPath = path.join(backupPath, 'metadata.json');\r\n      const metadata: BackupMetadata = JSON.parse(\r\n        await fs.readFile(metadataPath, 'utf-8')\r\n      );\r\n\r\n      // Check backup file exists\r\n      const fileName = path.basename(metadata.originalFile);\r\n      const backupFilePath = path.join(backupPath, fileName);\r\n      const stat = await fs.stat(backupFilePath);\r\n\r\n      // Verify size matches metadata\r\n      if (stat.size !== metadata.fileSize) {\r\n        return false;\r\n      }\r\n\r\n      // Verify hash matches\r\n      const actualHash = await this.generateFileHash(backupFilePath);\r\n      return actualHash === metadata.fileHash;\r\n    } catch {\r\n      return false;\r\n    }\r\n  }\r\n}\r\n"],"names":["fs","path","crypto","BackupManager","config","projectRoot","process","cwd","retentionHours","maxBackups","backupDir","generateFileHash","filePath","content","readFile","hash","createHash","update","digest","substring","error","Error","countLines","split","length","getFileSize","stat","size","createBackup","agentId","timestamp","Date","toISOString","fileHash","unixTimestamp","now","backupBaseDir","join","backupName","fullBackupPath","mkdir","recursive","originalFileName","basename","backupFilePath","copyFile","fileSize","lineCount","metadata","originalFile","backupPath","createdAt","metadataPath","writeFile","JSON","stringify","revertScriptPath","revertScript","mode","cleanOldBackups","originalPath","revertFile","backups","listBackups","mostRecentBackup","backupedFile","fileName","searchDir","dir","entries","readdir","withFileTypes","entry","fullPath","name","isDirectory","metadataContent","parse","push","sort","a","b","getTime","retentionMs","cutoffTime","deletedCount","backupTimestamps","i","rm","force","verifyBackup","actualHash"],"mappings":"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"}