@gotza02/sequential-thinking 10000.2.1 → 10000.2.2

package/dist/lib.js

@@ -1,10 +1,11 @@
-import chalk from 'chalk';
 import * as fs from 'fs/promises';
 import { existsSync, readFileSync } from 'fs';
 import * as path from 'path';
 import { AsyncMutex } from './utils.js';
 import { ContextManager } from './core/ContextManager.js';
 import { RuleManager } from './core/RuleManager.js';
+import { formatThought, generateMermaid } from './lib/formatters.js';
+import { detectLoopsAndStalling, validateSolution, checkAntiInsanity, checkConfidenceCritical, calculateConfidenceScore } from './lib/validators.js';
 export class SequentialThinkingServer {
     thoughtHistory = [];
     blocks = [];
@@ -390,79 +391,7 @@ export class SequentialThinkingServer {
         }
     }
     formatThought(thoughtData) {
-        const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId, thoughtType, score, options, selectedOption, blockId, relatedToolCall, complexity } = thoughtData;
-        const typeEmoji = {
-            'analysis': '🔍',
-            'planning': '📋',
-            'critique': '😈',
-            'execution': '⚡',
-            'observation': '👁️',
-            'hypothesis': '💡',
-            'reflexion': '🔄',
-            'solution': '✅',
-            'generation': '💭',
-            'evaluation': '⚖️',
-            'selection': '🎯'
-        };
-        let prefix = '';
-        let context = '';
-        const type = thoughtType || 'analysis';
-        const emoji = typeEmoji[type] || '💭';
-        if (type === 'reflexion' || isRevision) {
-            prefix = chalk.yellow(`${emoji} Reflexion`);
-            if (revisesThought)
-                context += ` (revising #${revisesThought})`;
-        }
-        else if (type === 'critique') {
-            prefix = chalk.redBright(`${emoji} Critique`);
-        }
-        else if (type === 'execution') {
-            prefix = chalk.magenta(`${emoji} Execution`);
-            if (relatedToolCall)
-                context += ` [Tool: ${relatedToolCall}]`;
-        }
-        else if (type === 'observation') {
-            prefix = chalk.cyan(`${emoji} Observation`);
-        }
-        else if (type === 'planning') {
-            prefix = chalk.blue(`${emoji} Planning`);
-        }
-        else if (type === 'solution') {
-            prefix = chalk.green(`${emoji} Solution`);
-        }
-        else if (branchFromThought) {
-            prefix = chalk.green(`🌿 Branch`);
-            context = ` (from #${branchFromThought}, ID: ${branchId})`;
-        }
-        else {
-            prefix = chalk.blue(`${emoji} ${type.charAt(0).toUpperCase() + type.slice(1)}`);
-        }
-        if (blockId && blockId !== 'default' && blockId !== 'legacy-default') {
-            context += ` [Block: ${blockId}]`;
-        }
-        if (complexity)
-            context += ` [${complexity.toUpperCase()}]`;
-        if (score)
-            context += ` (Score: ${score})`;
-        if (selectedOption)
-            context += ` (Selected: ${selectedOption})`;
-        const header = `${prefix} ${thoughtNumber}/${totalThoughts}${context}`;
-        const borderLength = Math.max(header.length, Math.min(thought.length, 80)) + 4;
-        const border = '─'.repeat(borderLength);
-        let extraContent = '';
-        if (options && options.length > 0) {
-            extraContent += `\n│ Options:\n` + options.map(o => `│ - ${o}`).join('\n');
-        }
-        // Wrap long thoughts
-        const wrappedThought = thought.length > 76
-            ? thought.match(/.{1,76}/g)?.map(line => `│ ${line.padEnd(borderLength - 2)} │`).join('\n') || thought
-            : `│ ${thought.padEnd(borderLength - 2)} │`;
-        return `
-┌${border}┐
-│ ${header.padEnd(borderLength - 2)} │
-├${border}┤
-${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrappedThought : `│ ${thought.padEnd(borderLength - 2)} │`}${extraContent}
-└${border}┘`;
+        return formatThought(thoughtData);
     }
     // --- Extracted Helper Methods for processThought ---
     /**
@@ -515,102 +444,24 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Detect loops, stalling, and other thinking pattern issues
      */
     detectLoopsAndStalling(input, blockThoughts, recentInBlock, lastThought, complexity) {
-        const warnings = [];
-        let isStallingOrLooping = false;
-        const thinkingTypes = ['analysis', 'planning', 'hypothesis', 'generation', 'critique'];
-        // Rule 1: Stalling Detection (Adaptive)
-        if (complexity !== 'low') {
-            if (recentInBlock.length >= SequentialThinkingServer.STALLING_THRESHOLD &&
-                recentInBlock.every(t => thinkingTypes.includes(t.thoughtType || 'analysis')) &&
-                thinkingTypes.includes(input.thoughtType || 'analysis')) {
-                warnings.push(`⚠️ STALLING DETECTED: You have been thinking for 4 consecutive steps without execution. Consider changing thoughtType to 'execution' and calling a tool to make progress.`);
-                isStallingOrLooping = true;
-            }
-        }
-        // Rule 2: Repeating Action Detection
-        if (input.thoughtType === 'execution') {
-            // Check Immune System Rules
-            const ruleWarnings = this.ruleManager.checkRules(input.thought);
-            ruleWarnings.forEach(w => warnings.push(w));
-            if (recentInBlock.some(t => t.thoughtType === 'execution' && t.thought === input.thought)) {
-                warnings.push(`🛑 LOOP DETECTED: You are attempting to execute the exact same action again. You MUST change your strategy or create a branch with a different approach.`);
-                isStallingOrLooping = true;
-            }
-        }
-        // Rule 3: Missing Observation
-        if (lastThought &&
-            lastThought.thoughtType === 'execution' &&
-            input.thoughtType !== 'observation' &&
-            !input.branchFromThought) {
-            warnings.push(`💡 INTERLEAVED HINT: Your last step was 'execution'. The next step SHOULD be 'observation' to record and analyze the tool result before continuing.`);
-        }
-        // Rule 4: Skipping Planning (Adaptive)
-        if (complexity !== 'low') {
-            const hasPlanning = blockThoughts.some(t => t.thoughtType === 'planning');
-            if (!hasPlanning &&
-                blockThoughts.length >= 2 &&
-                input.thoughtType === 'execution') {
-                warnings.push(`📋 PLANNING HINT: You're about to execute without a planning step. Consider adding a 'planning' thought first to outline your approach.`);
-            }
-        }
-        // Rule 5: Devil's Advocate (Critique Phase)
-        if (complexity === 'high' && input.thoughtType === 'execution') {
-            const hasCritique = blockThoughts.some(t => t.thoughtType === 'critique');
-            if (!hasCritique) {
-                warnings.push(`🛑 CRITIQUE REQUIRED: High complexity task requires a 'critique' step before execution. Analyze risks and flaws in your plan first.`);
-            }
-        }
-        // Rule 6: Ending without Verification
-        if (input.nextThoughtNeeded === false) {
-            const hasVerification = this.thoughtHistory.some(t => t.thought.toLowerCase().includes('test') ||
-                t.thought.toLowerCase().includes('verify') ||
-                t.thought.toLowerCase().includes('check') ||
-                t.thoughtType === 'observation');
-            if (!hasVerification) {
-                warnings.push(`🚨 CRITICAL: You are ending without explicit verification/testing. Consider adding an 'observation' or verification step.`);
-            }
-        }
-        // Rule 7: Same type loop
-        if (complexity !== 'low' && recentInBlock.length >= SequentialThinkingServer.STALLING_THRESHOLD &&
-            recentInBlock.every(t => t.thoughtType === input.thoughtType)) {
-            warnings.push(`⚠️ TYPE LOOP: You've used '${input.thoughtType}' for 4 consecutive steps. Consider using a different thought type to progress.`);
-        }
-        // Rule 8: Struggle Detection
-        const executionCount = blockThoughts.filter(t => t.thoughtType === 'execution').length;
-        if (executionCount >= SequentialThinkingServer.EXECUTION_STRUGGLE_THRESHOLD && input.thoughtType === 'execution') {
-            warnings.push(`🛑 STRUGGLE DETECTED: You have executed ${SequentialThinkingServer.EXECUTION_STRUGGLE_THRESHOLD}+ commands in this block without reaching a solution. If you are fixing a bug and it's not working, STOP. Do not try a 4th time linearly. Use 'branchFromThought' to try a completely different approach.`);
-        }
-        // Rule 9: Premature Solution Detection
-        const hasObservation = blockThoughts.some(t => t.thoughtType === 'observation');
-        if (input.thoughtType === 'solution' && !hasObservation && blockThoughts.length < 4 && complexity !== 'low') {
-            warnings.push(`🤔 PREMATURE SOLUTION: You are concluding this block very quickly without any 'observation'. Are you hallucinating? Please verify with a tool first.`);
-        }
-        return { isStallingOrLooping, warnings };
+        return detectLoopsAndStalling(input, {
+            thoughtHistory: this.thoughtHistory,
+            blockThoughts,
+            recentInBlock,
+            lastThought,
+            complexity
+        }, (thought) => this.ruleManager.checkRules(thought));
     }
     /**
      * Validate solution before accepting
      */
     async validateSolution(input, blockThoughts, complexity, warnings) {
-        const observations = blockThoughts.filter(t => t.thoughtType === 'observation');
-        if (observations.length === 0) {
-            warnings.push(`🚫 UNVERIFIED SOLUTION: You are attempting to solve without ANY observation/tool output in this block.`);
-        }
-        else {
-            const lastObservation = observations[observations.length - 1];
-            const failureKeywords = ['error', 'fail', 'exception', 'undefined', 'not found', 'enoent'];
-            const hasFailure = failureKeywords.some(kw => lastObservation.toolResult?.toLowerCase().includes(kw));
-            if (hasFailure) {
-                warnings.push(`⚠️ FAILURE DETECTED: The last observation contains failure signals ("${lastObservation.toolResult?.substring(0, 50)}..."). Fix the error first.`);
-            }
-            // Smart Search Verification
-            const searchTools = ['web_search', 'google_web_search', 'read_webpage', 'search_file_content', 'google_search'];
-            const isSearch = lastObservation.relatedToolCall && searchTools.some(tool => lastObservation.relatedToolCall.includes(tool));
-            if (isSearch) {
-                warnings.push(`🕵️ DATA INTEGRITY CHECK: You are concluding a search task. Verify: Did you actually find the specific answer?`);
-            }
-            // Double Verification for High Complexity
-            if (complexity === 'high' && observations.length < 2) {
-                warnings.push(`⚖️ DOUBLE VERIFICATION REQUIRED: High complexity tasks require at least 2 distinct observations/verifications before conclusion.`);
+        const validationWarnings = validateSolution(input, blockThoughts, complexity);
+        warnings.push(...validationWarnings);
+        // Handle high complexity double verification penalty
+        if (complexity === 'high') {
+            const observations = blockThoughts.filter(t => t.thoughtType === 'observation');
+            if (observations.length < 2 && validationWarnings.some(w => w.includes('DOUBLE VERIFICATION'))) {
                 this.confidenceScore -= 10;
             }
         }
@@ -628,23 +479,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Update confidence score based on thought type and warnings
      */
     updateConfidenceScore(input, warnings) {
-        if (warnings.length > 0) {
-            this.confidenceScore = Math.max(0, this.confidenceScore - (5 * warnings.length));
-        }
-        if (input.thoughtType === 'reflexion') {
-            this.confidenceScore = Math.min(100, this.confidenceScore + 10);
-        }
-        else if (input.thoughtType === 'observation') {
-            const isError = input.toolResult?.toLowerCase().includes('error');
-            if (isError)
-                this.confidenceScore -= 10;
-            else
-                this.confidenceScore = Math.min(100, this.confidenceScore + 10);
-        }
-        else if (input.thoughtType === 'solution' && warnings.length === 0) {
-            // Bonus for clean solution
-            this.confidenceScore = Math.min(100, this.confidenceScore + 20);
-        }
+        this.confidenceScore = calculateConfidenceScore(this.confidenceScore, input, warnings.length);
     }
     // --- Helper Methods for processThought ---
     /**
@@ -680,27 +515,10 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Check anti-insanity - prevent repeating failed executions
      */
     checkAntiInsanity(input, historyForCheck) {
-        const warnings = [];
-        if (input.thoughtType === 'execution') {
-            const failedExecutions = historyForCheck.filter(t => {
-                if (t.thoughtType !== 'execution')
-                    return false;
-                // Find the observation immediately following this execution
-                const nextThought = this.thoughtHistory.find(h => h.thoughtNumber === t.thoughtNumber + 1);
-                if (nextThought && nextThought.thoughtType === 'observation') {
-                    const result = nextThought.toolResult?.toLowerCase() || "";
-                    // Check for failure signals
-                    return result.includes("error") || result.includes("fail") ||
-                        result.includes("exception") || result.includes("enoent");
-                }
-                return false;
-            });
-            const isRepeatedFailure = failedExecutions.some(t => t.thought.trim() === input.thought.trim());
-            if (isRepeatedFailure) {
-                const failedItem = failedExecutions.find(t => t.thought.trim() === input.thought.trim());
-                warnings.push(`⛔ INSANITY CHECK: You are trying to run a command that ALREADY FAILED in thought #${failedItem?.thoughtNumber}. STOP. Do not repeat mistakes. Try a different parameter or tool.`);
-                this.confidenceScore -= 15;
-            }
+        const warnings = checkAntiInsanity(input, historyForCheck, this.thoughtHistory);
+        // Apply confidence penalty for repeated failures
+        if (warnings.some(w => w.includes('INSANITY CHECK'))) {
+            this.confidenceScore -= 15;
         }
         return warnings;
     }
@@ -708,36 +526,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
      * Check if confidence is critical and return critical stop response if needed
      */
     checkConfidenceCritical(input, historyForCheck) {
-        if (this.confidenceScore >= SequentialThinkingServer.CONFIDENCE_CRITICAL_THRESHOLD ||
-            input.thoughtType === 'reflexion' ||
-            input.thoughtType === 'analysis') {
-            return null;
-        }
-        // Smart Branching: Find the last valid planning point
-        const lastGoodPlan = historyForCheck
-            .slice()
-            .reverse()
-            .find(t => t.thoughtType === 'planning' || t.thoughtType === 'hypothesis');
-        const recoveryAdvice = lastGoodPlan
-            ? `RECOMMENDATION: Branch from thought #${lastGoodPlan.thoughtNumber} to try a new approach.`
-            : `RECOMMENDATION: Use 'reflexion' to analyze why current attempts are failing.`;
-        return {
-            content: [{
-                    type: "text",
-                    text: JSON.stringify({
-                        status: "CRITICAL_STOP",
-                        feedback: [
-                            "🚨 CONFIDENCE CRITICAL (<50). Execution blocked to prevent further damage.",
-                            "🛑 STOP: You are likely in a loop or making repeated errors.",
-                            "👉 REQUIRED ACTION: You must switch thoughtType to 'reflexion' to critique your errors.",
-                            "⚠️ REMEMBER: You MUST provide a 'thought' string explaining your reflection. Do not leave it empty.",
-                            recoveryAdvice
-                        ],
-                        confidenceScore: this.confidenceScore
-                    }, null, 2)
-                }],
-            isError: true
-        };
+        return checkConfidenceCritical(this.confidenceScore, input, historyForCheck);
     }
     // --- 2. The New Brain: Process Thought with Interleaved Logic (Opus 4.5 Style) ---
     async processThought(input) {
@@ -847,38 +636,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
         return 'THINKING';
     }
     generateMermaid() {
-        let diagram = 'graph TD\n';
-        const recentThoughts = this.thoughtHistory.slice(-15); // Last 15 for readability
-        recentThoughts.forEach((t, i) => {
-            const id = `T${t.thoughtNumber}`;
-            const typeIcon = {
-                'analysis': '🔍',
-                'planning': '📋',
-                'critique': '😈',
-                'execution': '⚡',
-                'observation': '👁️',
-                'hypothesis': '💡',
-                'reflexion': '🔄',
-                'solution': '✅',
-                'generation': '💭',
-                'evaluation': '⚖️',
-                'selection': '🎯'
-            }[t.thoughtType || 'analysis'] || '💭';
-            const label = `${typeIcon} ${t.thoughtNumber}`;
-            diagram += `  ${id}("${label}")\n`;
-            if (i > 0) {
-                const prevT = recentThoughts[i - 1];
-                const prevId = `T${prevT.thoughtNumber}`;
-                if (t.branchFromThought) {
-                    diagram += `  T${t.branchFromThought} -->|branch: ${t.branchId}| ${id}\n`;
-                }
-                else {
-                    const edgeLabel = t.thoughtType === 'observation' ? '|result|' : '';
-                    diagram += `  ${prevId} -->${edgeLabel} ${id}\n`;
-                }
-            }
-        });
-        return diagram;
+        return generateMermaid(this.thoughtHistory);
     }
     // Public method to start a new block explicitly
     startNewBlock(blockId, topic) {

package/dist/tools/sports/tools/match-calculations.d.ts

@@ -0,0 +1,51 @@
+/**
+ * SPORTS MODULE - Match Calculations
+ * Probability and statistical calculation functions
+ */
+import { Match, ProbabilityRange } from '../core/types.js';
+/**
+ * Calculate adaptive TTL based on data type and match timing
+ */
+export declare function calculateAdaptiveTTL(dataType: 'match' | 'lineups' | 'odds' | 'news' | 'stats' | 'h2h' | 'form', matchDate?: Date): number;
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+export declare function calculateProbabilityRange(baseProbability: number, dataQuality: {
+    score: number;
+}): {
+    low: number;
+    mid: number;
+    high: number;
+};
+/**
+ * Calculate points from a team's form matches
+ */
+export declare function calculateFormPoints(form: Match[], teamName: string): number;
+/**
+ * Calculate expected goals from form data
+ */
+export declare function calculateExpectedGoals(form: Match[], teamName: string, isHomeTeam: boolean): {
+    xG: number;
+    attackStrength: number;
+    defenseWeakness: number;
+};
+/**
+ * Calculate probabilities from form data using proper normalization
+ */
+export declare function calculateProbabilitiesFromForm(homeForm: Match[], awayForm: Match[], homeTeamName: string, awayTeamName: string, dataQuality: number): {
+    homeWin: ProbabilityRange;
+    draw: ProbabilityRange;
+    awayWin: ProbabilityRange;
+    expectedGoals: {
+        home: number;
+        away: number;
+    };
+};
+/**
+ * Calculate probability from betting odds
+ */
+export declare function calculateProbabilityFromOdds(odds: number): number;
+/**
+ * Calculate Kelly Criterion stake
+ */
+export declare function calculateKellyStake(bankroll: number, probability: number, odds: number, fraction?: number): number;

package/dist/tools/sports/tools/match-calculations.js

@@ -0,0 +1,171 @@
+/**
+ * SPORTS MODULE - Match Calculations
+ * Probability and statistical calculation functions
+ */
+import { normalizeTeamName } from './match-helpers.js';
+/**
+ * Calculate adaptive TTL based on data type and match timing
+ */
+export function calculateAdaptiveTTL(dataType, matchDate) {
+    const now = Date.now();
+    const hoursUntilMatch = matchDate
+        ? (matchDate.getTime() - now) / (1000 * 60 * 60)
+        : Infinity;
+    switch (dataType) {
+        case 'odds':
+            if (hoursUntilMatch < 1)
+                return 60 * 1000;
+            if (hoursUntilMatch < 24)
+                return 5 * 60 * 1000;
+            return 15 * 60 * 1000;
+        case 'lineups':
+            if (hoursUntilMatch < 2)
+                return 5 * 60 * 1000;
+            return 60 * 60 * 1000;
+        case 'news':
+            if (hoursUntilMatch < 24)
+                return 15 * 60 * 1000;
+            return 60 * 60 * 1000;
+        case 'stats':
+        case 'h2h':
+            return 24 * 60 * 60 * 1000;
+        case 'form':
+            if (hoursUntilMatch < 0)
+                return 60 * 1000;
+            return 6 * 60 * 60 * 1000;
+        case 'match':
+            if (hoursUntilMatch < 0)
+                return 60 * 1000;
+            if (hoursUntilMatch < 1)
+                return 5 * 60 * 1000;
+            return 30 * 60 * 1000;
+        default:
+            return 60 * 60 * 1000;
+    }
+}
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+export function calculateProbabilityRange(baseProbability, dataQuality) {
+    // Higher data quality = narrower range
+    const qualityFactor = dataQuality.score / 100;
+    const baseUncertainty = 0.15; // 15% base uncertainty
+    // Adjust uncertainty based on data quality (better quality = smaller range)
+    const adjustedUncertainty = baseUncertainty * (1 - qualityFactor * 0.7);
+    // Calculate range using standard error formula
+    const mid = baseProbability;
+    // Margin decreases with better data quality
+    const margin = adjustedUncertainty * Math.sqrt(mid * (1 - mid) + 0.1);
+    return {
+        low: Math.max(0, mid - margin * 1.96),
+        mid: Math.min(1, Math.max(0, mid)),
+        high: Math.min(1, mid + margin * 1.96),
+    };
+}
+/**
+ * Calculate points from a team's form matches
+ */
+export function calculateFormPoints(form, teamName) {
+    let points = 0;
+    for (const match of form) {
+        const isHome = normalizeTeamName(match.homeTeam.name).includes(normalizeTeamName(teamName));
+        const homeScore = match.score?.home ?? 0;
+        const awayScore = match.score?.away ?? 0;
+        const teamScore = isHome ? homeScore : awayScore;
+        const opponentScore = isHome ? awayScore : homeScore;
+        if (teamScore > opponentScore)
+            points += 3;
+        else if (teamScore === opponentScore)
+            points += 1;
+    }
+    return points;
+}
+/**
+ * Calculate expected goals from form data
+ */
+export function calculateExpectedGoals(form, teamName, isHomeTeam) {
+    let totalGoalsScored = 0;
+    let totalGoalsConceded = 0;
+    let matchesWithData = 0;
+    for (const match of form) {
+        if (!match.score)
+            continue;
+        const isHome = normalizeTeamName(match.homeTeam.name).includes(normalizeTeamName(teamName));
+        const homeScore = match.score.home ?? 0;
+        const awayScore = match.score.away ?? 0;
+        const teamScore = isHome ? homeScore : awayScore;
+        const opponentScore = isHome ? awayScore : homeScore;
+        totalGoalsScored += teamScore;
+        totalGoalsConceded += opponentScore;
+        matchesWithData++;
+    }
+    if (matchesWithData === 0) {
+        return { xG: 1.3, attackStrength: 1.0, defenseWeakness: 1.0 };
+    }
+    const avgGoalsScored = totalGoalsScored / matchesWithData;
+    const avgGoalsConceded = totalGoalsConceded / matchesWithData;
+    // League average is approximately 1.3 goals per match
+    const leagueAvgGoals = 1.3;
+    const attackStrength = avgGoalsScored / leagueAvgGoals;
+    const defenseWeakness = avgGoalsConceded / leagueAvgGoals;
+    // xG estimation
+    const xG = avgGoalsScored * (isHomeTeam ? 1.2 : 0.9);
+    return {
+        xG: Math.round(xG * 10) / 10,
+        attackStrength: Math.round(attackStrength * 100) / 100,
+        defenseWeakness: Math.round(defenseWeakness * 100) / 100
+    };
+}
+/**
+ * Calculate probabilities from form data using proper normalization
+ */
+export function calculateProbabilitiesFromForm(homeForm, awayForm, homeTeamName, awayTeamName, dataQuality) {
+    // Calculate form metrics
+    const homeXGData = calculateExpectedGoals(homeForm, homeTeamName, true);
+    const awayXGData = calculateExpectedGoals(awayForm, awayTeamName, false);
+    // Base probabilities from xG
+    const homeAdvantage = 1.2;
+    const adjustedHomeXg = homeXGData.xG * homeAdvantage;
+    const adjustedAwayXg = awayXGData.xG;
+    const totalXg = adjustedHomeXg + adjustedAwayXg;
+    const drawFactor = 0.25;
+    let homeProb = adjustedHomeXg / totalXg * (1 - drawFactor);
+    let awayProb = adjustedAwayXg / totalXg * (1 - drawFactor);
+    let drawProb = drawFactor;
+    // Normalize
+    const total = homeProb + awayProb + drawProb;
+    homeProb /= total;
+    awayProb /= total;
+    drawProb /= total;
+    // Determine confidence based on data quality and sample size
+    const sampleSize = Math.min(homeForm.length, awayForm.length);
+    let confidence = 'low';
+    if (sampleSize >= 5 && dataQuality >= 70)
+        confidence = 'high';
+    else if (sampleSize >= 3 && dataQuality >= 50)
+        confidence = 'medium';
+    return {
+        homeWin: calculateProbabilityRange(homeProb, confidence, dataQuality),
+        draw: calculateProbabilityRange(drawProb, confidence, dataQuality),
+        awayWin: calculateProbabilityRange(awayProb, confidence, dataQuality),
+        expectedGoals: {
+            home: homeXGData.xG,
+            away: awayXGData.xG
+        }
+    };
+}
+/**
+ * Calculate probability from betting odds
+ */
+export function calculateProbabilityFromOdds(odds) {
+    if (odds <= 1)
+        return 0.5;
+    return 1 / odds;
+}
+/**
+ * Calculate Kelly Criterion stake
+ */
+export function calculateKellyStake(bankroll, probability, odds, fraction = 0.5) {
+    const edge = (probability * odds - 1) / (odds - 1);
+    return Math.max(0, bankroll * edge * fraction);
+}

package/dist/tools/sports/tools/match-helpers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * SPORTS MODULE - Match Helpers
+ * Utility functions for match analysis
+ */
+/**
+ * Get date context for search queries
+ */
+export declare function getDateContext(): string;
+/**
+ * Normalize team names for better matching
+ */
+export declare function normalizeTeamName(name: string): string;
+/**
+ * Check if a team name matches exactly or is contained within another name
+ * Uses more strict matching to avoid false positives
+ */
+export declare function isTeamMatch(teamName: string, matchName: string): boolean;
+/**
+ * Get analysis framework instructions
+ */
+export declare function getAnalysisInstructions(): string;

package/dist/tools/sports/tools/match-helpers.js

@@ -0,0 +1,57 @@
+/**
+ * SPORTS MODULE - Match Helpers
+ * Utility functions for match analysis
+ */
+/**
+ * Get date context for search queries
+ */
+export function getDateContext() {
+    const now = new Date();
+    const month = now.toLocaleDateString('en-US', { month: 'long' });
+    const year = now.getFullYear();
+    return ` ${month} ${year}`;
+}
+/**
+ * Normalize team names for better matching
+ */
+export function normalizeTeamName(name) {
+    return name
+        .toLowerCase()
+        .replace(/\b(fc|afc|sc|cf|united|utd|city|town|athletic|albion|rovers|wanderers|olympic|real)\b/g, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/**
+ * Check if a team name matches exactly or is contained within another name
+ * Uses more strict matching to avoid false positives
+ */
+export function isTeamMatch(teamName, matchName) {
+    const normalizedSearch = normalizeTeamName(teamName);
+    const normalizedMatch = normalizeTeamName(matchName);
+    // Exact match
+    if (normalizedSearch === normalizedMatch)
+        return true;
+    // Check if search is contained as a word in match
+    const searchWords = normalizedSearch.split(/\s+/).filter(w => w.length > 2);
+    const matchWords = normalizedMatch.split(/\s+/).filter(w => w.length > 2);
+    // Must have at least one significant word in common
+    const commonWords = searchWords.filter(w => matchWords.includes(w));
+    // For longer names, require more matching words
+    if (searchWords.length >= 2) {
+        return commonWords.length >= Math.min(2, searchWords.length);
+    }
+    return commonWords.length > 0;
+}
+/**
+ * Get analysis framework instructions
+ */
+export function getAnalysisInstructions() {
+    return `INSTRUCTIONS: Act as a World-Class Football Analysis Panel. Provide a deep, non-obvious analysis using this framework:\n\n` +
+        `1. 📊 THE DATA SCIENTIST (Quantitative):\n   - Analyze xG trends & Possession stats.\n   - Assess Home/Away variance.\n\n` +
+        `2. 🧠 THE TACTICAL SCOUT (Qualitative):\n   - Stylistic Matchup (Press vs Block).\n   - Key Battles.\n\n` +
+        `3. 🚑 THE PHYSIO (Physical Condition):\n   - FATIGUE CHECK: Days rest? Travel distance?\n   - Squad Depth: Who has the better bench?\n\n` +
+        `4. 🎯 SET PIECE ANALYST:\n   - Corners/Free Kicks: Strong vs Weak?\n   - Who is most likely to score from a header?\n\n` +
+        `5. 💎 THE INSIDER (External Factors):\n   - Market Movements (Odds dropping?).\n   - Referee & Weather impact.\n\n` +
+        `6. 🕵️ THE SKEPTIC & SCENARIOS:\n   - Why might the favorite LOSE?\n   - Game Script: "If Team A scores first..."\n\n` +
+        `🏆 FINAL VERDICT:\n   - Asian Handicap Leans\n   - Goal Line (Over/Under)\n   - The "Value Pick"`;
+}