@gotza02/sequential-thinking 10000.2.1 → 10000.2.2

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

@@ -10,47 +10,10 @@ import { getGlobalCache, CacheService } from '../core/cache.js';
 import { formatMatchesTable, formatScore, formatMatchStatus } from '../utils/formatter.js';
 import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
 import { logger } from '../../../utils.js';
-// ============= Helper Functions =============
-/**
- * Get date context for search queries
- */
-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
- */
-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
- */
-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;
-}
+import { getDateContext, isTeamMatch, getAnalysisInstructions } from './match-helpers.js';
+// Note: calculateAdaptiveTTL, calculateProbabilityRange, calculateFormPoints,
+// calculateExpectedGoals, calculateProbabilitiesFromForm, and getLeagueId
+// are defined locally in this file with specific implementations for match analysis
 /**
  * Try to find match ID from API by team names and league
  */
@@ -367,65 +330,6 @@ async function scrapeContentWithErrorHandling(url, type) {
         return `${type.charAt(0).toUpperCase() + type.slice(1)} scrape failed: ${errorMsg}`;
     }
 }
-/**
- * Get analysis framework instructions
- */
-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"`;
-}
-/**
- * Calculate adaptive TTL based on data type and match timing
- */
-function calculateAdaptiveTTL(dataType, matchDate) {
-    const now = Date.now();
-    const hoursUntilMatch = matchDate
-        ? (matchDate.getTime() - now) / (1000 * 60 * 60)
-        : Infinity;
-    switch (dataType) {
-        case 'odds':
-            // Odds change frequently - short TTL
-            if (hoursUntilMatch < 1)
-                return 60 * 1000; // 1 minute
-            if (hoursUntilMatch < 24)
-                return 5 * 60 * 1000; // 5 minutes
-            return 15 * 60 * 1000; // 15 minutes
-        case 'lineups':
-            // Lineups announced ~1 hour before match
-            if (hoursUntilMatch < 2)
-                return 5 * 60 * 1000; // 5 minutes
-            return 60 * 60 * 1000; // 1 hour
-        case 'news':
-            // News changes throughout the day
-            if (hoursUntilMatch < 24)
-                return 15 * 60 * 1000; // 15 minutes
-            return 60 * 60 * 1000; // 1 hour
-        case 'stats':
-        case 'h2h':
-            // Historical stats don't change
-            return 24 * 60 * 60 * 1000; // 24 hours
-        case 'form':
-            // Form updates after each match
-            if (hoursUntilMatch < 0)
-                return 60 * 1000; // Live match - 1 minute
-            return 6 * 60 * 60 * 1000; // 6 hours
-        case 'match':
-            // Match data changes based on timing
-            if (hoursUntilMatch < 0)
-                return 60 * 1000; // Live - 1 minute
-            if (hoursUntilMatch < 1)
-                return 5 * 60 * 1000; // 5 minutes
-            return 30 * 60 * 1000; // 30 minutes
-        default:
-            return 30 * 60 * 1000; // 30 minutes default
-    }
-}
 /**
  * Perform comprehensive match analysis using web search
  */
@@ -487,28 +391,6 @@ async function scrapeDeepDiveSources(candidateUrls) {
     }
     return output;
 }
-/**
- * Calculate probability range with uncertainty quantification
- */
-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
-    // For binomial proportion: SE = sqrt(p*(1-p)/n)
-    // We use a simplified version based on data quality
-    const mid = baseProbability;
-    // Margin decreases with better data quality
-    // Using 1.96 for ~95% confidence interval (2 standard deviations)
-    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),
-    };
-}
 /**
  * Detect value bets from predictions and odds
  */
@@ -1139,6 +1021,21 @@ Requires API provider with match ID.`, {
     });
 }
 // ============= Helper Functions =============
+/**
+ * Calculate probability range with uncertainty quantification
+ */
+function calculateProbabilityRange(baseProbability, dataQuality) {
+    const qualityFactor = dataQuality.score / 100;
+    const baseUncertainty = 0.15;
+    const adjustedUncertainty = baseUncertainty * (1 - qualityFactor * 0.7);
+    const mid = baseProbability;
+    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),
+    };
+}
 /**
  * Get league ID from league name
  */

package/dist/tools/sports.js

@@ -91,7 +91,7 @@ function registerLegacyAnalyzeMatch(server) {
                     const data = await response.json();
                     const items = data.web?.results || [];
                     items.forEach((item) => candidateUrls.push(item.url));
-                    resultsText = items.map((item) => `- [${item.title}](${item.url}): ${item.description}`).join('\n');
+                    resultsText = items.map((item) => `- [${item.title}](${item.url}): ${item.description ?? ''}`).join('\n');
                 }
                 else if (searchProvider === 'exa') {
                     const response = await fetchWithRetry('https://api.exa.ai/search', {
@@ -107,7 +107,7 @@ function registerLegacyAnalyzeMatch(server) {
                     const data = await response.json();
                     const items = data.results || [];
                     items.forEach((item) => candidateUrls.push(item.url));
-                    resultsText = items.map((item) => `- [${item.title}](${item.url}): ${item.text || item.title}`).join('\n');
+                    resultsText = items.map((item) => `- [${item.title}](${item.url}): ${item.text ?? item.title}`).join('\n');
                 }
                 else if (searchProvider === 'google') {
                     const response = await fetchWithRetry(`https://www.googleapis.com/customsearch/v1?key=${process.env.GOOGLE_SEARCH_API_KEY}&cx=${process.env.GOOGLE_SEARCH_CX}&q=${encodeURIComponent(q.query)}&num=4`);
@@ -116,7 +116,7 @@ function registerLegacyAnalyzeMatch(server) {
                     const data = await response.json();
                     const items = data.items || [];
                     items.forEach((item) => candidateUrls.push(item.link));
-                    resultsText = items.map((item) => `- [${item.title}](${item.link}): ${item.snippet}`).join('\n');
+                    resultsText = items.map((item) => `- [${item.title}](${item.link}): ${item.snippet ?? ''}`).join('\n');
                 }
                 return `### ${q.type}\n${resultsText}\n`;
             }

package/dist/utils.d.ts

@@ -1,63 +1,130 @@
+declare const CONFIG: {
+    readonly COMMAND_TIMEOUT: 60000;
+    readonly MAX_BUFFER: number;
+    readonly MAX_PATTERN_LENGTH: 500;
+    readonly MAX_QUANTIFIERS: 20;
+    readonly MAX_LOCKS: 1000;
+    readonly DNS_TIMEOUT: 5000;
+    readonly MAX_INPUT_LENGTH: 10000;
+    readonly RETRY: {
+        readonly MAX_RETRIES: 3;
+        readonly BASE_DELAY: 1000;
+        readonly BACKOFF_MULTIPLIER: 2;
+    };
+};
+/**
+ * Whitelist of safe commands. Consider loading from config file for flexibility.
+ */
+declare const SAFE_COMMANDS: ReadonlySet<string>;
+export declare class SecurityError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare class ValidationError extends Error {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
+export declare class TimeoutError extends Error {
+    readonly timeout: number;
+    constructor(message: string, timeout: number);
+}
+interface ParsedCommand {
+    command: string;
+    args: string[];
+}
 /**
- * Execute a shell command with security protections against command injection.
- * Uses spawn() instead of exec() to avoid shell interpretation.
- *
- * @param command - The command string to execute
- * @param options - Execution options (timeout, maxBuffer)
- * @returns Promise with stdout and stderr
- * @throws Error if command contains shell metacharacters or is not whitelisted
+ * Robust command parser supporting quotes and escapes.
+ * State machine implementation for correctness.
  */
-export declare function execAsync(command: string, options?: {
+declare function parseCommand(command: string): ParsedCommand;
+export interface ExecOptions {
     timeout?: number;
     maxBuffer?: number;
-}): Promise<{
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+export interface ExecResult {
     stdout: string;
     stderr: string;
-}>;
+    exitCode: number;
+    executionTime: number;
+}
+/**
+ * Execute command securely using spawn (no shell interpretation).
+ */
+export declare function execAsync(command: string, options?: ExecOptions): Promise<ExecResult>;
 export declare class AsyncMutex {
-    private mutex;
-    lock(): Promise<() => void>;
-    dispatch<T>(fn: (() => T | PromiseLike<T>)): Promise<T>;
+    private queue;
+    private locked;
+    acquire(): Promise<() => void>;
+    private release;
+    dispatch<T>(fn: () => T | PromiseLike<T>): Promise<T>;
+}
+export declare class FileLock {
+    private locks;
+    private queue;
+    private readonly maxLocks;
+    constructor(maxLocks?: 1000);
+    acquire(filePath: string, timeout?: number): Promise<{
+        release: () => void;
+    }>;
+    private waitForLock;
+    private release;
+    private cleanupStaleLocks;
+    getLockCount(): number;
+    getQueueCount(): number;
 }
+export declare const fileLock: FileLock;
 export declare function validatePath(requestedPath: string): string;
+declare function isPrivateIPv4(ip: string): boolean;
+declare function isPrivateIPv6(ip: string): boolean;
 export declare function validatePublicUrl(urlString: string): Promise<void>;
 export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+interface LoggerOptions {
+    level?: LogLevel;
+    useColors?: boolean;
+    output?: 'stdout' | 'stderr';
+}
 declare class Logger {
     private level;
-    constructor();
+    private useColors;
+    private output;
+    private static readonly LEVELS;
+    private static readonly COLORS;
+    constructor(options?: LoggerOptions);
     private shouldLog;
-    debug(msg: string, ...args: any[]): void;
-    info(msg: string, ...args: any[]): void;
-    warn(msg: string, ...args: any[]): void;
-    error(msg: string, ...args: any[]): void;
+    private formatMessage;
+    private print;
+    debug(msg: string, ...args: unknown[]): void;
+    info(msg: string, ...args: unknown[]): void;
+    warn(msg: string, ...args: unknown[]): void;
+    error(msg: string, ...args: unknown[]): void;
+    setLevel(level: LogLevel): void;
 }
 export declare const logger: Logger;
-/**
- * Validate a regex pattern for ReDoS vulnerabilities
- * @throws Error if pattern is unsafe
- */
+export declare class ReDoSError extends SecurityError {
+    constructor(message: string);
+}
 export declare function validateRegexPattern(pattern: string): void;
-/**
- * Create a RegExp object with ReDoS protection
- * @param pattern - The regex pattern
- * @param flags - Regex flags (g, i, m, etc.)
- * @returns Safe RegExp object
- * @throws Error if pattern is unsafe
- */
 export declare function createSafeRegex(pattern: string, flags?: string): RegExp;
-export declare const DEFAULT_HEADERS: {
-    'User-Agent': string;
-    Accept: string;
-    'Accept-Language': string;
-};
-export declare function fetchWithRetry(url: string, options?: any, retries?: number, backoff?: number): Promise<Response>;
-export declare function withRetry(fn: () => Promise<any>, maxRetries?: number, baseDelay?: number): Promise<any>;
-export declare class FileLock {
-    locks: Map<any, any>;
-    acquire(filePath: string, timeout?: number): Promise<{
-        release: () => void;
-    }>;
+export declare const DEFAULT_HEADERS: Readonly<Record<string, string>>;
+export interface FetchOptions extends RequestInit {
+    retries?: number;
+    backoff?: number;
+    validateUrl?: boolean;
 }
-export declare const fileLock: FileLock;
-export declare function sanitizeInput(input: any, maxLength?: number): string;
-export {};
+export declare function fetchWithRetry(url: string, options?: FetchOptions): Promise<Response>;
+export declare function withRetry<T>(fn: () => Promise<T>, options?: {
+    maxRetries?: number;
+    baseDelay?: number;
+    onRetry?: (error: Error, attempt: number) => void;
+    shouldRetry?: (error: Error) => boolean;
+}): Promise<T>;
+export interface SanitizeOptions {
+    maxLength?: number;
+    allowedPattern?: RegExp;
+    removeNull?: boolean;
+    trim?: boolean;
+}
+export declare function sanitizeInput(input: unknown, options?: SanitizeOptions): string;
+export { CONFIG, SAFE_COMMANDS, parseCommand, isPrivateIPv4, isPrivateIPv6, Logger, };