claude-flow-novice 2.15.10 → 2.16.0

package/claude-assets/skills/cfn-loop-validation/src/cli/validate-gate.ts

@@ -0,0 +1,139 @@
+#!/usr/bin/env node
+
+/**
+ * CLI: Validate Gate
+ *
+ * Checks if test pass rate meets mode-specific thresholds.
+ *
+ * Usage:
+ *   validate-gate --pass-rate 0.95 [--mode standard] [--json]
+ *   validate-gate --pass-rate 0.95 --threshold 0.90 [--json]
+ *
+ * Mode-Specific Thresholds:
+ *   mvp:        0.70 (70%)
+ *   standard:   0.95 (95%)
+ *   enterprise: 0.98 (98%)
+ *
+ * Returns JSON with gate validation result
+ */
+
+import { CFNValidator } from '../validator';
+
+interface CLIOptions {
+  passRate?: number;
+  threshold?: number;
+  mode?: 'mvp' | 'standard' | 'enterprise';
+  json?: boolean;
+  taskId?: string;
+}
+
+/**
+ * Parse CLI arguments
+ */
+function parseArgs(): CLIOptions {
+  const options: CLIOptions = {
+    json: false,
+    mode: 'standard',
+  };
+
+  for (let i = 2; i < process.argv.length; i++) {
+    const arg = process.argv[i];
+
+    if (arg === '--pass-rate' && process.argv[i + 1]) {
+      const value = parseFloat(process.argv[++i]);
+      if (isNaN(value) || value < 0 || value > 1) {
+        console.error('Error: pass-rate must be between 0 and 1');
+        process.exit(1);
+      }
+      options.passRate = value;
+    } else if (arg === '--threshold' && process.argv[i + 1]) {
+      const value = parseFloat(process.argv[++i]);
+      if (isNaN(value) || value < 0 || value > 1) {
+        console.error('Error: threshold must be between 0 and 1');
+        process.exit(1);
+      }
+      options.threshold = value;
+    } else if (arg === '--mode' && process.argv[i + 1]) {
+      const mode = process.argv[++i];
+      if (!['mvp', 'standard', 'enterprise'].includes(mode)) {
+        console.error(`Error: Invalid mode '${mode}'. Must be mvp, standard, or enterprise`);
+        process.exit(1);
+      }
+      options.mode = mode as any;
+    } else if (arg === '--json') {
+      options.json = true;
+    } else if (arg === '--task-id' && process.argv[i + 1]) {
+      options.taskId = process.argv[++i];
+    }
+  }
+
+  return options;
+}
+
+/**
+ * Print human-readable output
+ */
+function printHumanOutput(
+  result: Awaited<ReturnType<CFNValidator['validateGatePass']>>
+): void {
+  console.log('\nGate Validation Report:');
+  console.log(`  Pass Rate: ${(result.passRate * 100).toFixed(2)}%`);
+  console.log(`  Threshold: ${(result.threshold * 100).toFixed(2)}%`);
+  console.log(`  Mode: ${result.mode}`);
+
+  if (!result.passed && result.gap !== undefined) {
+    console.log(`  Gap: ${(result.gap * 100).toFixed(2)}%`);
+  }
+
+  console.log(`  Status: ${result.passed ? 'PASSED' : 'FAILED'}`);
+  console.log(`  Reason: ${result.reason}`);
+}
+
+/**
+ * Main execution
+ */
+async function main(): Promise<void> {
+  const options = parseArgs();
+
+  // Validate input
+  if (typeof options.passRate !== 'number') {
+    console.error('Error: --pass-rate is required');
+    console.error('Usage: validate-gate --pass-rate 0.95 [--mode standard] [--json]');
+    process.exit(1);
+  }
+
+  // Create validator
+  const validator = new CFNValidator({
+    mode: options.mode || 'standard',
+    taskId: options.taskId || 'cli-validate-gate',
+  });
+
+  try {
+    // Validate gate
+    const result = await validator.validateGatePass(options.passRate, options.mode);
+
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printHumanOutput(result);
+    }
+
+    // Exit with proper code
+    process.exit(result.passed ? 0 : 1);
+  } catch (error) {
+    if (options.json) {
+      console.error(JSON.stringify({
+        error: error instanceof Error ? error.message : String(error),
+        code: 'VALIDATION_ERROR',
+      }));
+    } else {
+      console.error(`Error: ${error}`);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/claude-assets/skills/cfn-loop-validation/src/types.ts

@@ -0,0 +1,215 @@
+/**
+ * Validation Type Definitions
+ *
+ * Core types for CFN Loop validation system including:
+ * - Deliverable validation
+ * - Success criteria
+ * - Consensus and gate checking
+ * - Vapor detection
+ *
+ * @module cfn-loop-validation/types
+ */
+
+// ===== EXECUTION MODE TYPES =====
+
+export type ExecutionMode = 'mvp' | 'standard' | 'enterprise';
+
+// ===== DELIVERABLE VALIDATION =====
+
+/**
+ * File validation result
+ */
+export interface DeliverableValidation {
+  path: string;
+  exists: boolean;
+  sizeBytes?: number;
+  lastModified?: string;
+  mimeType?: string;
+  readable?: boolean;
+  error?: string;
+}
+
+/**
+ * Batch deliverable validation result
+ */
+export interface DeliverableValidationResult {
+  deliverables: DeliverableValidation[];
+  totalFiles: number;
+  existingFiles: number;
+  missingFiles: number;
+  totalSizeBytes: number;
+  allExist: boolean;
+  timestamp: number;
+}
+
+// ===== SUCCESS CRITERIA TYPES =====
+
+/**
+ * Success criteria definition
+ */
+export interface SuccessCriteria {
+  description: string;
+  type: 'file_exists' | 'test_pass' | 'command_output' | 'custom';
+  condition: string;
+  expected?: string | number | boolean;
+  command?: string;
+  paths?: string[];
+  timeout?: number;
+}
+
+/**
+ * Success criteria validation result
+ */
+export interface SuccessCriteriaValidationResult {
+  passed: boolean;
+  criteria: SuccessCriteria[];
+  passedCount: number;
+  failedCount: number;
+  details: {
+    criterion: SuccessCriteria;
+    passed: boolean;
+    result?: any;
+    error?: string;
+  }[];
+  timestamp: number;
+}
+
+// ===== GATE VALIDATION =====
+
+/**
+ * Gate validation result
+ */
+export interface GateValidationResult {
+  passed: boolean;
+  passRate: number;
+  threshold: number;
+  mode: ExecutionMode;
+  gap?: number;
+  reason: string;
+  timestamp: number;
+}
+
+/**
+ * Consensus validation result
+ */
+export interface ConsensusValidationResult {
+  passed: boolean;
+  consensusScore: number;
+  threshold: number;
+  mode: ExecutionMode;
+  validatorCount: number;
+  scores: number[];
+  timestamp: number;
+}
+
+// ===== VAPOR DETECTION =====
+
+/**
+ * Vapor detection result
+ */
+export interface VaporDetectionResult {
+  detected: boolean;
+  claimsCompletion: boolean;
+  deliverablesMissing: boolean;
+  missingDeliverables: string[];
+  agentOutput: string;
+  expectedDeliverables: string[];
+  confidence: number; // 0.0 - 1.0, confidence level of detection
+  timestamp: number;
+}
+
+// ===== VALIDATION CONFIG =====
+
+/**
+ * Validation configuration
+ */
+export interface ValidationConfig {
+  mode: ExecutionMode;
+  gateThreshold?: number;
+  consensusThreshold?: number;
+  taskId: string;
+  agentId?: string;
+  timeout?: number; // milliseconds
+  allowCaching?: boolean;
+}
+
+// ===== VALIDATION RESULT (UNIFIED) =====
+
+/**
+ * Unified validation result containing all validation types
+ */
+export interface ValidationResult {
+  taskId: string;
+  timestamp: number;
+  mode: ExecutionMode;
+  deliverables?: DeliverableValidationResult;
+  successCriteria?: SuccessCriteriaValidationResult;
+  gate?: GateValidationResult;
+  consensus?: ConsensusValidationResult;
+  vapor?: VaporDetectionResult;
+  passed: boolean;
+  errors: ValidationError[];
+  warnings: string[];
+}
+
+// ===== ERROR TYPES =====
+
+/**
+ * Validation error
+ */
+export class ValidationError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public details?: Record<string, any>
+  ) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Consensus on vapor error
+ */
+export class ConsensusOnVaporError extends ValidationError {
+  constructor(
+    message: string,
+    details?: Record<string, any>
+  ) {
+    super(message, 'CONSENSUS_ON_VAPOR', details);
+    this.name = 'ConsensusOnVaporError';
+  }
+}
+
+// ===== VALIDATION HELPERS =====
+
+/**
+ * Type guard for execution mode
+ */
+export function isExecutionMode(value: any): value is ExecutionMode {
+  return ['mvp', 'standard', 'enterprise'].includes(value);
+}
+
+/**
+ * Type guard for validation config
+ */
+export function isValidationConfig(value: any): value is ValidationConfig {
+  return (
+    value &&
+    typeof value === 'object' &&
+    isExecutionMode(value.mode) &&
+    typeof value.taskId === 'string'
+  );
+}
+
+/**
+ * Type guard for success criteria
+ */
+export function isSuccessCriteria(value: any): value is SuccessCriteria {
+  return (
+    value &&
+    typeof value === 'object' &&
+    typeof value.description === 'string' &&
+    ['file_exists', 'test_pass', 'command_output', 'custom'].includes(value.type)
+  );
+}