fraim-framework 2.0.56 → 2.0.58

package/dist/src/ai-manager/phase-flow.js

@@ -1,357 +0,0 @@
-"use strict";
-/**
- * Phase flow logic for AI Manager workflows
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNextPhase = getNextPhase;
-exports.isPhaseValidForWorkflow = isPhaseValidForWorkflow;
-exports.getPhaseOnFailure = getPhaseOnFailure;
-exports.getPhasesForWorkflow = getPhasesForWorkflow;
-exports.getNextPhaseForImplement = getNextPhaseForImplement;
-exports.isPhaseValidForIssueType = isPhaseValidForIssueType;
-exports.getPhasesForIssueType = getPhasesForIssueType;
-exports.getPhaseOnImplementFailure = getPhaseOnImplementFailure;
-/**
- * Phase flows for different workflow types
- */
-const BUG_PHASE_FLOW = [
-    'implement-scoping',
-    'implement-repro',
-    'implement-code',
-    'implement-validate',
-    'implement-regression',
-    'implement-completeness-review',
-    'submit-pr',
-    'wait-for-pr-review',
-    'retrospective',
-];
-const FEATURE_PHASE_FLOW = [
-    'implement-scoping',
-    'implement-spike',
-    'implement-code',
-    'implement-validate',
-    'implement-smoke',
-    'implement-regression',
-    'implement-completeness-review',
-    'submit-pr',
-    'wait-for-pr-review',
-    'retrospective',
-];
-const SPEC_PHASE_FLOW = [
-    'spec-spec',
-    'spec-competitor-analysis',
-    'spec-completeness-review',
-    'submit-pr',
-    'wait-for-pr-review',
-    'retrospective',
-];
-const DESIGN_PHASE_FLOW = [
-    'design-design',
-    'design-completeness-review',
-    'submit-pr',
-    'wait-for-pr-review',
-    'retrospective',
-];
-const TEST_PHASE_FLOW = [
-    'test-test',
-    'test-validate',
-    'submit-pr',
-    'wait-for-pr-review',
-    'retrospective',
-];
-const CUSTOMER_DEVELOPMENT_PHASE_FLOW = [
-    'customer-profiling',
-    'platform-discovery',
-    'prospect-qualification',
-    'inventory-compilation',
-];
-const USER_SURVEY_PHASE_FLOW = [
-    'survey-scoping',
-    'survey-build-linkedin',
-    'survey-build-reddit',
-    'survey-build-x',
-    'survey-build-facebook',
-    'survey-build-custom',
-    'survey-dispatch',
-];
-/**
- * Get the next phase in the workflow
- * @param currentPhase - Current phase
- * @param workflowType - Type of workflow
- * @param issueType - Type of issue (only used for implement workflow)
- * @returns Next phase or null if at end of workflow
- */
-function getNextPhase(currentPhase, workflowType, issueType) {
-    // Special handling for address-pr-feedback phase
-    if (currentPhase === 'address-pr-feedback') {
-        // Success path: After addressing feedback, go back to appropriate validation phase
-        if (workflowType === 'implement') {
-            return 'implement-validate';
-        }
-        else if (workflowType === 'spec') {
-            return 'spec-completeness-review';
-        }
-        else if (workflowType === 'design') {
-            return 'design-completeness-review';
-        }
-        else if (workflowType === 'test') {
-            return 'test-validate';
-        }
-        else {
-            throw new Error(`Unknown workflow type: ${workflowType}`);
-        }
-    }
-    let flow;
-    if (workflowType === 'implement') {
-        if (!issueType) {
-            throw new Error('Issue type is required for implement workflow');
-        }
-        flow = issueType === 'bug' ? BUG_PHASE_FLOW : FEATURE_PHASE_FLOW;
-    }
-    else if (workflowType === 'spec') {
-        flow = SPEC_PHASE_FLOW;
-    }
-    else if (workflowType === 'design') {
-        flow = DESIGN_PHASE_FLOW;
-    }
-    else if (workflowType === 'test') {
-        flow = TEST_PHASE_FLOW;
-    }
-    else if (workflowType === 'customer-development') {
-        flow = CUSTOMER_DEVELOPMENT_PHASE_FLOW;
-    }
-    else if (workflowType === 'user-survey') {
-        flow = USER_SURVEY_PHASE_FLOW;
-    }
-    else {
-        throw new Error(`Unknown workflow type: ${workflowType}`);
-    }
-    const currentIndex = flow.indexOf(currentPhase);
-    if (currentIndex === -1) {
-        throw new Error(`Invalid phase "${currentPhase}" for workflow type "${workflowType}"`);
-    }
-    if (currentIndex >= flow.length - 1) {
-        return null; // At end of workflow
-    }
-    return flow[currentIndex + 1];
-}
-/**
- * Check if a phase is valid for the given workflow type
- * @param phase - Phase to check
- * @param workflowType - Type of workflow
- * @param issueType - Type of issue (only used for implement workflow)
- * @returns True if phase is valid for workflow type
- */
-function isPhaseValidForWorkflow(phase, workflowType, issueType) {
-    let flow;
-    if (workflowType === 'implement') {
-        if (!issueType)
-            return false;
-        flow = issueType === 'bug' ? BUG_PHASE_FLOW : FEATURE_PHASE_FLOW;
-    }
-    else if (workflowType === 'spec') {
-        flow = SPEC_PHASE_FLOW;
-    }
-    else if (workflowType === 'design') {
-        flow = DESIGN_PHASE_FLOW;
-    }
-    else if (workflowType === 'test') {
-        flow = TEST_PHASE_FLOW;
-    }
-    else if (workflowType === 'customer-development') {
-        flow = CUSTOMER_DEVELOPMENT_PHASE_FLOW;
-    }
-    else if (workflowType === 'user-survey') {
-        flow = USER_SURVEY_PHASE_FLOW;
-    }
-    else {
-        return false;
-    }
-    if (phase === 'address-pr-feedback') {
-        return ['implement', 'spec', 'design', 'test'].includes(workflowType);
-    }
-    return flow.includes(phase);
-}
-/**
- * Get the phase to return to when a phase fails
- * @param failedPhase - The phase that failed
- * @param workflowType - Type of workflow
- * @param issueType - Type of issue (currently unused - failure handling is the same for bug/feature)
- * @returns Phase to return to
- */
-function getPhaseOnFailure(failedPhase, workflowType, issueType // eslint-disable-line @typescript-eslint/no-unused-vars
-) {
-    if (workflowType === 'implement') {
-        // Implement workflow failure handling
-        switch (failedPhase) {
-            case 'implement-scoping':
-                return 'implement-scoping'; // Start over at scoping
-            case 'implement-repro':
-                return 'implement-scoping'; // Go back to understand the issue better
-            case 'implement-spike':
-                return 'implement-scoping'; // Go back to understand requirements better
-            case 'implement-code':
-                return 'implement-scoping'; // Go back to re-understand requirements
-            case 'implement-validate':
-                return 'implement-code'; // Implementation doesn't work, fix the code
-            case 'implement-smoke':
-                return 'implement-code'; // Broke existing functionality, fix the implementation
-            case 'implement-regression':
-                return 'implement-code'; // Test issues likely indicate implementation problems
-            case 'implement-completeness-review':
-                return 'implement-validate'; // Missing validation, go back to validate properly
-            case 'submit-pr':
-                return 'implement-completeness-review'; // PR submission issues, review completeness
-            case 'wait-for-pr-review':
-                // PR feedback should go to address-pr-feedback phase
-                return 'address-pr-feedback';
-            case 'retrospective':
-                // If retrospective fails, retry the same phase
-                return 'retrospective';
-            case 'address-pr-feedback':
-                // If addressing PR feedback fails, retry the same phase
-                return 'address-pr-feedback';
-            default:
-                return 'implement-code'; // Default fallback
-        }
-    }
-    else if (workflowType === 'spec') {
-        // Spec workflow failure handling
-        switch (failedPhase) {
-            case 'spec-spec':
-                return 'spec-spec'; // Start over at spec
-            case 'spec-competitor-analysis':
-                return 'spec-spec'; // Go back to improve spec if competitive analysis fails
-            case 'spec-completeness-review':
-                return 'spec-spec'; // Go back to improve competitive analysis
-            case 'submit-pr':
-                return 'spec-completeness-review';
-            case 'wait-for-pr-review':
-                return 'address-pr-feedback'; // PR feedback goes to address phase
-            case 'retrospective':
-                return 'retrospective'; // Retry retrospective if it fails
-            case 'address-pr-feedback':
-                return 'address-pr-feedback'; // Retry addressing feedback
-            default:
-                return 'spec-spec';
-        }
-    }
-    else if (workflowType === 'design') {
-        // Design workflow failure handling
-        switch (failedPhase) {
-            case 'design-design':
-                return 'design-design'; // Start over at design
-            case 'design-completeness-review':
-                return 'design-design'; // Go back to improve design
-            case 'submit-pr':
-                return 'design-completeness-review';
-            case 'wait-for-pr-review':
-                return 'address-pr-feedback'; // PR feedback goes to address phase
-            case 'retrospective':
-                return 'retrospective'; // Retry retrospective if it fails
-            case 'address-pr-feedback':
-                return 'address-pr-feedback'; // Retry addressing feedback
-            default:
-                return 'design-design';
-        }
-    }
-    else if (workflowType === 'test') {
-        // Test workflow failure handling
-        switch (failedPhase) {
-            case 'test-test':
-                return 'test-test'; // Start over at test
-            case 'test-validate':
-                return 'test-test'; // Go back to fix tests
-            case 'submit-pr':
-                return 'test-validate';
-            case 'wait-for-pr-review':
-                return 'address-pr-feedback'; // PR feedback goes to address phase
-            case 'retrospective':
-                return 'retrospective'; // Retry retrospective if it fails
-            case 'address-pr-feedback':
-                return 'address-pr-feedback'; // Retry addressing feedback
-            default:
-                return 'test-test';
-        }
-    }
-    else if (workflowType === 'customer-development') {
-        // Customer development workflow failure handling
-        switch (failedPhase) {
-            case 'customer-profiling':
-                return 'customer-profiling'; // Start over at profiling
-            case 'platform-discovery':
-                return 'customer-profiling'; // Go back to refine customer profile
-            case 'prospect-qualification':
-                return 'platform-discovery'; // Go back to find more prospects
-            case 'inventory-compilation':
-                return 'prospect-qualification'; // Go back to improve qualification
-            default:
-                return 'customer-profiling';
-        }
-    }
-    else if (workflowType === 'user-survey') {
-        // User survey workflow failure handling
-        switch (failedPhase) {
-            case 'survey-scoping':
-                return 'survey-scoping';
-            case 'survey-build-linkedin':
-            case 'survey-build-reddit':
-            case 'survey-build-x':
-            case 'survey-build-facebook':
-            case 'survey-build-custom':
-                return 'survey-scoping'; // Go back to revise questions
-            case 'survey-dispatch':
-                return 'survey-build-linkedin'; // Go back to check builds
-            default:
-                return 'survey-scoping';
-        }
-    }
-    // Unknown workflow, return first phase of implement as fallback
-    return 'implement-scoping';
-}
-/**
- * Get all phases for a workflow type
- * @param workflowType - Type of workflow
- * @param issueType - Type of issue (only used for implement workflow)
- * @returns Array of phases
- */
-function getPhasesForWorkflow(workflowType, issueType) {
-    if (workflowType === 'implement') {
-        if (!issueType) {
-            throw new Error('Issue type is required for implement workflow');
-        }
-        return issueType === 'bug' ? [...BUG_PHASE_FLOW] : [...FEATURE_PHASE_FLOW];
-    }
-    else if (workflowType === 'spec') {
-        return [...SPEC_PHASE_FLOW];
-    }
-    else if (workflowType === 'design') {
-        return [...DESIGN_PHASE_FLOW];
-    }
-    else if (workflowType === 'test') {
-        return [...TEST_PHASE_FLOW];
-    }
-    else if (workflowType === 'customer-development') {
-        return [...CUSTOMER_DEVELOPMENT_PHASE_FLOW];
-    }
-    else if (workflowType === 'user-survey') {
-        return [...USER_SURVEY_PHASE_FLOW];
-    }
-    else {
-        throw new Error(`Unknown workflow type: ${workflowType}`);
-    }
-}
-// Legacy functions for backward compatibility
-function getNextPhaseForImplement(currentPhase, issueType) {
-    return getNextPhase(currentPhase, 'implement', issueType);
-}
-function isPhaseValidForIssueType(phase, issueType) {
-    return isPhaseValidForWorkflow(phase, 'implement', issueType);
-}
-function getPhasesForIssueType(issueType) {
-    return getPhasesForWorkflow('implement', issueType);
-}
-// Legacy function for backward compatibility
-function getPhaseOnImplementFailure(failedPhase, issueType) {
-    return getPhaseOnFailure(failedPhase, 'implement', issueType);
-}

package/dist/src/ai-manager/types.js

@@ -1,5 +0,0 @@
-"use strict";
-/**
- * Type definitions for AI Manager phase-based protocol
- */
-Object.defineProperty(exports, "__esModule", { value: true });