claude-flow-novice 2.18.6 → 2.18.8

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/context-lookup.js

@@ -1,388 +0,0 @@
-"use strict";
-/**
- * Context Lookup Helper - Phase 4 TypeScript Migration
- *
- * Retrieves and validates context from Redis for CFN Loop orchestration.
- * Handles task context lookup, iteration-specific retrieval, and broadcast context.
- *
- * Migrated from:
- * - .claude/skills/cfn-loop-orchestration/helpers/context-lookup.sh (359 LOC)
- *
- * Features:
- * - Single and batch context retrieval
- * - Iteration-specific lookup
- * - Context validation and completeness checking
- * - Graceful handling of missing context
- * - Broadcast context support
- * - Optional context caching
- *
- * @example
- * ```typescript
- * const lookup = new ContextLookup(redis, logger);
- *
- * // Retrieve task context
- * const context = await lookup.lookupContext('task-123');
- *
- * // Retrieve iteration-specific context
- * const iterContext = await lookup.lookupContext('task-123', 2);
- *
- * // Validate context structure
- * const isValid = await lookup.validateContextStructure(context);
- * ```
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ContextLookup = void 0;
-exports.taskId = taskId;
-exports.createContextLookup = createContextLookup;
-/**
- * Helper to create a branded TaskId
- */
-function taskId(value) {
-    return value;
-}
-/**
- * Context Lookup Module
- *
- * Provides type-safe context retrieval from Redis with validation.
- * Supports caching for performance optimization.
- */
-class ContextLookup {
-    redis;
-    logger;
-    enableCache;
-    contextCache = new Map();
-    CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
-    constructor(redis, logger, enableCache = true) {
-        this.redis = redis;
-        this.logger = logger;
-        this.enableCache = enableCache;
-    }
-    /**
-     * Look up task context by task ID and optional iteration
-     *
-     * @param taskId Task identifier
-     * @param iteration Optional iteration number
-     * @returns LookupResult with context or empty result
-     *
-     * @throws Error if context retrieval fails
-     */
-    async lookupContext(taskId, iteration) {
-        const cacheKey = this.buildCacheKey(taskId, iteration);
-        // Check cache first if enabled
-        if (this.enableCache) {
-            const cached = this.getFromCache(cacheKey);
-            if (cached) {
-                this.logger.debug(`Context cache hit for ${cacheKey}`);
-                return {
-                    context: cached,
-                    found: true,
-                    cached: true,
-                    retrievedAt: new Date().toISOString(),
-                    source: 'cache'
-                };
-            }
-        }
-        try {
-            // Build Redis key
-            const redisKey = iteration
-                ? `cfn_loop:${taskId}:context:iteration:${iteration}`
-                : `cfn_loop:${taskId}:context`;
-            this.logger.debug(`Looking up context from Redis: ${redisKey}`);
-            // Retrieve from Redis
-            const rawContext = await this.redis.get(redisKey);
-            if (!rawContext) {
-                this.logger.warn(`Context not found: ${redisKey}`);
-                return {
-                    context: {},
-                    found: false,
-                    cached: false,
-                    retrievedAt: new Date().toISOString(),
-                    source: 'redis'
-                };
-            }
-            // Parse and validate
-            const context = JSON.parse(rawContext);
-            if (!this.validateContextStructure(context)) {
-                this.logger.error(`Invalid context structure: ${redisKey}`);
-                return {
-                    context: {},
-                    found: false,
-                    cached: false,
-                    retrievedAt: new Date().toISOString(),
-                    source: 'redis'
-                };
-            }
-            // Cache if enabled
-            if (this.enableCache) {
-                this.saveToCache(cacheKey, context);
-            }
-            return {
-                context,
-                found: true,
-                cached: false,
-                retrievedAt: new Date().toISOString(),
-                source: 'redis'
-            };
-        }
-        catch (error) {
-            this.logger.error(`Context lookup failed for ${taskId}:`, error);
-            throw new Error(`Failed to lookup context: ${String(error)}`);
-        }
-    }
-    /**
-     * Look up multiple contexts in batch
-     *
-     * @param taskIds Array of task identifiers
-     * @returns BatchLookupResult with all found contexts
-     */
-    async lookupMultipleContexts(taskIds) {
-        const contexts = new Map();
-        const missing = [];
-        const retrievedAt = new Date().toISOString();
-        this.logger.info(`Batch context lookup for ${taskIds.length} tasks`);
-        for (const taskId of taskIds) {
-            try {
-                const result = await this.lookupContext(taskId);
-                if (result.found) {
-                    contexts.set(String(taskId), result.context);
-                }
-                else {
-                    missing.push(String(taskId));
-                }
-            }
-            catch (error) {
-                this.logger.warn(`Failed to lookup context for ${taskId}:`, error);
-                missing.push(String(taskId));
-            }
-        }
-        return {
-            taskId: taskIds[0],
-            contexts,
-            total: taskIds.length,
-            found: contexts.size,
-            missing,
-            retrievedAt
-        };
-    }
-    /**
-     * Get the latest context for a task (most recent iteration)
-     *
-     * @param taskId Task identifier
-     * @returns BroadcastContext or undefined if not found
-     */
-    async getLatestContext(taskId) {
-        try {
-            const redisKey = `cfn_loop:${taskId}:context:latest`;
-            const rawContext = await this.redis.get(redisKey);
-            if (!rawContext) {
-                this.logger.debug(`Latest context not found for ${taskId}`);
-                return undefined;
-            }
-            const context = JSON.parse(rawContext);
-            if (!this.validateContextStructure(context)) {
-                this.logger.error(`Invalid latest context for ${taskId}`);
-                return undefined;
-            }
-            return context;
-        }
-        catch (error) {
-            this.logger.error(`Failed to get latest context for ${taskId}:`, error);
-            return undefined;
-        }
-    }
-    /**
-     * Validate context structure against required fields
-     *
-     * @param context Context object to validate
-     * @returns true if context is valid, false otherwise
-     */
-    validateContextStructure(context) {
-        if (!context || typeof context !== 'object') {
-            this.logger.warn('Context is not an object');
-            return false;
-        }
-        const ctx = context;
-        // Required fields for BroadcastContext
-        const requiredFields = [
-            'taskId',
-            'iteration',
-            'phase',
-            'mode',
-            'timestamp',
-            'contextVersion'
-        ];
-        for (const field of requiredFields) {
-            if (!(field in ctx) || ctx[field] === undefined || ctx[field] === null) {
-                this.logger.warn(`Missing required field: ${String(field)}`);
-                return false;
-            }
-        }
-        // Type validation
-        if (typeof ctx.taskId !== 'string') {
-            this.logger.warn('taskId must be a string');
-            return false;
-        }
-        if (typeof ctx.iteration !== 'number' || ctx.iteration < 1) {
-            this.logger.warn('iteration must be a positive number');
-            return false;
-        }
-        const validPhases = ['loop3', 'loop2', 'product-owner', 'iteration-prep'];
-        if (!validPhases.includes(String(ctx.phase))) {
-            this.logger.warn(`Invalid phase: ${String(ctx.phase)}`);
-            return false;
-        }
-        const validModes = ['task', 'cli', 'unknown'];
-        if (!validModes.includes(String(ctx.mode))) {
-            this.logger.warn(`Invalid mode: ${String(ctx.mode)}`);
-            return false;
-        }
-        if (typeof ctx.timestamp !== 'string') {
-            this.logger.warn('timestamp must be a string');
-            return false;
-        }
-        if (typeof ctx.contextVersion !== 'string') {
-            this.logger.warn('contextVersion must be a string');
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Validate that context contains all expected fields
-     * More lenient than validateContextStructure - allows optional fields
-     *
-     * @param context Context to validate
-     * @param rules Validation rules (optional)
-     * @returns true if context is complete, false otherwise
-     */
-    isContextComplete(context, rules) {
-        const ctx = context;
-        // Check required fields
-        if (rules?.requiredFields) {
-            for (const field of rules.requiredFields) {
-                if (!(field in ctx) || ctx[field] === undefined) {
-                    this.logger.warn(`Missing required field: ${field}`);
-                    return false;
-                }
-            }
-        }
-        // Check optional fields if all are present
-        if (rules?.optionalFields) {
-            const missingOptional = rules.optionalFields.filter((field) => !(field in ctx) || ctx[field] === undefined);
-            if (missingOptional.length > 0) {
-                this.logger.debug(`Missing optional fields: ${missingOptional.join(', ')}`);
-            }
-        }
-        return true;
-    }
-    /**
-     * Get context by phase within a task
-     *
-     * @param taskId Task identifier
-     * @param phase Loop phase to retrieve
-     * @returns BroadcastContext for that phase or undefined
-     */
-    async getContextByPhase(taskId, phase) {
-        try {
-            const redisKey = `cfn_loop:${taskId}:context:phase:${phase}`;
-            const rawContext = await this.redis.get(redisKey);
-            if (!rawContext) {
-                this.logger.debug(`Context not found for phase ${phase} in task ${taskId}`);
-                return undefined;
-            }
-            const context = JSON.parse(rawContext);
-            if (!this.validateContextStructure(context)) {
-                this.logger.error(`Invalid context for phase ${phase} in task ${taskId}`);
-                return undefined;
-            }
-            return context;
-        }
-        catch (error) {
-            this.logger.error(`Failed to get context by phase for ${taskId}:${phase}:`, error);
-            return undefined;
-        }
-    }
-    /**
-     * Clear cache for a specific context or all cache
-     *
-     * @param taskId Optional task ID to clear specific cache
-     * @param iteration Optional iteration to clear specific cache
-     */
-    clearCache(taskId, iteration) {
-        if (taskId) {
-            const cacheKey = this.buildCacheKey(taskId, iteration);
-            this.contextCache.delete(cacheKey);
-            this.logger.debug(`Cleared cache for ${cacheKey}`);
-        }
-        else {
-            this.contextCache.clear();
-            this.logger.debug('Cleared all context cache');
-        }
-    }
-    /**
-     * Get cache statistics
-     *
-     * @returns Object with cache statistics
-     */
-    getCacheStats() {
-        return {
-            size: this.contextCache.size,
-            maxSize: 1000, // Reasonable default
-            ttlMs: this.CACHE_TTL_MS
-        };
-    }
-    /**
-     * Build cache key from task ID and optional iteration
-     * @private
-     */
-    buildCacheKey(taskId, iteration) {
-        return iteration
-            ? `${taskId}:iteration:${iteration}`
-            : String(taskId);
-    }
-    /**
-     * Get context from cache if still valid
-     * @private
-     */
-    getFromCache(key) {
-        const cached = this.contextCache.get(key);
-        if (!cached) {
-            return undefined;
-        }
-        const age = Date.now() - cached.timestamp;
-        if (age > this.CACHE_TTL_MS) {
-            this.contextCache.delete(key);
-            return undefined;
-        }
-        return cached.context;
-    }
-    /**
-     * Save context to cache
-     * @private
-     */
-    saveToCache(key, context) {
-        // Prevent cache bloat
-        if (this.contextCache.size >= 1000) {
-            const firstKey = this.contextCache.keys().next().value;
-            if (firstKey) {
-                this.contextCache.delete(firstKey);
-            }
-        }
-        this.contextCache.set(key, {
-            context,
-            timestamp: Date.now()
-        });
-    }
-}
-exports.ContextLookup = ContextLookup;
-/**
- * Factory function for creating a ContextLookup instance
- *
- * @param redis Redis coordinator instance
- * @param logger Logger instance
- * @param enableCache Enable context caching (default: true)
- * @returns ContextLookup instance
- */
-function createContextLookup(redis, logger, enableCache = true) {
-    return new ContextLookup(redis, logger, enableCache);
-}
-//# sourceMappingURL=context-lookup.js.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/deliverable-verifier.d.ts

@@ -1,26 +0,0 @@
-/**
- * Deliverable Verifier
- * Verifies expected deliverables exist (prevents "consensus on vapor")
- */
-export interface VerificationResult {
-    verified: boolean;
-    files: string[];
-    missing: string[];
-    found: string[];
-    typeErrors?: string[];
-    gitChanges?: number;
-    requiresChanges?: boolean;
-    reason?: string;
-}
-/**
- * Verifies expected deliverables exist
- * @param params Verification parameters
- * @returns VerificationResult with detailed verification status
- */
-export declare function verifyDeliverables(params: {
-    files: string[];
-    expectedTypes?: string[];
-    requireGitChanges?: boolean;
-    taskType?: string;
-}): VerificationResult;
-//# sourceMappingURL=deliverable-verifier.d.ts.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/deliverable-verifier.js

@@ -1,116 +0,0 @@
-"use strict";
-/**
- * Deliverable Verifier
- * Verifies expected deliverables exist (prevents "consensus on vapor")
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyDeliverables = verifyDeliverables;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const child_process_1 = require("child_process");
-const IMPLEMENTATION_KEYWORDS = [
-    'create', 'build', 'implement', 'add', 'generate'
-];
-/**
- * Verifies expected deliverables exist
- * @param params Verification parameters
- * @returns VerificationResult with detailed verification status
- */
-function verifyDeliverables(params) {
-    const found = [];
-    const missing = [];
-    const typeErrors = [];
-    // Check each file
-    for (const file of params.files) {
-        if (fs.existsSync(file)) {
-            found.push(file);
-            // Type validation if expected types specified
-            if (params.expectedTypes && params.expectedTypes.length > 0) {
-                const ext = path.extname(file);
-                if (!params.expectedTypes.includes(ext)) {
-                    typeErrors.push(file);
-                }
-            }
-        }
-        else {
-            missing.push(file);
-        }
-    }
-    // Git change detection
-    let gitChanges = 0;
-    if (params.requireGitChanges !== undefined) {
-        try {
-            const gitStatus = (0, child_process_1.execSync)('git status --short', {
-                encoding: 'utf-8',
-                timeout: 10000, // 10 second timeout
-                maxBuffer: 1024 * 1024 // 1MB buffer
-            });
-            gitChanges = gitStatus.trim().split('\n').filter(line => line.length > 0).length;
-        }
-        catch (error) {
-            // Git not available, not a git repo, or timeout
-            gitChanges = -1;
-        }
-    }
-    // Detect if task requires changes (implementation keywords)
-    const requiresChanges = params.taskType
-        ? IMPLEMENTATION_KEYWORDS.some(keyword => params.taskType.toLowerCase().includes(keyword))
-        : false;
-    // Check for "consensus on vapor"
-    let verified = missing.length === 0 && typeErrors.length === 0;
-    let reason;
-    if (requiresChanges && params.requireGitChanges && gitChanges === 0 && params.files.length === 0) {
-        verified = false;
-        reason = 'Implementation task detected but no deliverables created (consensus on vapor)';
-    }
-    const result = {
-        verified,
-        files: params.files,
-        missing,
-        found,
-        gitChanges,
-        requiresChanges
-    };
-    // Add optional properties only if they have values
-    if (typeErrors.length > 0) {
-        result.typeErrors = typeErrors;
-    }
-    if (reason !== undefined) {
-        result.reason = reason;
-    }
-    return result;
-}
-//# sourceMappingURL=deliverable-verifier.js.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/gate-check.d.ts

@@ -1,27 +0,0 @@
-/**
- * Gate Check Helper - Test-Driven Validation
- * Validates Loop 3 self-assessment against test pass rate thresholds
- */
-export type Mode = 'mvp' | 'standard' | 'enterprise';
-export interface GateCheckParams {
-    passRate: number;
-    threshold?: number | undefined;
-    mode: Mode;
-}
-export interface GateCheckResult {
-    passed: boolean;
-    passRate: number;
-    threshold: number;
-    mode: Mode;
-    gap: number;
-    reason: string;
-}
-/**
- * Get threshold for a specific mode
- */
-export declare function getModeThreshold(mode: Mode): number;
-/**
- * Perform gate check
- */
-export declare function gateCheck(params: GateCheckParams): GateCheckResult;
-//# sourceMappingURL=gate-check.d.ts.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/gate-check.js

@@ -1,92 +0,0 @@
-"use strict";
-/**
- * Gate Check Helper - Test-Driven Validation
- * Validates Loop 3 self-assessment against test pass rate thresholds
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModeThreshold = getModeThreshold;
-exports.gateCheck = gateCheck;
-/**
- * Mode-specific thresholds
- */
-const MODE_THRESHOLDS = {
-    mvp: 0.70,
-    standard: 0.95,
-    enterprise: 0.98,
-};
-/**
- * Get threshold for a specific mode
- */
-function getModeThreshold(mode) {
-    return MODE_THRESHOLDS[mode];
-}
-/**
- * Perform gate check
- */
-function gateCheck(params) {
-    const { passRate, mode } = params;
-    // Use custom threshold if provided, otherwise use mode-specific
-    const threshold = params.threshold !== undefined ? params.threshold : getModeThreshold(mode);
-    // Determine if gate passed
-    const passed = passRate >= threshold;
-    // Calculate gap (threshold - passRate)
-    // Positive gap = need improvement (failing)
-    // Zero gap = exactly at threshold
-    // Negative gap = exceeded threshold (passing)
-    const gap = parseFloat((threshold - passRate).toFixed(4));
-    // Generate reason
-    const reason = passed
-        ? `Gate PASSED: Pass rate ${passRate.toFixed(4)} >= threshold ${threshold.toFixed(4)} (${mode} mode)`
-        : `Gate FAILED: Pass rate ${passRate.toFixed(4)} < threshold ${threshold.toFixed(4)} (${mode} mode)`;
-    return {
-        passed,
-        passRate,
-        threshold,
-        mode,
-        gap,
-        reason,
-    };
-}
-/**
- * CLI entry point for bash wrapper
- */
-if (require.main === module) {
-    const args = process.argv.slice(2);
-    // Parse command line arguments
-    let passRate = 0;
-    let threshold = undefined;
-    let mode = 'standard';
-    for (let i = 0; i < args.length; i++) {
-        const arg = args[i];
-        if (!arg)
-            continue;
-        switch (arg) {
-            case '--pass-rate': {
-                const nextArg = args[++i];
-                if (nextArg)
-                    passRate = parseFloat(nextArg);
-                break;
-            }
-            case '--threshold': {
-                const nextArg = args[++i];
-                if (nextArg)
-                    threshold = parseFloat(nextArg);
-                break;
-            }
-            case '--mode': {
-                const nextArg = args[++i];
-                if (nextArg)
-                    mode = nextArg;
-                break;
-            }
-        }
-    }
-    const params = { passRate, mode };
-    if (threshold !== undefined) {
-        params.threshold = threshold;
-    }
-    const result = gateCheck(params);
-    console.log(JSON.stringify(result, null, 2));
-    process.exit(result.passed ? 0 : 1);
-}
-//# sourceMappingURL=gate-check.js.map

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/orchestrator/dist/helpers/iteration-manager.d.ts

@@ -1,28 +0,0 @@
-/**
- * Iteration Manager
- * Manages CFN Loop iteration transitions and agent wake operations
- */
-export interface IterationPreparation {
-    nextIteration: number;
-    feedback: any;
-    timestamp: string;
-}
-export interface WakeResult {
-    signals: string[];
-}
-/**
- * Prepares next iteration with feedback
- * @param params Current iteration and feedback data
- * @returns IterationPreparation for next iteration
- */
-export declare function prepareIteration(params: {
-    currentIteration: number;
-    feedback: any;
-}): IterationPreparation;
-/**
- * Prepares wake signals for agents
- * @param agentIds Array of agent IDs to wake
- * @returns WakeResult with signal identifiers
- */
-export declare function wakeAgents(agentIds: string[]): WakeResult;
-//# sourceMappingURL=iteration-manager.d.ts.map