claude-flow-novice 1.0.0

package/dist/src/feature-flags/validation/HookInterceptor.js

@@ -0,0 +1,310 @@
+/**
+ * Phase 4 Hook Interception with Auto-Relaunch
+ * Intercepts hook executions and provides auto-relaunch capability
+ */ import { EventEmitter } from 'events';
+import { spawn } from 'child_process';
+export class HookInterceptor extends EventEmitter {
+    flagManager;
+    validator;
+    interceptedHooks = new Map();
+    runningProcesses = new Map();
+    constructor(flagManager, validator){
+        super();
+        this.flagManager = flagManager;
+        this.validator = validator;
+    }
+    /**
+   * Intercept and execute hook with validation and auto-relaunch
+   */ async interceptHook(execution) {
+        const isEnabled = await this.flagManager.isEnabled('hook-interception', execution.userId);
+        if (!isEnabled) {
+            return this.executeDirectly(execution);
+        }
+        const executionId = `${execution.hookType}-${Date.now()}`;
+        this.recordExecution(executionId, execution);
+        try {
+            let result = await this.executeWithValidation(execution, executionId);
+            // Auto-relaunch logic
+            if (!result.success && this.shouldAutoRelaunch(execution)) {
+                result = await this.attemptAutoRelaunch(execution, executionId, result);
+            }
+            this.emit('hook_intercepted', {
+                executionId,
+                execution,
+                result
+            });
+            return result;
+        } catch (error) {
+            this.emit('hook_error', {
+                executionId,
+                execution,
+                error: error.message
+            });
+            return {
+                success: false,
+                output: '',
+                error: error.message,
+                exitCode: 1,
+                duration: 0,
+                relaunchAttempts: 0
+            };
+        }
+    }
+    async executeWithValidation(execution, executionId) {
+        const startTime = Date.now();
+        try {
+            const process1 = spawn(execution.command, execution.args, {
+                stdio: [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ],
+                shell: true
+            });
+            this.runningProcesses.set(executionId, process1);
+            const result = await new Promise((resolve)=>{
+                let stdout = '';
+                let stderr = '';
+                process1.stdout?.on('data', (data)=>{
+                    stdout += data.toString();
+                });
+                process1.stderr?.on('data', (data)=>{
+                    stderr += data.toString();
+                });
+                process1.on('close', async (code)=>{
+                    const duration = Date.now() - startTime;
+                    const success = code === 0;
+                    // Validate the execution if it's a completion-related hook
+                    let validationResult;
+                    if (this.isCompletionHook(execution)) {
+                        const task = this.createTaskFromExecution(execution, stdout, stderr);
+                        validationResult = await this.validator.validateCompletion(task);
+                    }
+                    resolve({
+                        success: success && validationResult?.isValid !== false,
+                        output: stdout,
+                        error: stderr,
+                        exitCode: code || 0,
+                        duration,
+                        validationResult,
+                        relaunchAttempts: 0
+                    });
+                });
+                process1.on('error', (error)=>{
+                    resolve({
+                        success: false,
+                        output: stdout,
+                        error: error.message,
+                        exitCode: 1,
+                        duration: Date.now() - startTime,
+                        relaunchAttempts: 0
+                    });
+                });
+            });
+            this.runningProcesses.delete(executionId);
+            return result;
+        } catch (error) {
+            this.runningProcesses.delete(executionId);
+            throw error;
+        }
+    }
+    async attemptAutoRelaunch(execution, executionId, previousResult) {
+        const maxRelaunchAttempts = parseInt(process.env.MAX_RELAUNCH_ATTEMPTS || '3', 10);
+        let attempts = 0;
+        let lastResult = previousResult;
+        while(attempts < maxRelaunchAttempts && !lastResult.success){
+            attempts++;
+            this.emit('auto_relaunch_attempt', {
+                executionId,
+                attempt: attempts,
+                maxAttempts: maxRelaunchAttempts
+            });
+            // Modify execution slightly for relaunch
+            const modifiedExecution = this.modifyForRelaunch(execution, attempts);
+            const newExecutionId = `${executionId}-relaunch-${attempts}`;
+            lastResult = await this.executeWithValidation(modifiedExecution, newExecutionId);
+            lastResult.relaunchAttempts = attempts;
+            if (lastResult.success) {
+                this.emit('auto_relaunch_success', {
+                    executionId,
+                    attempts,
+                    result: lastResult
+                });
+                break;
+            }
+            // Wait before next attempt
+            await this.sleep(1000 * attempts); // Exponential backoff
+        }
+        if (!lastResult.success) {
+            this.emit('auto_relaunch_failed', {
+                executionId,
+                attempts,
+                finalResult: lastResult
+            });
+        }
+        return lastResult;
+    }
+    shouldAutoRelaunch(execution) {
+        const autoRelaunchEnabled = process.env.AUTO_RELAUNCH_ENABLED !== 'false';
+        // Don't auto-relaunch certain hook types
+        const nonRelaunchableHooks = [
+            'session-end',
+            'notify'
+        ];
+        if (nonRelaunchableHooks.includes(execution.hookType)) {
+            return false;
+        }
+        return autoRelaunchEnabled;
+    }
+    modifyForRelaunch(execution, attempt) {
+        // Add retry indicators to the execution
+        const modifiedArgs = [
+            ...execution.args
+        ];
+        // Add retry context if not already present
+        if (!modifiedArgs.includes('--retry')) {
+            modifiedArgs.push('--retry', attempt.toString());
+        }
+        // Add exponential backoff delay for certain commands
+        if (execution.command.includes('claude-flow')) {
+            modifiedArgs.push('--retry-delay', (1000 * attempt).toString());
+        }
+        return {
+            ...execution,
+            args: modifiedArgs,
+            timestamp: new Date().toISOString()
+        };
+    }
+    async executeDirectly(execution) {
+        const startTime = Date.now();
+        try {
+            const process1 = spawn(execution.command, execution.args, {
+                stdio: [
+                    'pipe',
+                    'pipe',
+                    'pipe'
+                ],
+                shell: true
+            });
+            const result = await new Promise((resolve)=>{
+                let stdout = '';
+                let stderr = '';
+                process1.stdout?.on('data', (data)=>{
+                    stdout += data.toString();
+                });
+                process1.stderr?.on('data', (data)=>{
+                    stderr += data.toString();
+                });
+                process1.on('close', (code)=>{
+                    resolve({
+                        success: code === 0,
+                        output: stdout,
+                        error: stderr,
+                        exitCode: code || 0,
+                        duration: Date.now() - startTime,
+                        relaunchAttempts: 0
+                    });
+                });
+                process1.on('error', (error)=>{
+                    resolve({
+                        success: false,
+                        output: stdout,
+                        error: error.message,
+                        exitCode: 1,
+                        duration: Date.now() - startTime,
+                        relaunchAttempts: 0
+                    });
+                });
+            });
+            return result;
+        } catch (error) {
+            return {
+                success: false,
+                output: '',
+                error: error.message,
+                exitCode: 1,
+                duration: Date.now() - startTime,
+                relaunchAttempts: 0
+            };
+        }
+    }
+    isCompletionHook(execution) {
+        return execution.hookType === 'post-task' || execution.hookType === 'post-edit';
+    }
+    createTaskFromExecution(execution, stdout, stderr) {
+        return {
+            id: `hook-${execution.hookType}-${Date.now()}`,
+            description: `Hook execution: ${execution.command} ${execution.args.join(' ')}`,
+            actualOutput: {
+                stdout,
+                stderr,
+                exitCode: stderr ? 1 : 0
+            },
+            context: {
+                hookType: execution.hookType,
+                timestamp: execution.timestamp,
+                sessionId: execution.sessionId,
+                userId: execution.userId
+            },
+            userId: execution.userId
+        };
+    }
+    recordExecution(executionId, execution) {
+        const sessionId = execution.sessionId || 'default';
+        if (!this.interceptedHooks.has(sessionId)) {
+            this.interceptedHooks.set(sessionId, []);
+        }
+        this.interceptedHooks.get(sessionId).push(execution);
+    }
+    sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    /**
+   * Kill running hook process
+   */ async killHook(executionId) {
+        const process1 = this.runningProcesses.get(executionId);
+        if (!process1) {
+            return false;
+        }
+        try {
+            process1.kill('SIGTERM');
+            // Give process time to terminate gracefully
+            await this.sleep(5000);
+            if (!process1.killed) {
+                process1.kill('SIGKILL');
+            }
+            this.runningProcesses.delete(executionId);
+            return true;
+        } catch (error) {
+            this.emit('kill_error', {
+                executionId,
+                error: error.message
+            });
+            return false;
+        }
+    }
+    /**
+   * Get execution history for a session
+   */ getExecutionHistory(sessionId) {
+        return this.interceptedHooks.get(sessionId) || [];
+    }
+    /**
+   * Get current system metrics
+   */ getSystemMetrics() {
+        const allExecutions = Array.from(this.interceptedHooks.values()).flat();
+        const runningProcessCount = this.runningProcesses.size;
+        const hookTypeCounts = allExecutions.reduce((acc, exec)=>{
+            acc[exec.hookType] = (acc[exec.hookType] || 0) + 1;
+            return acc;
+        }, {});
+        return {
+            totalExecutions: allExecutions.length,
+            runningProcesses: runningProcessCount,
+            hookTypeCounts,
+            sessionsCount: this.interceptedHooks.size,
+            lastExecution: allExecutions.length > 0 ? allExecutions[allExecutions.length - 1].timestamp : null
+        };
+    }
+}
+
+//# sourceMappingURL=HookInterceptor.js.map

package/dist/src/feature-flags/validation/HookInterceptor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/feature-flags/validation/HookInterceptor.ts"],"names":["EventEmitter","spawn","HookInterceptor","flagManager","validator","interceptedHooks","Map","runningProcesses","interceptHook","execution","isEnabled","userId","executeDirectly","executionId","hookType","Date","now","recordExecution","result","executeWithValidation","success","shouldAutoRelaunch","attemptAutoRelaunch","emit","error","message","output","exitCode","duration","relaunchAttempts","startTime","process","command","args","stdio","shell","set","Promise","resolve","stdout","stderr","on","data","toString","code","validationResult","isCompletionHook","task","createTaskFromExecution","validateCompletion","isValid","delete","previousResult","maxRelaunchAttempts","parseInt","env","MAX_RELAUNCH_ATTEMPTS","attempts","lastResult","attempt","maxAttempts","modifiedExecution","modifyForRelaunch","newExecutionId","sleep","finalResult","autoRelaunchEnabled","AUTO_RELAUNCH_ENABLED","nonRelaunchableHooks","includes","modifiedArgs","push","timestamp","toISOString","id","description","join","actualOutput","context","sessionId","has","get","ms","setTimeout","killHook","kill","killed","getExecutionHistory","getSystemMetrics","allExecutions","Array","from","values","flat","runningProcessCount","size","hookTypeCounts","reduce","acc","exec","totalExecutions","length","sessionsCount","lastExecution"],"mappings":"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"}

package/dist/src/feature-flags/validation/TruthBasedValidator.js

@@ -0,0 +1,263 @@
+/**
+ * Phase 4 Truth-Based Validation System
+ * Validates completion with cryptographic signatures and consensus
+ */ import { createHash, randomBytes } from 'crypto';
+import { EventEmitter } from 'events';
+export class TruthBasedValidator extends EventEmitter {
+    flagManager;
+    validationHistory = new Map();
+    consensusNodes = new Set();
+    constructor(flagManager){
+        super();
+        this.flagManager = flagManager;
+        this.initializeConsensusNodes();
+    }
+    initializeConsensusNodes() {
+        // Simulated consensus nodes for Phase 4
+        const nodeCount = parseInt(process.env.MAX_CONSENSUS_AGENTS || '5', 10);
+        for(let i = 0; i < nodeCount; i++){
+            this.consensusNodes.add(`node-${i + 1}-${randomBytes(4).toString('hex')}`);
+        }
+    }
+    /**
+   * Validate task completion with truth-based approach
+   */ async validateCompletion(task) {
+        const isEnabled = await this.flagManager.isEnabled('truth-based-validation', task.userId);
+        if (!isEnabled) {
+            // Fallback to basic validation
+            return this.basicValidation(task);
+        }
+        try {
+            const result = await this.performTruthValidation(task);
+            this.recordValidation(task.id, result);
+            this.emit('validation_completed', {
+                taskId: task.id,
+                result,
+                method: 'truth-based'
+            });
+            return result;
+        } catch (error) {
+            this.emit('validation_error', {
+                taskId: task.id,
+                error: error.message
+            });
+            // Fallback to basic validation on error
+            return this.basicValidation(task);
+        }
+    }
+    async performTruthValidation(task) {
+        const validationMethods = await Promise.allSettled([
+            this.cryptographicValidation(task),
+            this.consensusValidation(task),
+            this.semanticValidation(task)
+        ]);
+        const results = validationMethods.filter((result)=>result.status === 'fulfilled').map((result)=>result.value);
+        if (results.length === 0) {
+            throw new Error('All validation methods failed');
+        }
+        // Hybrid approach: combine results
+        const avgTruthScore = results.reduce((sum, r)=>sum + r.truthScore, 0) / results.length;
+        const consensusCount = results.filter((r)=>r.isValid).length;
+        const isValid = consensusCount >= Math.ceil(results.length / 2);
+        return {
+            isValid,
+            truthScore: avgTruthScore,
+            signature: this.generateSignature(task, avgTruthScore),
+            timestamp: new Date().toISOString(),
+            consensusNodes: this.consensusNodes.size,
+            metadata: {
+                validator: 'TruthBasedValidator',
+                method: 'hybrid',
+                confidence: avgTruthScore * (consensusCount / results.length)
+            }
+        };
+    }
+    async cryptographicValidation(task) {
+        const taskHash = createHash('sha256').update(JSON.stringify({
+            id: task.id,
+            description: task.description,
+            expectedOutput: task.expectedOutput,
+            actualOutput: task.actualOutput
+        })).digest('hex');
+        const signature = this.generateSignature(task, 1.0);
+        // Simulated cryptographic validation logic
+        const isValid = this.validateSignature(taskHash, signature);
+        const truthScore = isValid ? 0.95 : 0.1;
+        return {
+            isValid,
+            truthScore,
+            signature,
+            timestamp: new Date().toISOString(),
+            consensusNodes: 1,
+            metadata: {
+                validator: 'CryptographicValidator',
+                method: 'cryptographic',
+                confidence: truthScore
+            }
+        };
+    }
+    async consensusValidation(task) {
+        const validationPromises = Array.from(this.consensusNodes).map((nodeId)=>this.nodeValidation(task, nodeId));
+        const nodeResults = await Promise.allSettled(validationPromises);
+        const successfulValidations = nodeResults.filter((result)=>result.status === 'fulfilled').map((result)=>result.value);
+        const consensusCount = successfulValidations.filter(Boolean).length;
+        const totalNodes = successfulValidations.length;
+        const consensusRatio = consensusCount / totalNodes;
+        const isValid = consensusRatio >= 0.6; // 60% consensus required
+        const truthScore = consensusRatio * 0.9; // Max 90% for consensus
+        return {
+            isValid,
+            truthScore,
+            signature: this.generateSignature(task, truthScore),
+            timestamp: new Date().toISOString(),
+            consensusNodes: totalNodes,
+            metadata: {
+                validator: 'ConsensusValidator',
+                method: 'consensus',
+                confidence: consensusRatio
+            }
+        };
+    }
+    async nodeValidation(task, nodeId) {
+        // Simulated Byzantine fault-tolerant node validation
+        const nodeReliability = 0.85; // 85% node reliability
+        const randomFactor = Math.random();
+        if (randomFactor > nodeReliability) {
+            throw new Error(`Node ${nodeId} failed validation`);
+        }
+        // Simulate validation logic
+        const hasExpectedOutput = task.expectedOutput !== undefined;
+        const outputMatches = hasExpectedOutput && JSON.stringify(task.actualOutput) === JSON.stringify(task.expectedOutput);
+        const descriptionValid = task.description && task.description.length > 0;
+        const contextValid = task.context !== null && task.context !== undefined;
+        return outputMatches || descriptionValid && contextValid;
+    }
+    async semanticValidation(task) {
+        // Simulated semantic analysis
+        const descriptionQuality = this.analyzeDescription(task.description);
+        const outputConsistency = this.analyzeOutputConsistency(task);
+        const contextRelevance = this.analyzeContextRelevance(task);
+        const truthScore = (descriptionQuality + outputConsistency + contextRelevance) / 3;
+        const isValid = truthScore >= 0.7;
+        return {
+            isValid,
+            truthScore,
+            signature: this.generateSignature(task, truthScore),
+            timestamp: new Date().toISOString(),
+            consensusNodes: 1,
+            metadata: {
+                validator: 'SemanticValidator',
+                method: 'consensus',
+                confidence: truthScore
+            }
+        };
+    }
+    analyzeDescription(description) {
+        if (!description) return 0;
+        // Basic quality metrics
+        const wordCount = description.split(' ').length;
+        const hasActionWords = /\b(implement|create|build|develop|test|validate)\b/i.test(description);
+        const hasSpecificity = description.length > 20;
+        let score = 0.3; // Base score
+        if (wordCount >= 5) score += 0.3;
+        if (hasActionWords) score += 0.2;
+        if (hasSpecificity) score += 0.2;
+        return Math.min(score, 1.0);
+    }
+    analyzeOutputConsistency(task) {
+        if (!task.expectedOutput || !task.actualOutput) return 0.5;
+        try {
+            const expectedStr = JSON.stringify(task.expectedOutput);
+            const actualStr = JSON.stringify(task.actualOutput);
+            if (expectedStr === actualStr) return 1.0;
+            // Partial matching
+            const similarity = this.calculateSimilarity(expectedStr, actualStr);
+            return Math.max(similarity, 0.1);
+        } catch  {
+            return 0.2;
+        }
+    }
+    analyzeContextRelevance(task) {
+        if (!task.context) return 0.3;
+        const contextKeys = Object.keys(task.context);
+        const hasUsefulContext = contextKeys.length > 0;
+        const hasTimestamp = 'timestamp' in task.context || 'createdAt' in task.context;
+        const hasUser = 'userId' in task.context || 'user' in task.context;
+        let score = 0.3;
+        if (hasUsefulContext) score += 0.3;
+        if (hasTimestamp) score += 0.2;
+        if (hasUser) score += 0.2;
+        return score;
+    }
+    calculateSimilarity(str1, str2) {
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0) return 1.0;
+        const editDistance = this.levenshteinDistance(longer, shorter);
+        return (longer.length - editDistance) / longer.length;
+    }
+    levenshteinDistance(str1, str2) {
+        const matrix = Array(str2.length + 1).fill(null).map(()=>Array(str1.length + 1).fill(null));
+        for(let i = 0; i <= str1.length; i += 1){
+            matrix[0][i] = i;
+        }
+        for(let j = 0; j <= str2.length; j += 1){
+            matrix[j][0] = j;
+        }
+        for(let j = 1; j <= str2.length; j += 1){
+            for(let i = 1; i <= str1.length; i += 1){
+                const indicator = str1[i - 1] === str2[j - 1] ? 0 : 1;
+                matrix[j][i] = Math.min(matrix[j][i - 1] + 1, matrix[j - 1][i] + 1, matrix[j - 1][i - 1] + indicator);
+            }
+        }
+        return matrix[str2.length][str1.length];
+    }
+    basicValidation(task) {
+        const isValid = Boolean(task.description && task.id);
+        const truthScore = isValid ? 0.5 : 0.1;
+        return {
+            isValid,
+            truthScore,
+            signature: 'basic-validation',
+            timestamp: new Date().toISOString(),
+            consensusNodes: 0,
+            metadata: {
+                validator: 'BasicValidator',
+                method: 'cryptographic',
+                confidence: truthScore
+            }
+        };
+    }
+    generateSignature(task, score) {
+        const data = `${task.id}-${score}-${Date.now()}`;
+        return createHash('sha256').update(data).digest('hex');
+    }
+    validateSignature(hash, signature) {
+        // Simulated signature validation
+        return signature.length === 64 && /^[a-f0-9]+$/i.test(signature);
+    }
+    recordValidation(taskId, result) {
+        if (!this.validationHistory.has(taskId)) {
+            this.validationHistory.set(taskId, []);
+        }
+        this.validationHistory.get(taskId).push(result);
+    }
+    getValidationHistory(taskId) {
+        return this.validationHistory.get(taskId) || [];
+    }
+    getSystemMetrics() {
+        const totalValidations = Array.from(this.validationHistory.values()).reduce((sum, history)=>sum + history.length, 0);
+        const allResults = Array.from(this.validationHistory.values()).flat();
+        const avgTruthScore = allResults.length > 0 ? allResults.reduce((sum, r)=>sum + r.truthScore, 0) / allResults.length : 0;
+        const successRate = allResults.length > 0 ? allResults.filter((r)=>r.isValid).length / allResults.length : 0;
+        return {
+            totalValidations,
+            avgTruthScore,
+            successRate,
+            consensusNodes: this.consensusNodes.size,
+            lastValidation: allResults.length > 0 ? allResults[allResults.length - 1].timestamp : null
+        };
+    }
+}
+
+//# sourceMappingURL=TruthBasedValidator.js.map

package/dist/src/feature-flags/validation/TruthBasedValidator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/feature-flags/validation/TruthBasedValidator.ts"],"names":["createHash","randomBytes","EventEmitter","TruthBasedValidator","flagManager","validationHistory","Map","consensusNodes","Set","initializeConsensusNodes","nodeCount","parseInt","process","env","MAX_CONSENSUS_AGENTS","i","add","toString","validateCompletion","task","isEnabled","userId","basicValidation","result","performTruthValidation","recordValidation","id","emit","taskId","method","error","message","validationMethods","Promise","allSettled","cryptographicValidation","consensusValidation","semanticValidation","results","filter","status","map","value","length","Error","avgTruthScore","reduce","sum","r","truthScore","consensusCount","isValid","Math","ceil","signature","generateSignature","timestamp","Date","toISOString","size","metadata","validator","confidence","taskHash","update","JSON","stringify","description","expectedOutput","actualOutput","digest","validateSignature","validationPromises","Array","from","nodeId","nodeValidation","nodeResults","successfulValidations","Boolean","totalNodes","consensusRatio","nodeReliability","randomFactor","random","hasExpectedOutput","undefined","outputMatches","descriptionValid","contextValid","context","descriptionQuality","analyzeDescription","outputConsistency","analyzeOutputConsistency","contextRelevance","analyzeContextRelevance","wordCount","split","hasActionWords","test","hasSpecificity","score","min","expectedStr","actualStr","similarity","calculateSimilarity","max","contextKeys","Object","keys","hasUsefulContext","hasTimestamp","hasUser","str1","str2","longer","shorter","editDistance","levenshteinDistance","matrix","fill","j","indicator","data","now","hash","has","set","get","push","getValidationHistory","getSystemMetrics","totalValidations","values","history","allResults","flat","successRate","lastValidation"],"mappings":"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"}