wyrm-mcp 7.2.0 → 7.2.2

package/dist/auto-orchestrator.js

@@ -1,325 +1 @@
-/**
- * Wyrm Auto-Orchestrator - Automatically apply reasoning patterns
- *
- * This layer intercepts task requests and automatically applies
- * the best multi-agent reasoning pattern based on task classification.
- *
- * Patterns applied automatically:
- * - Haiku Boosting: All content generation via few-shot + self-critique
- * - Ensemble Voting: Decisions (architecture, design, strategy) via N approaches + vote
- * - Task Decomposition: Large features via subtasks + parallel execution
- * - Verification: High-risk code changes via multi-angle review
- *
- * @copyright 2026 Ghost Protocol (Pvt) Ltd.
- * @license AGPL-3.0-or-later — dual-licensed; commercial terms: ghosts.lk@proton.me. See LICENSE.
- */
-/**
- * Classify incoming task based on multiple signals
- */
-export function classifyTask(input, context) {
-    const text = input.toLowerCase();
-    let type = 'generation';
-    let confidence = 50;
-    let complexity = 'medium';
-    // Decision detection
-    const decisionKeywords = ['decide', 'choose', 'architecture', 'design pattern', 'approach', 'strategy', 'should we', 'which is better', 'trade-off', 'tradeoff'];
-    if (decisionKeywords.some(kw => text.includes(kw))) {
-        type = 'decision';
-        confidence = 85;
-        complexity = context?.complexity === 'high' ? 'high' : 'medium';
-    }
-    // Research detection
-    const researchKeywords = ['investigate', 'analyze', 'explore', 'research', 'what are the', 'find all', 'compare', 'benchmark'];
-    if (researchKeywords.some(kw => text.includes(kw))) {
-        type = 'research';
-        confidence = 80;
-        complexity = 'high';
-    }
-    // Verification detection
-    const verificationKeywords = ['review', 'check', 'validate', 'test', 'security', 'performance', 'audit', 'lint'];
-    if (verificationKeywords.some(kw => text.includes(kw))) {
-        type = 'verification';
-        confidence = 75;
-        complexity = 'medium';
-    }
-    // Decomposition detection (large feature builds)
-    const decompositionKeywords = ['build', 'implement', 'feature', 'system', 'module', 'create', 'develop', 'setup'];
-    const hasDetailedDescription = input.length > 500;
-    if (decompositionKeywords.some(kw => text.includes(kw)) && hasDetailedDescription) {
-        type = 'decomposition';
-        confidence = 70;
-        complexity = 'high';
-    }
-    // Generation (default, with boosting)
-    if (type === 'generation') {
-        confidence = 60; // Lower confidence for default catch-all
-        complexity = 'low';
-    }
-    // Adjust complexity based on input length
-    if (input.length > 1000)
-        complexity = 'high';
-    if (input.length < 200)
-        complexity = 'low';
-    const parallelBlocks = getParallelBlockCount(type, complexity);
-    return {
-        type,
-        confidence,
-        description: input.substring(0, 100) + (input.length > 100 ? '...' : ''),
-        complexity,
-        recommendedApproach: getRecommendedApproach(type),
-        parallelBlocks,
-    };
-}
-/**
- * Determine how many parallel agents to spawn
- */
-function getParallelBlockCount(type, complexity) {
-    const config = {
-        decision: { low: 2, medium: 3, high: 4 },
-        generation: { low: 1, medium: 2, high: 3 },
-        research: { low: 2, medium: 4, high: 6 },
-        verification: { low: 2, medium: 3, high: 4 },
-        decomposition: { low: 2, medium: 4, high: 6 },
-    };
-    return config[type][complexity] || 3;
-}
-/**
- * Get recommended orchestration approach
- */
-function getRecommendedApproach(type) {
-    const approaches = {
-        decision: 'ensemble-voting (4 approaches + vote)',
-        generation: 'haiku-boosting (few-shot + self-critique)',
-        research: 'parallel-research (N angles + synthesis)',
-        verification: 'verification-pipeline (security + perf + style reviews)',
-        decomposition: 'task-decomposition (subtasks + parallel + synthesis)',
-    };
-    return approaches[type];
-}
-/**
- * Default orchestration config
- */
-export function getDefaultConfig() {
-    return {
-        autoOrchestrateEnabled: true,
-        minConfidenceThreshold: 65, // Only apply if 65%+ confident
-        maxParallelAgents: 6,
-        defaultHaikuBoosting: true, // Boost all Haiku content generation
-        trackMetrics: true,
-        thinkingBudget: 10000, // Max thinking tokens per orchestrated task
-    };
-}
-/**
- * Apply appropriate orchestration pattern
- */
-export async function orchestrateTask(task, config = getDefaultConfig()) {
-    const classified = classifyTask(task);
-    // Check if confidence meets threshold
-    if (classified.confidence < config.minConfidenceThreshold) {
-        return {
-            taskType: classified.type,
-            approach: 'standard (below confidence threshold)',
-            results: null,
-            quality: 0,
-            costSavings: 0,
-            parallelExecutionTime: 0,
-            confidence: classified.confidence,
-            appliedPatterns: [],
-            metrics: { tokensBoosting: 0, tokensEnsemble: 0, tokensVerification: 0, totalTokens: 0 },
-        };
-    }
-    // Apply pattern based on task type
-    let patterns = [];
-    let startTime = Date.now();
-    switch (classified.type) {
-        case 'decision':
-            patterns = ['ensemble-voting', 'haiku-boosting'];
-            // Would spawn 4 approaches via parallel agents, vote, boost confidence
-            break;
-        case 'generation':
-            patterns = ['haiku-boosting', 'self-critique'];
-            // Add few-shot examples + self-critique loop
-            break;
-        case 'research':
-            patterns = ['parallel-research', 'synthesis'];
-            // Spawn parallel agents for different angles, synthesize findings
-            break;
-        case 'verification':
-            patterns = ['parallel-review', 'multi-angle'];
-            // Parallel: security review, performance check, style check → synthesize
-            break;
-        case 'decomposition':
-            patterns = ['task-decomposition', 'parallel-synthesis'];
-            // Break into subtasks, parallel execution, merge results
-            break;
-    }
-    const executionTime = Date.now() - startTime;
-    // Estimate quality and cost savings
-    const qualityBoost = getQualityBoost(patterns);
-    const costSavings = getCostSavings(patterns, classified.parallelBlocks);
-    return {
-        taskType: classified.type,
-        approach: classified.recommendedApproach,
-        results: null, // Would be filled by actual implementation
-        quality: 60 + qualityBoost,
-        costSavings,
-        parallelExecutionTime: executionTime,
-        confidence: classified.confidence,
-        appliedPatterns: patterns,
-        metrics: {
-            tokensBoosting: patterns.includes('haiku-boosting') ? 800 : 0,
-            tokensEnsemble: patterns.includes('ensemble-voting') ? 1200 : 0,
-            tokensVerification: patterns.includes('multi-angle') ? 600 : 0,
-            totalTokens: 0, // Would be calculated
-        },
-    };
-}
-/**
- * Quality boost from applied patterns (est. %)
- */
-function getQualityBoost(patterns) {
-    let boost = 0;
-    if (patterns.includes('haiku-boosting'))
-        boost += 45;
-    if (patterns.includes('ensemble-voting'))
-        boost += 35;
-    if (patterns.includes('self-critique'))
-        boost += 25;
-    if (patterns.includes('multi-angle'))
-        boost += 20;
-    return Math.min(boost, 80); // Cap at 80% boost
-}
-/**
- * Cost savings vs Opus (est. %)
- */
-function getCostSavings(patterns, parallelBlocks = 1) {
-    // Base: Haiku is 10x cheaper than Opus
-    // With patterns: Multiple Haiku calls (boosting + ensemble) still beat single Opus
-    // Typical: 4 Haiku ($0.48) vs 1 Opus ($1.00) = 52% savings
-    if (patterns.includes('ensemble-voting')) {
-        return parallelBlocks > 1 ? 45 : 30; // Multiple approaches still cheaper
-    }
-    if (patterns.includes('haiku-boosting')) {
-        return 35; // Boosting adds overhead but still cheaper than Opus
-    }
-    return 25; // Other patterns, general Haiku usage
-}
-/**
- * Orchestration middleware for agent context
- *
- * Usage in agent:
- * ```typescript
- * const config = getDefaultConfig();
- * const task = "Design a microservice architecture for a real-time collaboration tool";
- * const plan = await orchestrateTask(task, config);
- *
- * if (plan.appliedPatterns.length > 0) {
- *   // Auto-orchestration active
- *   // Implementation would:
- *   // 1. Spawn parallel agents (if ensemble/decomposition)
- *   // 2. Apply boosting (if generation)
- *   // 3. Run reviews (if verification)
- *   // 4. Synthesize results
- *   // 5. Store metrics in Wyrm
- * }
- * ```
- */
-export class AutoOrchestrator {
-    config;
-    taskHistory = [];
-    constructor(config) {
-        this.config = {
-            ...getDefaultConfig(),
-            ...config,
-        };
-    }
-    /**
-     * Process incoming task with auto-orchestration
-     */
-    async processTask(task) {
-        const classified = classifyTask(task);
-        this.taskHistory.push(classified);
-        // Trim history to last 100 tasks
-        if (this.taskHistory.length > 100) {
-            this.taskHistory = this.taskHistory.slice(-100);
-        }
-        return orchestrateTask(task, this.config);
-    }
-    /**
-     * Get task classification insight
-     */
-    getTaskDistribution() {
-        const dist = {
-            decision: 0,
-            generation: 0,
-            research: 0,
-            verification: 0,
-            decomposition: 0,
-        };
-        for (const task of this.taskHistory) {
-            dist[task.type]++;
-        }
-        return dist;
-    }
-    /**
-     * Get orchestration effectiveness stats
-     */
-    getStats() {
-        const distribution = this.getTaskDistribution();
-        const total = this.taskHistory.length;
-        const avgQuality = this.taskHistory.reduce((sum, t) => {
-            const patterns = this.getPatternSetForType(t.type);
-            return sum + getQualityBoost(patterns);
-        }, 0) / (total || 1);
-        const avgCost = this.taskHistory.reduce((sum, t) => {
-            return sum + getCostSavings(this.getPatternSetForType(t.type), t.complexity === 'high' ? 4 : 2);
-        }, 0) / (total || 1);
-        const complexities = this.taskHistory.map(t => t.complexity);
-        const avgComplexity = complexities.filter(c => c === 'high').length > total / 2
-            ? 'high'
-            : complexities.filter(c => c === 'low').length > total / 2
-                ? 'low'
-                : 'medium';
-        return {
-            tasksProcessed: total,
-            distribution,
-            estimatedQualityBoost: Math.round(avgQuality),
-            estimatedCostSavings: Math.round(avgCost),
-            averageComplexity: avgComplexity,
-        };
-    }
-    /**
-     * Get pattern set for task type
-     */
-    getPatternSetForType(type) {
-        const patterns = {
-            decision: ['ensemble-voting', 'haiku-boosting'],
-            generation: ['haiku-boosting', 'self-critique'],
-            research: ['parallel-research', 'synthesis'],
-            verification: ['parallel-review', 'multi-angle'],
-            decomposition: ['task-decomposition', 'parallel-synthesis'],
-        };
-        return patterns[type];
-    }
-    /**
-     * Update config at runtime
-     */
-    updateConfig(updates) {
-        this.config = { ...this.config, ...updates };
-    }
-}
-/**
- * Singleton instance for global orchestration
- */
-let globalOrchestrator = null;
-export function getGlobalOrchestrator() {
-    if (!globalOrchestrator) {
-        globalOrchestrator = new AutoOrchestrator(getDefaultConfig());
-    }
-    return globalOrchestrator;
-}
-export function initializeOrchestrator(config) {
-    globalOrchestrator = new AutoOrchestrator(config);
-    return globalOrchestrator;
-}
-//# sourceMappingURL=auto-orchestrator.js.map
+function g(i,e){const t=i.toLowerCase();let s="generation",r=50,o="medium";["decide","choose","architecture","design pattern","approach","strategy","should we","which is better","trade-off","tradeoff"].some(a=>t.includes(a))&&(s="decision",r=85,o=e?.complexity==="high"?"high":"medium"),["investigate","analyze","explore","research","what are the","find all","compare","benchmark"].some(a=>t.includes(a))&&(s="research",r=80,o="high"),["review","check","validate","test","security","performance","audit","lint"].some(a=>t.includes(a))&&(s="verification",r=75,o="medium");const u=["build","implement","feature","system","module","create","develop","setup"],y=i.length>500;u.some(a=>t.includes(a))&&y&&(s="decomposition",r=70,o="high"),s==="generation"&&(r=60,o="low"),i.length>1e3&&(o="high"),i.length<200&&(o="low");const k=b(s,o);return{type:s,confidence:r,description:i.substring(0,100)+(i.length>100?"...":""),complexity:o,recommendedApproach:v(s),parallelBlocks:k}}function b(i,e){return{decision:{low:2,medium:3,high:4},generation:{low:1,medium:2,high:3},research:{low:2,medium:4,high:6},verification:{low:2,medium:3,high:4},decomposition:{low:2,medium:4,high:6}}[i][e]||3}function v(i){return{decision:"ensemble-voting (4 approaches + vote)",generation:"haiku-boosting (few-shot + self-critique)",research:"parallel-research (N angles + synthesis)",verification:"verification-pipeline (security + perf + style reviews)",decomposition:"task-decomposition (subtasks + parallel + synthesis)"}[i]}function d(){return{autoOrchestrateEnabled:!0,minConfidenceThreshold:65,maxParallelAgents:6,defaultHaikuBoosting:!0,trackMetrics:!0,thinkingBudget:1e4}}async function w(i,e=d()){const t=g(i);if(t.confidence<e.minConfidenceThreshold)return{taskType:t.type,approach:"standard (below confidence threshold)",results:null,quality:0,costSavings:0,parallelExecutionTime:0,confidence:t.confidence,appliedPatterns:[],metrics:{tokensBoosting:0,tokensEnsemble:0,tokensVerification:0,totalTokens:0}};let s=[],r=Date.now();switch(t.type){case"decision":s=["ensemble-voting","haiku-boosting"];break;case"generation":s=["haiku-boosting","self-critique"];break;case"research":s=["parallel-research","synthesis"];break;case"verification":s=["parallel-review","multi-angle"];break;case"decomposition":s=["task-decomposition","parallel-synthesis"];break}const o=Date.now()-r,h=p(s),n=m(s,t.parallelBlocks);return{taskType:t.type,approach:t.recommendedApproach,results:null,quality:60+h,costSavings:n,parallelExecutionTime:o,confidence:t.confidence,appliedPatterns:s,metrics:{tokensBoosting:s.includes("haiku-boosting")?800:0,tokensEnsemble:s.includes("ensemble-voting")?1200:0,tokensVerification:s.includes("multi-angle")?600:0,totalTokens:0}}}function p(i){let e=0;return i.includes("haiku-boosting")&&(e+=45),i.includes("ensemble-voting")&&(e+=35),i.includes("self-critique")&&(e+=25),i.includes("multi-angle")&&(e+=20),Math.min(e,80)}function m(i,e=1){return i.includes("ensemble-voting")?e>1?45:30:i.includes("haiku-boosting")?35:25}class f{config;taskHistory=[];constructor(e){this.config={...d(),...e}}async processTask(e){const t=g(e);return this.taskHistory.push(t),this.taskHistory.length>100&&(this.taskHistory=this.taskHistory.slice(-100)),w(e,this.config)}getTaskDistribution(){const e={decision:0,generation:0,research:0,verification:0,decomposition:0};for(const t of this.taskHistory)e[t.type]++;return e}getStats(){const e=this.getTaskDistribution(),t=this.taskHistory.length,s=this.taskHistory.reduce((n,c)=>{const u=this.getPatternSetForType(c.type);return n+p(u)},0)/(t||1),r=this.taskHistory.reduce((n,c)=>n+m(this.getPatternSetForType(c.type),c.complexity==="high"?4:2),0)/(t||1),o=this.taskHistory.map(n=>n.complexity),h=o.filter(n=>n==="high").length>t/2?"high":o.filter(n=>n==="low").length>t/2?"low":"medium";return{tasksProcessed:t,distribution:e,estimatedQualityBoost:Math.round(s),estimatedCostSavings:Math.round(r),averageComplexity:h}}getPatternSetForType(e){return{decision:["ensemble-voting","haiku-boosting"],generation:["haiku-boosting","self-critique"],research:["parallel-research","synthesis"],verification:["parallel-review","multi-angle"],decomposition:["task-decomposition","parallel-synthesis"]}[e]}updateConfig(e){this.config={...this.config,...e}}}let l=null;function x(){return l||(l=new f(d())),l}function T(i){return l=new f(i),l}export{f as AutoOrchestrator,g as classifyTask,d as getDefaultConfig,x as getGlobalOrchestrator,T as initializeOrchestrator,w as orchestrateTask};