fraim-framework 2.0.56 → 2.0.58

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

@@ -1,480 +0,0 @@
-"use strict";
-/**
- * AI Coach - Provides guidance and coaching for implementation phases
- *
- * Handles coaching requests from agents, provides phase instructions,
- * completion messages, and help when agents encounter challenges.
- */
-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.AICoach = void 0;
-const fs_1 = require("fs");
-const phase_flow_js_1 = require("./phase-flow.js");
-class AICoach {
-    constructor(fileIndex) {
-        this.fileIndex = fileIndex;
-    }
-    /**
-     * Handle coaching request from agent
-     */
-    async handleCoachingRequest(args) {
-        console.log(`🤖 AI Coach: Providing guidance for ${args.workflowType} workflow, phase: ${args.currentPhase}, status: ${args.status}`);
-        // Validate required parameters
-        const requiredParams = ['workflowType', 'currentPhase', 'status'];
-        const missingParams = requiredParams.filter(param => !args[param]);
-        if (missingParams.length > 0) {
-            console.log(`❌ AI Coach: Missing required parameters: ${missingParams.join(', ')}`);
-            throw new Error(`Missing required parameters: ${missingParams.join(', ')}`);
-        }
-        // Handle missing or empty issue number gracefully
-        if (!args.issueNumber || args.issueNumber.trim() === '') {
-            return `⚠️ **Issue Number Missing**
-
-Please provide a valid issue number to get specific guidance for your workflow.
-
-**Current Request:**
-- Workflow: ${args.workflowType}
-- Phase: ${args.currentPhase}
-- Status: ${args.status}
-
-**Next Steps:**
-1. Identify the GitHub issue number you're working on
-2. Include the issue number in your coaching request
-3. Re-request guidance with complete information
-
-Example: \`seekCoachingOnNextStep({ workflowType: "${args.workflowType}", issueNumber: "123", currentPhase: "${args.currentPhase}", status: "${args.status}" })\``;
-        }
-        // Validate workflow type
-        const validWorkflowTypes = ['implement', 'spec', 'design', 'test', 'customer-development', 'user-survey'];
-        if (!validWorkflowTypes.includes(args.workflowType)) {
-            console.log(`❌ AI Coach: Invalid workflow type: ${args.workflowType}`);
-            throw new Error(`Invalid workflow type: ${args.workflowType}. Valid types: ${validWorkflowTypes.join(', ')}`);
-        }
-        // Validate phase for workflow type
-        const issueType = this.extractIssueType(args.findings, args.evidence);
-        console.log(`🔍 AI Coach: Extracted issue type: ${issueType}`);
-        if (!(0, phase_flow_js_1.isPhaseValidForWorkflow)(args.currentPhase, args.workflowType, issueType)) {
-            // Special handling for implement workflow to provide better error messages
-            if (args.workflowType === 'implement') {
-                const hasIssueType = args.findings?.issueType || args.evidence?.issueType;
-                if (!hasIssueType) {
-                    throw new Error(`❌ Missing Required Field: issueType
-
-For implement workflow, you MUST specify issueType in your findings object:
-
-**Correct format:**
-\`\`\`javascript
-seekCoachingOnNextStep({
-  workflowType: "implement",
-  issueNumber: "${args.issueNumber}",
-  currentPhase: "${args.currentPhase}",
-  status: "${args.status}",
-  findings: {
-    issueType: "bug" // or "feature" - REQUIRED!
-  },
-  evidence: {
-    // your evidence here
-  }
-})
-\`\`\`
-
-**Valid phases by issue type:**
-- **Bugs**: implement-scoping → implement-repro → implement-code → implement-validate → implement-smoke → implement-regression → implement-completeness-review → submit-pr → wait-for-pr-review
-- **Features**: implement-scoping → implement-spike → implement-code → implement-validate → implement-smoke → implement-regression → implement-completeness-review → submit-pr → wait-for-pr-review`);
-                }
-                else {
-                    throw new Error(`❌ Invalid Phase for Issue Type
-
-Phase "${args.currentPhase}" is not valid for ${issueType} issues.
-
-**Valid phases for ${issueType}s:**
-${this.getValidPhasesForIssueType(issueType).join(' → ')}
-
-**Your current request:**
-- Workflow: ${args.workflowType}
-- Issue Type: ${issueType}
-- Phase: ${args.currentPhase} ❌
-
-**Suggestion:** Use the correct phase name from the valid flow above.`);
-                }
-            }
-            else {
-                throw new Error(`Invalid phase "${args.currentPhase}" for workflow type "${args.workflowType}"`);
-            }
-        }
-        if (args.status === 'complete') {
-            console.log(`✅ AI Coach: Generating completion message`);
-            return await this.generateCompletionMessage(args);
-        }
-        else if (args.status === 'incomplete') {
-            console.log(`🤝 AI Coach: Generating help message`);
-            return await this.generateHelpMessage(args);
-        }
-        else if (args.status === 'failure') {
-            console.log(`❌ AI Coach: Generating failure message`);
-            return await this.generateFailureMessage(args);
-        }
-        else {
-            console.log(`📖 AI Coach: Getting phase instructions for ${args.currentPhase}`);
-            return await this.getPhaseInstructions(args.currentPhase, args.workflowType);
-        }
-    }
-    /**
-     * Generate completion message for completed phases
-     */
-    async generateCompletionMessage(args) {
-        // Determine next phase and provide its instructions
-        const issueType = this.extractIssueType(args.findings, args.evidence);
-        const nextPhase = (0, phase_flow_js_1.getNextPhase)(args.currentPhase, args.workflowType, issueType);
-        if (!nextPhase) {
-            // This is the final phase - show completion message
-            return `# 🎉 ${args.workflowType.charAt(0).toUpperCase() + args.workflowType.slice(1)} Complete!
-
-**Congratulations!** You have successfully completed all ${args.workflowType} phases for issue #${args.issueNumber}.
-
-## 🏆 What You've Accomplished
-${this.getAccomplishmentsForWorkflow(args.workflowType)}
-
-## 📋 Final Evidence Summary
-${JSON.stringify(args.evidence || args.findings || {}, null, 2)}
-
-`;
-        }
-        else {
-            // Get instructions for the next phase
-            const nextPhaseInstructions = await this.getPhaseInstructions(nextPhase, args.workflowType);
-            return `# 🎉 Phase Complete!
-
-**Phase:** ${args.currentPhase}
-**Status:** Complete
-
-Great work! You've completed the ${args.currentPhase} phase.
-
-## Evidence Summary
-${JSON.stringify(args.evidence || args.findings || {}, null, 2)}
-
-## 🚀 Next Phase: ${nextPhase}
-
-Here are the instructions for your next phase:
-
----
-
-${nextPhaseInstructions}
-`;
-        }
-    }
-    /**
-     * Get accomplishments list for a workflow type
-     */
-    getAccomplishmentsForWorkflow(workflowType) {
-        switch (workflowType) {
-            case 'implement':
-                return `- ✅ **Scoping**: Understood requirements and issue type
-- ✅ **Repro/Spike**: Created reproduction test or validated technical approach
-- ✅ **Implementation**: Built working solution with comprehensive tests
-- ✅ **Validation**: Verified functionality through manual and automated testing
-- ✅ **Smoke Tests**: Confirmed technical health (build, tests, git status)
-- ✅ **Regression Tests**: Ensured bug fixes work or features have proper test coverage
-- ✅ **Completeness Review**: Verified all design aspects implemented
-- ✅ **Submit PR**: Prepared work for human review
-- ✅ **PR Review**: Successfully completed code review process`;
-            case 'spec':
-                return `- ✅ **Specification**: Created comprehensive feature specification
-- ✅ **Validation**: Verified spec completeness and quality
-- ✅ **Submit PR**: Prepared specification for review
-- ✅ **PR Review**: Successfully completed specification review process`;
-            case 'design':
-                return `- ✅ **Design**: Created technical design and architecture
-- ✅ **Validation**: Verified design completeness and feasibility
-- ✅ **Submit PR**: Prepared design for implementation phase
-- ✅ **PR Review**: Successfully completed design review process`;
-            case 'test':
-                return `- ✅ **Testing**: Created comprehensive test suite
-- ✅ **Validation**: Verified test coverage and quality
-- ✅ **Submit PR**: Prepared tests for integration
-- ✅ **PR Review**: Successfully completed test review process`;
-            case 'user-survey':
-                return `- ✅ **Scoping**: Defined research goals and target audience
-- ✅ **LinkedIn Build**: Generated professional LinkedIn survey content
-- ✅ **Reddit Build**: Targeted relevant communities with specific copy
-- ✅ **X/Twitter Build**: Created high-engagement short-form content
-- ✅ **Facebook Build**: Formulated community-focused content
-- ✅ **Custom Platforms**: Addressed supplementary platform needs
-- ✅ **Dispatch**: Successfully executed survey distribution via automation`;
-            default:
-                return `- ✅ **${workflowType}**: Completed all phases successfully
-- ✅ **Validation**: Verified work quality and completeness
-- ✅ **Submit PR**: Prepared work for review
-- ✅ **PR Review**: Successfully completed review process`;
-        }
-    }
-    /**
-     * Get valid phases for a specific issue type
-     */
-    getValidPhasesForIssueType(issueType) {
-        if (issueType === 'bug') {
-            return ['implement-scoping', 'implement-repro', 'implement-code', 'implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
-        }
-        else {
-            return ['implement-scoping', 'implement-spike', 'implement-code', 'implement-validate', 'implement-smoke', 'implement-regression', 'implement-completeness-review', 'submit-pr', 'wait-for-pr-review'];
-        }
-    }
-    /**
-     * Extract issue type from findings or evidence
-     */
-    extractIssueType(findings, evidence) {
-        // Try to get issue type from findings first
-        if (findings?.issueType) {
-            return findings.issueType;
-        }
-        // Try to get from evidence
-        if (evidence?.issueType) {
-            return evidence.issueType;
-        }
-        // Default to feature if not specified
-        return 'feature';
-    }
-    /**
-     * Generate failure message for failed phases
-     */
-    async generateFailureMessage(args) {
-        // Standard failure handling for all phases
-        const issueType = this.extractIssueType(args.findings);
-        const { getPhaseOnFailure } = await Promise.resolve().then(() => __importStar(require('./phase-flow.js')));
-        const nextPhase = getPhaseOnFailure(args.currentPhase, args.workflowType, issueType);
-        const nextPhaseInstructions = await this.getPhaseInstructions(nextPhase, args.workflowType);
-        return `# ❌ Phase Failed
-
-**Workflow:** ${args.workflowType}
-**Failed Phase:** ${args.currentPhase}
-**Issue:** ${args.issueNumber}
-
-## Failure Details
-${args.findings ? JSON.stringify(args.findings, null, 2) : 'No specific failure details provided'}
-
-## 🚀 Next Phase: ${nextPhase}
-
-You'll now return to the **${nextPhase}** phase to address the issues.
-
----
-
-${nextPhaseInstructions}
-
----
-
-## Action Plan
-1. **Review the failure details above**
-2. **Follow the ${nextPhase} phase instructions**
-3. **Address the root cause of the failure**
-4. **Continue through the workflow**
-`;
-    }
-    /**
-     * Generate help message for incomplete phases
-     */
-    async generateHelpMessage(args) {
-        // Standard help message for all phases
-        const phaseInstructions = await this.getPhaseInstructions(args.currentPhase, args.workflowType);
-        return `# 🤝 AI Coach Assistance
-
-**Workflow:** ${args.workflowType}
-**Phase:** ${args.currentPhase}
-**Status:** Incomplete - Need Help
-
-I understand you're encountering challenges with the ${args.currentPhase} phase. Let me provide you with the complete guidance for this phase.
-
-## Issues You Mentioned
-${args.findings?.uncertainties && Array.isArray(args.findings.uncertainties) ?
-            args.findings.uncertainties.map((issue) => `- ${issue}`).join('\n') :
-            'No specific issues mentioned'}
-
-## Complete Phase Guidance
-Here are the complete instructions for the ${args.currentPhase} phase:
-
----
-
-${phaseInstructions}
-
----
-
-## Next Steps
-1. Review the complete phase guidance above
-2. Address the specific issues you mentioned
-3. Follow the phase workflow step by step
-4. When ready, call seekCoachingOnNextStep again with status "complete"
-
-Remember: Take your time and follow each step carefully. The phase guidance contains everything you need to succeed.
-`;
-    }
-    /**
-     * Get phase instructions from .md files
-     */
-    async getPhaseInstructions(phase, workflowType) {
-        try {
-            // Special handling for shared phases
-            const sharedPhases = ['retrospective', 'submit-pr', 'wait-for-pr-review', 'address-pr-feedback'];
-            let phasePath;
-            if (sharedPhases.includes(phase)) {
-                // Check if it's in root ai-manager-rules directory (like retrospective)
-                if (phase === 'retrospective') {
-                    phasePath = `ai-manager-rules/${phase}.md`;
-                }
-                else {
-                    // Other shared phases are in shared-phases subdirectory
-                    phasePath = `ai-manager-rules/shared-phases/${phase}.md`;
-                }
-            }
-            else if (workflowType === 'implement') {
-                phasePath = `ai-manager-rules/implement-phases/${phase}.md`;
-            }
-            else if (workflowType === 'customer-development') {
-                // Map phase names to file names
-                const phaseFileMap = {
-                    'customer-profiling': 'phase1-customer-profiling.md',
-                    'platform-discovery': 'phase2-platform-discovery.md',
-                    'prospect-qualification': 'phase3-prospect-qualification.md',
-                    'inventory-compilation': 'phase4-inventory-compilation.md'
-                };
-                const fileName = phaseFileMap[phase];
-                if (fileName) {
-                    phasePath = `ai-manager-rules/customer-development-phases/${fileName}`;
-                }
-                else {
-                    phasePath = `ai-manager-rules/customer-development-phases/${phase}.md`;
-                }
-            }
-            else if (workflowType === 'user-survey') {
-                const phaseFileMap = {
-                    'survey-scoping': 'phase1-survey-scoping.md',
-                    'survey-build-linkedin': 'phase2-survey-build-linkedin.md',
-                    'survey-build-reddit': 'phase3-survey-build-reddit.md',
-                    'survey-build-x': 'phase4-survey-build-x.md',
-                    'survey-build-facebook': 'phase5-survey-build-facebook.md',
-                    'survey-build-custom': 'phase6-survey-build-custom.md',
-                    'survey-dispatch': 'phase7-survey-dispatch.md'
-                };
-                const fileName = phaseFileMap[phase];
-                if (fileName) {
-                    phasePath = `ai-manager-rules/user-survey-phases/${fileName}`;
-                }
-                else {
-                    phasePath = `ai-manager-rules/user-survey-phases/${phase}.md`;
-                }
-            }
-            else {
-                phasePath = `ai-manager-rules/${workflowType}-phases/${phase}.md`;
-            }
-            // Try to get from file index first
-            let phaseFile = this.fileIndex.get(phasePath);
-            if (phaseFile && (0, fs_1.existsSync)(phaseFile.fullPath)) {
-                return (0, fs_1.readFileSync)(phaseFile.fullPath, 'utf8');
-            }
-            // If not found and not a shared phase, try shared-phases directory
-            if (!sharedPhases.includes(phase)) {
-                const sharedPhasePath = `ai-manager-rules/shared-phases/${phase}.md`;
-                phaseFile = this.fileIndex.get(sharedPhasePath);
-                if (phaseFile && (0, fs_1.existsSync)(phaseFile.fullPath)) {
-                    return (0, fs_1.readFileSync)(phaseFile.fullPath, 'utf8');
-                }
-            }
-            // Fallback: try to read directly from filesystem
-            const { join } = require('path');
-            const possiblePaths = [];
-            if (sharedPhases.includes(phase)) {
-                if (phase === 'retrospective') {
-                    // Retrospective is in root ai-manager-rules directory
-                    possiblePaths.push(join(process.cwd(), 'dist', 'registry', `ai-manager-rules/${phase}.md`), join(process.cwd(), 'registry', `ai-manager-rules/${phase}.md`), join(__dirname, '..', '..', 'registry', `ai-manager-rules/${phase}.md`), join(__dirname, '..', 'registry', `ai-manager-rules/${phase}.md`));
-                }
-                else {
-                    // Other shared phases are in shared-phases subdirectory
-                    const sharedPhasePath = `ai-manager-rules/shared-phases/${phase}.md`;
-                    possiblePaths.push(join(process.cwd(), 'dist', 'registry', sharedPhasePath), join(process.cwd(), 'registry', sharedPhasePath), join(__dirname, '..', '..', 'registry', sharedPhasePath), join(__dirname, '..', 'registry', sharedPhasePath));
-                }
-            }
-            else {
-                // For workflow-specific phases
-                possiblePaths.push(join(process.cwd(), 'dist', 'registry', phasePath), join(process.cwd(), 'registry', phasePath), join(__dirname, '..', '..', 'registry', phasePath), join(__dirname, '..', 'registry', phasePath));
-                // Also try shared-phases directory
-                const sharedPhasePath = `ai-manager-rules/shared-phases/${phase}.md`;
-                possiblePaths.push(join(process.cwd(), 'dist', 'registry', sharedPhasePath), join(process.cwd(), 'registry', sharedPhasePath), join(__dirname, '..', '..', 'registry', sharedPhasePath), join(__dirname, '..', 'registry', sharedPhasePath));
-            }
-            for (const fullPath of possiblePaths) {
-                if ((0, fs_1.existsSync)(fullPath)) {
-                    console.log(`📖 AI Coach: Reading phase file from ${fullPath}`);
-                    return (0, fs_1.readFileSync)(fullPath, 'utf8');
-                }
-            }
-            return `# Phase: ${phase}
-
-**Error**: Phase instructions not found
-
-Tried paths:
-${possiblePaths.map(p => `- ${p}`).join('\n')}
-
-Please check that the phase name is correct and the phase file exists.
-
-Available phases for ${workflowType} workflow: ${this.getAvailablePhasesForWorkflow(workflowType)}
-`;
-        }
-        catch (error) {
-            return `# Phase: ${phase}
-
-**Error**: Failed to load phase instructions: ${error instanceof Error ? error.message : 'Unknown error'}
-`;
-        }
-    }
-    /**
-     * Get available phases for a workflow type
-     */
-    getAvailablePhasesForWorkflow(workflowType) {
-        switch (workflowType) {
-            case 'implement':
-                return 'implement-scoping, implement-repro, implement-spike, implement-code, implement-validate, implement-smoke, implement-regression, implement-completeness-review, submit-pr, wait-for-pr-review';
-            case 'spec':
-                return 'spec-spec, spec-completeness-review, submit-pr, wait-for-pr-review';
-            case 'design':
-                return 'design-design, design-completeness-review, submit-pr, wait-for-pr-review';
-            case 'test':
-                return 'test-test, test-validate, submit-pr, wait-for-pr-review';
-            case 'customer-development':
-                return 'customer-profiling, platform-discovery, prospect-qualification, inventory-compilation';
-            case 'user-survey':
-                return 'survey-scoping, survey-build-linkedin, survey-build-reddit, survey-build-x, survey-build-facebook, survey-build-custom, survey-dispatch';
-            default:
-                return 'unknown';
-        }
-    }
-}
-exports.AICoach = AICoach;