agentic-qe 1.9.3 → 2.0.0

package/dist/agents/QXPartnerAgent.js

@@ -0,0 +1,769 @@
+"use strict";
+/**
+ * QXPartnerAgent - Quality Experience (QX) Analysis Agent
+ *
+ * QX = Marriage between QA (Quality Advocacy) and UX (User Experience)
+ * Goal: Co-create Quality Experience for everyone associated with the product
+ *
+ * Based on: https://talesoftesting.com/quality-experienceqx-co-creating-quality-experience-for-everyone-associated-with-the-product/
+ *
+ * Key Capabilities:
+ * - Problem understanding and analysis (Rule of Three)
+ * - User needs vs Business needs analysis
+ * - Oracle problem detection and resolution
+ * - Comprehensive impact analysis (visible & invisible)
+ * - UX testing heuristics application
+ * - Integration with testability scoring
+ * - Contextual recommendations generation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QXPartnerAgent = void 0;
+const BaseAgent_1 = require("./BaseAgent");
+const types_1 = require("../types");
+const qx_1 = require("../types/qx");
+class ConsoleLogger {
+    info(message, ...args) {
+        console.log(`[INFO] ${message}`, ...args);
+    }
+    warn(message, ...args) {
+        console.warn(`[WARN] ${message}`, ...args);
+    }
+    error(message, ...args) {
+        console.error(`[ERROR] ${message}`, ...args);
+    }
+    debug(message, ...args) {
+        console.debug(`[DEBUG] ${message}`, ...args);
+    }
+}
+class QXPartnerAgent extends BaseAgent_1.BaseAgent {
+    constructor(config) {
+        const baseConfig = {
+            type: types_1.QEAgentType.QX_PARTNER,
+            capabilities: QXPartnerAgent.getDefaultCapabilities(),
+            context: config.context,
+            memoryStore: config.memoryStore,
+            eventBus: config.eventBus,
+            enableLearning: true // Enable learning for adaptive QX analysis
+        };
+        super(baseConfig);
+        this.logger = new ConsoleLogger();
+        this.config = {
+            analysisMode: config.analysisMode || 'full',
+            heuristics: config.heuristics || {
+                enabledHeuristics: Object.values(qx_1.QXHeuristic),
+                minConfidence: 0.7,
+                enableCompetitiveAnalysis: false
+            },
+            integrateTestability: config.integrateTestability ?? true,
+            testabilityScoringPath: config.testabilityScoringPath || '.claude/skills/testability-scoring',
+            detectOracleProblems: config.detectOracleProblems ?? true,
+            minOracleSeverity: config.minOracleSeverity || 'medium',
+            collaboration: config.collaboration || {
+                coordinateWithUX: true,
+                coordinateWithQA: true,
+                shareWithQualityAnalyzer: true
+            },
+            outputFormat: config.outputFormat || 'json',
+            thresholds: config.thresholds || {
+                minQXScore: 70,
+                minProblemClarity: 60,
+                minUserNeedsAlignment: 70,
+                minBusinessAlignment: 70
+            }
+        };
+    }
+    /**
+     * Get default capabilities for QX Partner Agent
+     */
+    static getDefaultCapabilities() {
+        return [
+            {
+                name: 'qx-analysis',
+                version: '1.0.0',
+                description: 'Comprehensive QX (Quality Experience) analysis combining QA and UX perspectives'
+            },
+            {
+                name: 'oracle-problem-detection',
+                version: '1.0.0',
+                description: 'Detect and resolve oracle problems when quality criteria are unclear'
+            },
+            {
+                name: 'ux-heuristics',
+                version: '1.0.0',
+                description: 'Apply UX testing heuristics for comprehensive analysis'
+            },
+            {
+                name: 'impact-analysis',
+                version: '1.0.0',
+                description: 'Analyze visible and invisible impacts of design changes'
+            },
+            {
+                name: 'balance-finder',
+                version: '1.0.0',
+                description: 'Find balance between user experience and business needs'
+            },
+            {
+                name: 'testability-integration',
+                version: '1.0.0',
+                description: 'Integrate with testability scoring for combined insights'
+            }
+        ];
+    }
+    /**
+     * Initialize QX analysis components
+     */
+    async initializeComponents() {
+        try {
+            this.logger.info(`QXPartnerAgent ${this.agentId.id} initializing components`);
+            // Initialize heuristics engine
+            this.heuristicsEngine = new QXHeuristicsEngine(this.config.heuristics);
+            this.logger.info('QX Heuristics Engine initialized');
+            // Initialize oracle problem detector
+            if (this.config.detectOracleProblems) {
+                this.oracleDetector = new OracleDetector(this.config.minOracleSeverity || 'medium');
+                this.logger.info('Oracle Problem Detector initialized');
+            }
+            // Initialize impact analyzer
+            this.impactAnalyzer = new ImpactAnalyzer();
+            this.logger.info('Impact Analyzer initialized');
+            // Validate testability scoring integration
+            if (this.config.integrateTestability) {
+                await this.validateTestabilityScoringAvailability();
+            }
+            // Setup collaboration channels
+            if (this.config.collaboration) {
+                await this.setupCollaborationChannels();
+            }
+            this.logger.info(`QXPartnerAgent ${this.agentId.id} components initialized successfully`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to initialize QXPartnerAgent components:`, error);
+            throw new Error(`Component initialization failed: ${error.message}`);
+        }
+    }
+    /**
+     * Load QX knowledge and historical patterns
+     */
+    async loadKnowledge() {
+        try {
+            this.logger.info('Loading QX knowledge base');
+            // Load historical QX analyses
+            const historicalQX = await this.retrieveSharedMemory(types_1.QEAgentType.QX_PARTNER, 'historical-qx-analyses');
+            if (historicalQX) {
+                this.logger.info('Loaded historical QX analyses');
+                await this.storeMemory('qx-history', historicalQX);
+            }
+            // Load oracle problem patterns
+            const oraclePatterns = await this.retrieveMemory('oracle-patterns');
+            if (oraclePatterns) {
+                this.logger.info('Loaded oracle problem patterns');
+            }
+            else {
+                await this.initializeDefaultOraclePatterns();
+            }
+            // Load UX heuristics knowledge
+            const heuristicsKnowledge = await this.retrieveMemory('heuristics-knowledge');
+            if (heuristicsKnowledge) {
+                this.logger.info('Loaded UX heuristics knowledge');
+            }
+            // Load collaboration insights from other agents
+            if (this.config.collaboration?.coordinateWithUX) {
+                const uxInsights = await this.retrieveSharedMemory(types_1.QEAgentType.VISUAL_TESTER, 'ux-insights');
+                if (uxInsights) {
+                    this.logger.info('Loaded UX agent insights');
+                }
+            }
+            if (this.config.collaboration?.coordinateWithQA) {
+                const qaInsights = await this.retrieveSharedMemory(types_1.QEAgentType.QUALITY_ANALYZER, 'qa-insights');
+                if (qaInsights) {
+                    this.logger.info('Loaded QA agent insights');
+                }
+            }
+            this.logger.info('QX knowledge loaded successfully');
+        }
+        catch (error) {
+            this.logger.warn(`Failed to load some QX knowledge:`, error);
+            // Continue with default knowledge
+        }
+    }
+    /**
+     * Clean up QX analysis resources
+     */
+    async cleanup() {
+        try {
+            this.logger.info(`QXPartnerAgent ${this.agentId.id} cleaning up resources`);
+            // Save current QX analysis state
+            await this.saveQXState();
+            // Store learned patterns
+            await this.saveOraclePatterns();
+            await this.saveHeuristicsInsights();
+            // Share insights with collaborating agents
+            if (this.config.collaboration) {
+                await this.shareCollaborationInsights();
+            }
+            this.logger.info(`QXPartnerAgent ${this.agentId.id} cleanup completed`);
+        }
+        catch (error) {
+            this.logger.error(`Error during QXPartnerAgent cleanup:`, error);
+            throw new Error(`Cleanup failed: ${error.message}`);
+        }
+    }
+    /**
+     * Perform QX analysis task
+     */
+    async performTask(task) {
+        const params = task.payload;
+        const taskType = params.type;
+        this.logger.info(`Performing QX task: ${taskType} for target: ${params.target}`);
+        switch (taskType) {
+            case qx_1.QXTaskType.FULL_ANALYSIS:
+                return await this.performFullQXAnalysis(params);
+            case qx_1.QXTaskType.ORACLE_DETECTION:
+                return await this.detectOracleProblems(params);
+            case qx_1.QXTaskType.BALANCE_ANALYSIS:
+                return await this.analyzeUserBusinessBalance(params);
+            case qx_1.QXTaskType.IMPACT_ANALYSIS:
+                return await this.performImpactAnalysis(params);
+            case qx_1.QXTaskType.APPLY_HEURISTIC:
+                return await this.applySpecificHeuristic(params);
+            case qx_1.QXTaskType.GENERATE_RECOMMENDATIONS:
+                return await this.generateQXRecommendations(params);
+            case qx_1.QXTaskType.INTEGRATE_TESTABILITY:
+                return await this.integrateTestabilityScoring(params);
+            default:
+                throw new Error(`Unsupported QX task type: ${taskType}`);
+        }
+    }
+    // ============================================================================
+    // QX Analysis Methods
+    // ============================================================================
+    /**
+     * Perform comprehensive QX analysis
+     */
+    async performFullQXAnalysis(params) {
+        const startTime = Date.now();
+        const target = params.target;
+        this.logger.info(`Starting full QX analysis for: ${target}`);
+        // 1. Collect context
+        const context = await this.collectQXContext(target, params.params?.context);
+        // 2. Analyze problem
+        const problemAnalysis = await this.analyzeProblem(context);
+        // 3. Analyze user needs
+        const userNeeds = await this.analyzeUserNeeds(context, problemAnalysis);
+        // 4. Analyze business needs
+        const businessNeeds = await this.analyzeBusinessNeeds(context, problemAnalysis);
+        // 5. Detect oracle problems
+        const oracleProblems = this.config.detectOracleProblems
+            ? await this.detectOracleProblemsFromContext(context, userNeeds, businessNeeds)
+            : [];
+        // 6. Perform impact analysis
+        const impactAnalysis = await this.analyzeImpact(context, problemAnalysis);
+        // 7. Apply heuristics
+        const heuristics = await this.applyAllHeuristics(context, problemAnalysis, userNeeds, businessNeeds);
+        // 8. Integrate testability (if enabled)
+        const testabilityIntegration = this.config.integrateTestability
+            ? await this.integrateTestabilityScoring(params)
+            : undefined;
+        // 9. Generate recommendations
+        const recommendations = await this.generateRecommendations(problemAnalysis, userNeeds, businessNeeds, oracleProblems, impactAnalysis, heuristics, testabilityIntegration);
+        // 10. Calculate overall score
+        const overallScore = this.calculateOverallQXScore(problemAnalysis, userNeeds, businessNeeds, impactAnalysis, heuristics);
+        const grade = this.scoreToGrade(overallScore);
+        const analysis = {
+            overallScore,
+            grade,
+            timestamp: new Date(),
+            target,
+            problemAnalysis,
+            userNeeds,
+            businessNeeds,
+            oracleProblems,
+            impactAnalysis,
+            heuristics,
+            recommendations,
+            testabilityIntegration,
+            context
+        };
+        // Store analysis in memory
+        await this.storeMemory(`qx-analysis:${target}`, analysis);
+        const duration = Date.now() - startTime;
+        this.logger.info(`QX analysis completed in ${duration}ms. Score: ${overallScore}/100 (${grade})`);
+        return analysis;
+    }
+    /**
+     * Collect QX context from target
+     */
+    async collectQXContext(target, additionalContext) {
+        this.logger.debug(`Collecting QX context for: ${target}`);
+        // In a real implementation, this would use Playwright or similar to analyze the target
+        // For now, we'll create a structure that can be filled by external tools
+        const context = {
+            url: target,
+            custom: additionalContext || {}
+        };
+        // Store context for later retrieval
+        await this.storeMemory(`qx-context:${target}`, context);
+        return context;
+    }
+    /**
+     * Analyze problem using Rule of Three and complexity assessment
+     */
+    async analyzeProblem(_context) {
+        this.logger.debug('Analyzing problem');
+        // In real implementation, this would use NLP and pattern matching
+        // For now, return a structure that can be populated by external analysis
+        const analysis = {
+            problemStatement: 'Problem analysis pending',
+            complexity: 'moderate',
+            breakdown: [],
+            potentialFailures: [],
+            clarityScore: 50
+        };
+        return analysis;
+    }
+    /**
+     * Analyze user needs
+     */
+    async analyzeUserNeeds(_context, _problemAnalysis) {
+        this.logger.debug('Analyzing user needs');
+        const analysis = {
+            needs: [],
+            suitability: 'adequate',
+            challenges: [],
+            alignmentScore: 70
+        };
+        return analysis;
+    }
+    /**
+     * Analyze business needs
+     */
+    async analyzeBusinessNeeds(_context, _problemAnalysis) {
+        this.logger.debug('Analyzing business needs');
+        const analysis = {
+            primaryGoal: 'balanced',
+            kpisAffected: [],
+            crossTeamImpact: [],
+            compromisesUX: false,
+            impactsKPIs: false,
+            alignmentScore: 70
+        };
+        return analysis;
+    }
+    /**
+     * Detect oracle problems from analysis context
+     */
+    async detectOracleProblemsFromContext(context, userNeeds, businessNeeds) {
+        if (!this.oracleDetector) {
+            return [];
+        }
+        return this.oracleDetector.detect(context, userNeeds, businessNeeds);
+    }
+    /**
+     * Perform impact analysis
+     */
+    async analyzeImpact(context, problemAnalysis) {
+        if (!this.impactAnalyzer) {
+            throw new Error('Impact analyzer not initialized');
+        }
+        return this.impactAnalyzer.analyze(context, problemAnalysis);
+    }
+    /**
+     * Apply all enabled heuristics
+     */
+    async applyAllHeuristics(context, problemAnalysis, userNeeds, businessNeeds) {
+        if (!this.heuristicsEngine) {
+            throw new Error('Heuristics engine not initialized');
+        }
+        return this.heuristicsEngine.applyAll(context, problemAnalysis, userNeeds, businessNeeds);
+    }
+    /**
+     * Generate QX recommendations
+     */
+    async generateRecommendations(problemAnalysis, userNeeds, businessNeeds, oracleProblems, impactAnalysis, heuristics, _testabilityIntegration) {
+        const recommendations = [];
+        // Generate recommendations from problem analysis
+        if (problemAnalysis.clarityScore < (this.config.thresholds?.minProblemClarity || 60)) {
+            recommendations.push({
+                principle: 'Problem Clarity',
+                recommendation: 'Improve problem statement clarity and breakdown',
+                severity: 'high',
+                impact: 100 - problemAnalysis.clarityScore,
+                effort: 'medium',
+                priority: 1,
+                category: 'qx'
+            });
+        }
+        // Generate recommendations from user needs
+        if (userNeeds.alignmentScore < (this.config.thresholds?.minUserNeedsAlignment || 70)) {
+            recommendations.push({
+                principle: 'User Needs Alignment',
+                recommendation: 'Better align solution with user needs',
+                severity: 'high',
+                impact: 100 - userNeeds.alignmentScore,
+                effort: 'high',
+                priority: 2,
+                category: 'ux'
+            });
+        }
+        // Generate recommendations from business needs
+        if (businessNeeds.alignmentScore < (this.config.thresholds?.minBusinessAlignment || 70)) {
+            recommendations.push({
+                principle: 'Business Alignment',
+                recommendation: 'Improve alignment with business objectives',
+                severity: 'medium',
+                impact: 100 - businessNeeds.alignmentScore,
+                effort: 'medium',
+                priority: 3,
+                category: 'qx'
+            });
+        }
+        // Generate recommendations from oracle problems
+        for (const problem of oracleProblems) {
+            if (problem.severity === 'high' || problem.severity === 'critical') {
+                recommendations.push({
+                    principle: 'Oracle Problem',
+                    recommendation: `Resolve: ${problem.description}`,
+                    severity: problem.severity,
+                    impact: 80,
+                    effort: 'high',
+                    priority: problem.severity === 'critical' ? 1 : 2,
+                    category: 'qa'
+                });
+            }
+        }
+        // Generate recommendations from heuristics
+        for (const heuristic of heuristics) {
+            for (const issue of heuristic.issues) {
+                if (issue.severity === 'high' || issue.severity === 'critical') {
+                    recommendations.push({
+                        principle: heuristic.name,
+                        recommendation: issue.description,
+                        severity: issue.severity,
+                        impact: 100 - heuristic.score,
+                        effort: 'medium',
+                        priority: 4,
+                        category: 'design'
+                    });
+                }
+            }
+        }
+        // Sort by priority and impact
+        recommendations.sort((a, b) => {
+            if (a.priority !== b.priority)
+                return a.priority - b.priority;
+            return b.impact - a.impact;
+        });
+        return recommendations;
+    }
+    /**
+     * Calculate overall QX score
+     */
+    calculateOverallQXScore(problemAnalysis, userNeeds, businessNeeds, impactAnalysis, heuristics) {
+        // Weighted average of all components
+        const weights = {
+            problem: 0.20,
+            userNeeds: 0.25,
+            businessNeeds: 0.20,
+            impact: 0.15,
+            heuristics: 0.20
+        };
+        const heuristicsAvg = heuristics.length > 0
+            ? heuristics.reduce((sum, h) => sum + h.score, 0) / heuristics.length
+            : 70;
+        const impactScore = Math.max(0, 100 - impactAnalysis.overallImpactScore);
+        const score = problemAnalysis.clarityScore * weights.problem +
+            userNeeds.alignmentScore * weights.userNeeds +
+            businessNeeds.alignmentScore * weights.businessNeeds +
+            impactScore * weights.impact +
+            heuristicsAvg * weights.heuristics;
+        return Math.round(score);
+    }
+    /**
+     * Convert score to grade
+     */
+    scoreToGrade(score) {
+        if (score >= 90)
+            return 'A';
+        if (score >= 80)
+            return 'B';
+        if (score >= 70)
+            return 'C';
+        if (score >= 60)
+            return 'D';
+        return 'F';
+    }
+    /**
+     * Detect oracle problems (separate task)
+     */
+    async detectOracleProblems(params) {
+        const context = await this.collectQXContext(params.target, params.params?.context);
+        const problemAnalysis = await this.analyzeProblem(context);
+        const userNeeds = await this.analyzeUserNeeds(context, problemAnalysis);
+        const businessNeeds = await this.analyzeBusinessNeeds(context, problemAnalysis);
+        return this.detectOracleProblemsFromContext(context, userNeeds, businessNeeds);
+    }
+    /**
+     * Analyze user vs business balance
+     */
+    async analyzeUserBusinessBalance(params) {
+        const context = await this.collectQXContext(params.target, params.params?.context);
+        const problemAnalysis = await this.analyzeProblem(context);
+        const userNeeds = await this.analyzeUserNeeds(context, problemAnalysis);
+        const businessNeeds = await this.analyzeBusinessNeeds(context, problemAnalysis);
+        return {
+            userNeeds,
+            businessNeeds,
+            balance: {
+                favorsUser: userNeeds.alignmentScore > businessNeeds.alignmentScore,
+                favorsBusiness: businessNeeds.alignmentScore > userNeeds.alignmentScore,
+                isBalanced: Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore) < 10,
+                recommendation: this.getBalanceRecommendation(userNeeds, businessNeeds)
+            }
+        };
+    }
+    getBalanceRecommendation(userNeeds, businessNeeds) {
+        const diff = userNeeds.alignmentScore - businessNeeds.alignmentScore;
+        if (Math.abs(diff) < 10) {
+            return 'Good balance between user and business needs';
+        }
+        else if (diff > 0) {
+            return 'Consider business objectives more to achieve better balance';
+        }
+        else {
+            return 'Consider user needs more to achieve better balance';
+        }
+    }
+    /**
+     * Perform impact analysis (separate task)
+     */
+    async performImpactAnalysis(params) {
+        const context = await this.collectQXContext(params.target, params.params?.context);
+        const problemAnalysis = await this.analyzeProblem(context);
+        return this.analyzeImpact(context, problemAnalysis);
+    }
+    /**
+     * Apply specific heuristic
+     */
+    async applySpecificHeuristic(params) {
+        if (!params.params?.heuristic) {
+            throw new Error('Heuristic parameter is required');
+        }
+        const context = await this.collectQXContext(params.target, params.params?.context);
+        const problemAnalysis = await this.analyzeProblem(context);
+        const userNeeds = await this.analyzeUserNeeds(context, problemAnalysis);
+        const businessNeeds = await this.analyzeBusinessNeeds(context, problemAnalysis);
+        if (!this.heuristicsEngine) {
+            throw new Error('Heuristics engine not initialized');
+        }
+        return this.heuristicsEngine.apply(params.params.heuristic, context, problemAnalysis, userNeeds, businessNeeds);
+    }
+    /**
+     * Generate QX recommendations (separate task)
+     */
+    async generateQXRecommendations(params) {
+        const analysis = await this.performFullQXAnalysis(params);
+        return analysis.recommendations;
+    }
+    /**
+     * Integrate with testability scoring
+     */
+    async integrateTestabilityScoring(_params) {
+        if (!this.config.integrateTestability) {
+            return undefined;
+        }
+        this.logger.debug('Integrating with testability scoring');
+        // In real implementation, this would invoke the testability-scoring skill
+        // For now, return a placeholder structure
+        const integration = {
+            qxRelation: [
+                'Testability affects QX through observability and controllability',
+                'High testability scores typically correlate with better QX scores'
+            ],
+            combinedInsights: [
+                'Consider testability principles in QX analysis',
+                'Low observability impacts both testing and user experience'
+            ]
+        };
+        return integration;
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    async validateTestabilityScoringAvailability() {
+        this.logger.debug('Validating testability scoring availability');
+        // In real implementation, check if the skill exists and is accessible
+    }
+    async setupCollaborationChannels() {
+        this.logger.debug('Setting up collaboration channels');
+        if (this.config.collaboration?.coordinateWithUX) {
+            this.logger.info('Collaboration with UX agents enabled');
+        }
+        if (this.config.collaboration?.coordinateWithQA) {
+            this.logger.info('Collaboration with QA agents enabled');
+        }
+    }
+    async initializeDefaultOraclePatterns() {
+        const defaultPatterns = {
+            patterns: [
+                'Revenue vs User Experience conflict',
+                'Technical constraints vs User expectations',
+                'Business deadlines vs Quality requirements'
+            ]
+        };
+        await this.storeMemory('oracle-patterns', defaultPatterns);
+    }
+    async saveQXState() {
+        // Save current state for future reference
+        const state = {
+            lastAnalysis: new Date(),
+            analysisCount: this.performanceMetrics.tasksCompleted
+        };
+        await this.storeMemory('qx-state', state);
+    }
+    async saveOraclePatterns() {
+        // Save learned oracle patterns
+        const patterns = await this.retrieveMemory('oracle-patterns');
+        if (patterns) {
+            await this.storeSharedMemory(types_1.QEAgentType.QX_PARTNER, 'oracle-patterns', patterns);
+        }
+    }
+    async saveHeuristicsInsights() {
+        // Save heuristics insights for other agents
+        const insights = await this.retrieveMemory('heuristics-knowledge');
+        if (insights) {
+            await this.storeSharedMemory(types_1.QEAgentType.QX_PARTNER, 'heuristics-insights', insights);
+        }
+    }
+    async shareCollaborationInsights() {
+        if (this.config.collaboration?.shareWithQualityAnalyzer) {
+            const qxInsights = await this.retrieveMemory('qx-state');
+            if (qxInsights) {
+                await this.storeSharedMemory(types_1.QEAgentType.QUALITY_ANALYZER, 'qx-insights', qxInsights);
+            }
+        }
+    }
+    async onPreInitialization() {
+        this.logger.info(`QXPartnerAgent initializing in ${this.config.analysisMode} mode`);
+    }
+    async onPostInitialization() {
+        this.logger.info(`QXPartnerAgent ready for QX analysis`);
+    }
+}
+exports.QXPartnerAgent = QXPartnerAgent;
+// ============================================================================
+// Helper Classes
+// ============================================================================
+/**
+ * QX Heuristics Engine
+ */
+class QXHeuristicsEngine {
+    constructor(config) {
+        this.config = config;
+    }
+    async applyAll(_context, _problemAnalysis, _userNeeds, _businessNeeds) {
+        const results = [];
+        for (const heuristic of this.config.enabledHeuristics) {
+            const result = await this.apply(heuristic, _context, _problemAnalysis, _userNeeds, _businessNeeds);
+            results.push(result);
+        }
+        return results;
+    }
+    async apply(heuristic, _context, _problemAnalysis, _userNeeds, _businessNeeds) {
+        // Simplified heuristic application
+        // In real implementation, each heuristic would have specific logic
+        return {
+            name: heuristic,
+            category: this.getHeuristicCategory(heuristic),
+            applied: true,
+            score: 75, // Placeholder
+            findings: [],
+            issues: [],
+            recommendations: []
+        };
+    }
+    getHeuristicCategory(heuristic) {
+        if (heuristic.includes('problem'))
+            return 'problem';
+        if (heuristic.includes('user'))
+            return 'user-needs';
+        if (heuristic.includes('business'))
+            return 'business-needs';
+        if (heuristic.includes('oracle') || heuristic.includes('balance'))
+            return 'balance';
+        if (heuristic.includes('impact'))
+            return 'impact';
+        if (heuristic.includes('competitive') || heuristic.includes('inspiration'))
+            return 'creativity';
+        return 'design';
+    }
+}
+/**
+ * Oracle Problem Detector
+ */
+class OracleDetector {
+    constructor(minSeverity) {
+        this.minSeverity = minSeverity;
+    }
+    detect(context, userNeeds, businessNeeds) {
+        const problems = [];
+        // Check for user vs business conflicts
+        if (Math.abs(userNeeds.alignmentScore - businessNeeds.alignmentScore) > 20) {
+            problems.push({
+                type: 'user-vs-business',
+                description: 'Significant gap between user needs and business objectives',
+                severity: 'high',
+                stakeholders: ['Users', 'Business'],
+                resolutionApproach: [
+                    'Gather supporting data from both perspectives',
+                    'Facilitate discussion between stakeholders',
+                    'Find compromise solutions that address both needs'
+                ]
+            });
+        }
+        // Check for missing information
+        if (userNeeds.challenges.length > 0 || businessNeeds.compromisesUX) {
+            problems.push({
+                type: 'unclear-criteria',
+                description: 'Quality criteria unclear due to conflicting information',
+                severity: 'medium',
+                missingInfo: userNeeds.challenges,
+                resolutionApproach: [
+                    'Collect missing information from stakeholders',
+                    'Define clear acceptance criteria'
+                ]
+            });
+        }
+        return problems.filter(p => this.meetsMinimumSeverity(p.severity));
+    }
+    meetsMinimumSeverity(severity) {
+        const severityLevels = ['low', 'medium', 'high', 'critical'];
+        const minIndex = severityLevels.indexOf(this.minSeverity);
+        const currentIndex = severityLevels.indexOf(severity);
+        return currentIndex >= minIndex;
+    }
+}
+/**
+ * Impact Analyzer
+ */
+class ImpactAnalyzer {
+    async analyze(_context, _problemAnalysis) {
+        // Simplified impact analysis
+        // In real implementation, this would perform deep analysis
+        return {
+            visible: {
+                guiFlow: {
+                    forEndUser: [],
+                    forInternalUser: []
+                },
+                userFeelings: []
+            },
+            invisible: {
+                performance: [],
+                security: []
+            },
+            immutableRequirements: [],
+            overallImpactScore: 30 // Lower is better
+        };
+    }
+}
+//# sourceMappingURL=QXPartnerAgent.js.map