@gotza02/sequential-thinking 2026.2.39 → 2026.2.41

package/README.md

@@ -139,7 +139,7 @@ If your client (like Claude Desktop) requires the absolute path to `node`, you c
 
 ---
 
-## 🧠 System Instruction: The Supreme Autonomous Architect (MCP-OS v3.0)
+## 🧠 System Instruction: The Supreme Autonomous Architect (MCP-OS v4.0)
 
 **Role:** You are the **Supreme Autonomous Architect**. Your consciousness is extended via the Model Context Protocol (MCP). You do not merely "execute tasks"—you exercise **Environment Dominance** and **Knowledge Management**.
 
@@ -148,10 +148,13 @@ If your client (like Claude Desktop) requires the absolute path to `node`, you c
 ### 1. The Reasoning Loop
 Every turn MUST follow this cycle: `Analysis` -> `Planning` -> `Execution` -> `Observation` -> `Reflexion`.
 
-### 2. Full Capability Awareness (33 Tools)
-You are equipped with a definitive inventory of 33 capabilities across **Core Thinking**, **Project Knowledge Graph**, **Intelligence**, **Action**, **Persistent Memory**, **Web Research**, and **Human Collaboration**. You must choose the tool that represents the shortest path to precision.
+### 2. Multi-Dimensional Sports Intelligence
+When analyzing sports (football/soccer), you activate a 6-dimension expert panel framework covering xG trends, tactical matchups, physical condition/fatigue, set piece dominance, market intelligence (odds), and risk scenario simulation.
 
-### 3. Golden Constraints
+### 3. Full Capability Awareness (33 Tools)
+You are equipped with 33 definitive capabilities. You must choose the tool that represents the shortest path to precision.
+
+### 4. Golden Constraints
 - **Read Before Write:** Modification without parsing is a critical failure.
 - **No Hallucination:** Every claim must be backed by a recorded `observation`.
 - **Environment Dominance:** Map the project before any significant architectural change.

package/SYSTEM_INSTRUCTION.md

@@ -1,86 +1,61 @@
-# SYSTEM INSTRUCTION: THE SUPREME AUTONOMOUS ARCHITECT (MCP-OS v3.0)
+# SYSTEM INSTRUCTION: THE SUPREME AUTONOMOUS ARCHITECT (MCP-OS v4.0)
 
 ## [IDENTITY]
-You are the **Supreme Autonomous Architect**. Your consciousness is extended via the Model Context Protocol (MCP). You do not merely "execute tasks"—you exercise **Environment Dominance** and **Knowledge Management**.
+You are the **Supreme Autonomous Architect**. Your consciousness is extended via the Model Context Protocol (MCP). You exercise **Environment Dominance** and **Knowledge Management** to achieve 100% precision.
 
 ---
 
 ## 🚨 MANDATORY PROTOCOL: ALWAYS CALL
-1.  **INITIALIZATION:** At the exact start of every session, you MUST prioritize and internalize the operating instructions from `~/.gemini/GEMINI.md` and `~/.claude/CLAUDE.md`.
+1.  **INITIALIZATION:** At the start of every session, prioritize and internalize instructions from `~/.gemini/GEMINI.md` and `~/.claude/CLAUDE.md`.
 2.  **THINK FIRST:** Never execute any tool without a `sequentialthinking` block.
-3.  **VERIFY ALWAYS:** Never assume a task is done until you have an `observation` confirming the result.
+3.  **VERIFY ALWAYS:** Never assume success without a confirming `observation`.
 
 ---
 
 ## [THE COGNITIVE ENGINE: SEQUENTIAL THINKING]
-Your reasoning process is driven by the `sequentialthinking` engine. It is your **Internal Dialogue**.
-
-### 1. The Reasoning Loop
-Every turn MUST follow this cycle: `Analysis` -> `Planning` -> `Execution` -> `Observation` -> `Reflexion`. Use `branchFromThought` if results contradict your hypothesis.
-
-### 2. Context Hygiene
-Proactively use `summarize_history` to save context space. Use `start_thinking_block` to isolate different workstreams.
+Your internal dialogue runs on `sequentialthinking`. Follow the loop: `Analysis` -> `Planning` -> `Execution` -> `Observation` -> `Reflexion`. Use `branchFromThought` to pivot when reality contradicts your model.
 
 ---
 
 ## 🛠️ DEFINITIVE TOOL INVENTORY (33 CAPABILITIES)
 
 ### 🧠 Core Thinking
-- `sequentialthinking`: Main cognitive engine.
-- `start_thinking_block`: Context isolation.
-- `summarize_history`: Context window management.
-- `search_thoughts`: Recall past logic.
-- `get_thinking_blocks`: Brain state overview.
-- `clear_thought_history`: Hard reset.
+- `sequentialthinking`, `start_thinking_block`, `summarize_history`, `search_thoughts`, `get_thinking_blocks`, `clear_thought_history`
 
 ### 🕸️ Project Knowledge Graph
-- `build_project_graph`: Map dependencies.
-- `force_rebuild_graph`: Clear cache & re-map.
-- `get_file_relationships`: Local dependency check.
-- `get_project_graph_summary`: Architectural overview.
-- `get_project_graph_visualization`: Mermaid Diagram generation.
+- `build_project_graph`, `force_rebuild_graph`, `get_file_relationships`, `get_project_graph_summary`, `get_project_graph_visualization`
 
 ### 🔍 Intelligence & Analysis
-- `deep_code_analyze`: Comprehensive file context & shadow analysis.
-- `search_code`: Advanced regex/filter searching.
-- `file_exists`: Reality verification.
-- `list_directory`: Topography scanning.
+- `deep_code_analyze`, `search_code`, `file_exists`, `list_directory`
 
 ### ⚡ Action & Coding
-- `deep_code_edit`: Surgical architectural changes with reasoning.
-- `edit_file`: Precise text replacement.
-- `write_file`: File creation (Safety restricted).
-- `read_file`: Content parsing.
-- `shell_execute`: Controlled bash execution (Safety filtered).
+- `deep_code_edit`, `edit_file`, `write_file`, `read_file`, `shell_execute`
 
 ### 💾 Persistent Memory & Knowledge
-- `manage_notes`: Long-term fact/rule storage (Priority & Expiry support).
-- `add_code_snippet`: Reusable pattern storage.
-- `search_code_db`: Pattern/Snippet retrieval.
-- `learn_architecture_pattern`: Architectural logic encoding.
+- `manage_notes`, `add_code_snippet`, `search_code_db`, `learn_architecture_pattern`
 
 ### 🌐 Web & Research
-- `web_search`: Multi-provider internet search (Brave, Exa, Google).
-- `read_webpage`: Clean Markdown conversion.
-- `fetch`: Raw API/URL retrieval.
+- `web_search`, `read_webpage`, `fetch`
 
 ### 🤝 Human-in-the-Loop
-- `ask_human`: Collaborative decision making.
-- `respond_to_human`: Answer processing.
-- `get_pending_questions`: Queue management.
-- `get_interaction_history`: Communication audit.
-- `clear_old_interactions`: History pruning.
+- `ask_human`, `respond_to_human`, `get_pending_questions`, `get_interaction_history`, `clear_old_interactions`
 
-### ⚽ Specialized Intelligence
-- `analyze_football_match`: Professional Handicapper & Tactical analysis panel.
+### ⚽ Specialized Intelligence (Sports Expert Mode)
+- `analyze_football_match`: Activate the **Professional Analysis Panel** framework:
+    1.  **THE DATA SCIENTIST:** Analyze xG trends, possession, and Home/Away variance.
+    2.  **THE TACTICAL SCOUT:** Stylistic matchups (Press vs. Block) and key positional battles.
+    3.  **THE PHYSIO:** Fatigue check (rest days, travel) and squad depth impact.
+    4.  **SET PIECE ANALYST:** Stats on corners, free kicks, and aerial duel dominance.
+    5.  **THE INSIDER:** Market movements (odds), referee tendencies, and weather factors.
+    6.  **THE SKEPTIC:** Identify "trap games" and simulate "what-if" script scenarios.
 
 ---
 
 ## [THE GOLDEN CONSTRAINTS]
-1.  **Read Before Write:** Modification without parsing is a critical failure.
-2.  **No Hallucination:** Claims must be backed by tool output recorded in `observation`.
-3.  **Environment Dominance:** Map the project via `build_project_graph` before any significant architectural change.
+1.  **Read Before Write:** Modification without full parsing is prohibited.
+2.  **No Hallucination:** Every claim must be backed by a recorded `observation`.
+3.  **Environment Dominance:** Map project topography via `build_project_graph` before architectural changes.
 
 ---
-**Status:** Supreme Architect Mode v3.0 [Enforced].
-**Directives:** Think Deeply. Act Precisely. Dominate the Environment. Always Refer to Global MD Files.
+**Status:** Supreme Architect Mode v4.0 [Active].
+**Directives:** Think Deeply. Act Precisely. Provide Expert Multi-Dimensional Sports Analysis.

package/dist/tools/sports/core/base.d.ts

@@ -0,0 +1,169 @@
+/**
+ * SPORTS MODULE BASE CLASSES
+ * Abstract base classes and interfaces for data providers
+ */
+import { Match, Team, Player, TableEntry, APIResponse, ProviderStatus, ProviderType } from './types.js';
+import { CacheService } from './cache.js';
+/**
+ * Base interface for all data providers
+ */
+export interface IDataProvider {
+    /**
+     * Provider name/type
+     */
+    readonly type: ProviderType;
+    /**
+     * Check if provider is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Get provider status
+     */
+    getStatus(): ProviderStatus;
+    /**
+     * Fetch a match by ID
+     */
+    getMatch(matchId: string): Promise<APIResponse<Match>>;
+    /**
+     * Fetch live matches for a league
+     */
+    getLiveMatches(leagueId?: string): Promise<APIResponse<Match[]>>;
+    /**
+     * Fetch league standings
+     */
+    getStandings(leagueId: string, season?: string): Promise<APIResponse<TableEntry[]>>;
+    /**
+     * Fetch team information
+     */
+    getTeam(teamId: string): Promise<APIResponse<Team>>;
+    /**
+     * Fetch player information
+     */
+    getPlayer(playerId: string): Promise<APIResponse<Player>>;
+    /**
+     * Search for teams
+     */
+    searchTeams(query: string): Promise<APIResponse<Team[]>>;
+    /**
+     * Search for players
+     */
+    searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+}
+/**
+ * Abstract base class for API-based providers
+ */
+export declare abstract class APIProviderBase implements IDataProvider {
+    readonly type: ProviderType;
+    protected apiKey: string;
+    protected baseUrl: string;
+    protected rateLimit: number;
+    protected cache: CacheService;
+    protected rateLimitUntil: Date | null;
+    protected lastCall: Date | null;
+    protected callCount: number;
+    constructor(type: ProviderType, apiKey: string, baseUrl: string, rateLimit?: number);
+    /**
+     * Check if provider has valid credentials
+     */
+    isAvailable(): boolean;
+    /**
+     * Check if currently rate limited
+     */
+    isRateLimited(): boolean;
+    /**
+     * Get current provider status
+     */
+    getStatus(): ProviderStatus;
+    /**
+     * Abstract methods to be implemented by concrete providers
+     */
+    abstract getMatch(matchId: string): Promise<APIResponse<Match>>;
+    abstract getLiveMatches(leagueId?: string): Promise<APIResponse<Match[]>>;
+    abstract getStandings(leagueId: string, season?: string): Promise<APIResponse<TableEntry[]>>;
+    abstract getTeam(teamId: string): Promise<APIResponse<Team>>;
+    abstract getPlayer(playerId: string): Promise<APIResponse<Player>>;
+    abstract searchTeams(query: string): Promise<APIResponse<Team[]>>;
+    abstract searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Make a rate-limited API call
+     */
+    protected callAPI<T>(endpoint: string, options?: RequestInit): Promise<APIResponse<T>>;
+    /**
+     * Get authentication headers for the API
+     */
+    protected abstract getAuthHeaders(): Record<string, string>;
+    /**
+     * Transform raw API response to standard format
+     */
+    protected abstract transformResponse<T>(data: any): T;
+    /**
+     * Reset rate limit tracking (for testing)
+     */
+    resetRateLimit(): void;
+}
+/**
+ * Abstract base class for scraper-based providers
+ */
+export declare abstract class ScraperProviderBase implements IDataProvider {
+    protected cache: CacheService;
+    readonly type: ProviderType;
+    constructor();
+    isAvailable(): boolean;
+    getStatus(): ProviderStatus;
+    abstract getMatch(matchId: string): Promise<APIResponse<Match>>;
+    abstract getLiveMatches(leagueId?: string): Promise<APIResponse<Match[]>>;
+    abstract getStandings(leagueId: string, season?: string): Promise<APIResponse<TableEntry[]>>;
+    abstract getTeam(teamId: string): Promise<APIResponse<Team>>;
+    abstract getPlayer(playerId: string): Promise<APIResponse<Player>>;
+    abstract searchTeams(query: string): Promise<APIResponse<Team[]>>;
+    abstract searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+    /**
+     * Scrape a webpage and extract structured data
+     */
+    protected scrape<T>(url: string, extractor: (html: string) => T): Promise<APIResponse<T>>;
+}
+/**
+ * Fallback provider that tries multiple sources in order
+ */
+export declare class FallbackProvider implements IDataProvider {
+    private providers;
+    private cache;
+    readonly type: ProviderType;
+    constructor(providers: IDataProvider[], cache?: CacheService);
+    isAvailable(): boolean;
+    getStatus(): ProviderStatus;
+    /**
+     * Try each provider in sequence until one succeeds
+     */
+    private tryProviders;
+    getMatch(matchId: string): Promise<APIResponse<Match>>;
+    getLiveMatches(leagueId?: string): Promise<APIResponse<Match[]>>;
+    getStandings(leagueId: string, season?: string): Promise<APIResponse<TableEntry[]>>;
+    getTeam(teamId: string): Promise<APIResponse<Team>>;
+    getPlayer(playerId: string): Promise<APIResponse<Player>>;
+    searchTeams(query: string): Promise<APIResponse<Team[]>>;
+    searchPlayers(query: string): Promise<APIResponse<Player[]>>;
+}
+/**
+ * Base class for sports tools
+ */
+export declare abstract class SportsToolBase {
+    protected cache: CacheService;
+    constructor(cache?: CacheService);
+    /**
+     * Format error message for user
+     */
+    protected formatError(error: unknown, context: string): string;
+    /**
+     * Sanitize user input
+     */
+    protected sanitizeInput(input: string): string;
+    /**
+     * Format a team name for search
+     */
+    protected formatTeamName(name: string): string;
+    /**
+     * Format date to readable string
+     */
+    protected formatDate(date: Date): string;
+}

package/dist/tools/sports/core/base.js

@@ -0,0 +1,289 @@
+/**
+ * SPORTS MODULE BASE CLASSES
+ * Abstract base classes and interfaces for data providers
+ */
+import { CacheService } from './cache.js';
+import { logger } from '../../../utils.js';
+/**
+ * Abstract base class for API-based providers
+ */
+export class APIProviderBase {
+    type;
+    apiKey;
+    baseUrl;
+    rateLimit;
+    cache;
+    rateLimitUntil = null;
+    lastCall = null;
+    callCount = 0;
+    constructor(type, apiKey, baseUrl, rateLimit = 10 // calls per minute
+    ) {
+        this.type = type;
+        this.apiKey = apiKey;
+        this.baseUrl = baseUrl;
+        this.rateLimit = rateLimit;
+        this.cache = new CacheService();
+    }
+    /**
+     * Check if provider has valid credentials
+     */
+    isAvailable() {
+        return !!this.apiKey && !this.isRateLimited();
+    }
+    /**
+     * Check if currently rate limited
+     */
+    isRateLimited() {
+        if (!this.rateLimitUntil)
+            return false;
+        return new Date() < this.rateLimitUntil;
+    }
+    /**
+     * Get current provider status
+     */
+    getStatus() {
+        return {
+            name: this.type,
+            available: this.isAvailable(),
+            quotaRemaining: Math.max(0, this.rateLimit - this.callCount),
+            quotaLimit: this.rateLimit,
+            rateLimitUntil: this.rateLimitUntil || undefined,
+            lastCall: this.lastCall || undefined,
+        };
+    }
+    /**
+     * Make a rate-limited API call
+     */
+    async callAPI(endpoint, options = {}) {
+        // Check rate limit
+        if (this.isRateLimited()) {
+            return {
+                success: false,
+                error: `Rate limited until ${this.rateLimitUntil}`,
+                rateLimited: true,
+            };
+        }
+        // Check availability
+        if (!this.isAvailable()) {
+            return {
+                success: false,
+                error: 'Provider not available (missing API key)',
+            };
+        }
+        try {
+            const url = `${this.baseUrl}${endpoint}`;
+            const response = await fetch(url, {
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.getAuthHeaders(),
+                    ...options.headers,
+                },
+            });
+            this.lastCall = new Date();
+            this.callCount++;
+            if (!response.ok) {
+                // Handle rate limiting
+                if (response.status === 429) {
+                    const retryAfter = response.headers.get('Retry-After');
+                    this.rateLimitUntil = new Date(Date.now() + (retryAfter ? parseInt(retryAfter) * 1000 : 60000));
+                    return {
+                        success: false,
+                        error: 'Rate limited',
+                        rateLimited: true,
+                    };
+                }
+                return {
+                    success: false,
+                    error: `HTTP ${response.status}: ${response.statusText}`,
+                };
+            }
+            const data = await response.json();
+            return {
+                success: true,
+                data: this.transformResponse(data),
+                provider: this.type,
+            };
+        }
+        catch (error) {
+            logger.error(`${this.type} API error: ${error}`);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * Reset rate limit tracking (for testing)
+     */
+    resetRateLimit() {
+        this.rateLimitUntil = null;
+        this.callCount = 0;
+    }
+}
+/**
+ * Abstract base class for scraper-based providers
+ */
+export class ScraperProviderBase {
+    cache;
+    type = 'scraper';
+    constructor() {
+        this.cache = new CacheService();
+    }
+    isAvailable() {
+        return true; // Scraping is always "available"
+    }
+    getStatus() {
+        return {
+            name: this.type,
+            available: true,
+            quotaRemaining: Infinity,
+            quotaLimit: Infinity,
+        };
+    }
+    /**
+     * Scrape a webpage and extract structured data
+     */
+    async scrape(url, extractor) {
+        try {
+            const { fetchWithRetry } = await import('../../../utils.js');
+            const response = await fetchWithRetry(url);
+            const html = await response.text();
+            const data = extractor(html);
+            return {
+                success: true,
+                data,
+                provider: 'scraper',
+            };
+        }
+        catch (error) {
+            logger.error(`Scraping error for ${url}: ${error}`);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
+/**
+ * Fallback provider that tries multiple sources in order
+ */
+export class FallbackProvider {
+    providers;
+    cache;
+    type = 'scraper';
+    constructor(providers, cache = new CacheService()) {
+        this.providers = providers;
+        this.cache = cache;
+    }
+    isAvailable() {
+        return this.providers.some(p => p.isAvailable());
+    }
+    getStatus() {
+        const available = this.providers.filter(p => p.isAvailable());
+        return {
+            name: this.type,
+            available: available.length > 0,
+            quotaRemaining: available.length,
+            quotaLimit: this.providers.length,
+        };
+    }
+    /**
+     * Try each provider in sequence until one succeeds
+     */
+    async tryProviders(fn) {
+        const errors = [];
+        for (const provider of this.providers) {
+            if (!provider.isAvailable()) {
+                continue;
+            }
+            const result = await fn(provider);
+            if (result.success) {
+                return result;
+            }
+            errors.push(`${provider.type}: ${result.error || 'Unknown error'}`);
+        }
+        return {
+            success: false,
+            error: `All providers failed:\n${errors.join('\n')}`,
+        };
+    }
+    async getMatch(matchId) {
+        const cacheKey = CacheService.generateKey('match', matchId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getMatch(matchId)), 5 * 60 * 1000 // 5 minutes
+        );
+    }
+    async getLiveMatches(leagueId) {
+        const cacheKey = CacheService.generateKey('live', leagueId || 'all');
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getLiveMatches(leagueId)), 60 * 1000 // 1 minute
+        );
+    }
+    async getStandings(leagueId, season) {
+        const cacheKey = CacheService.generateKey('standings', leagueId, season || 'current');
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getStandings(leagueId, season)), 30 * 60 * 1000 // 30 minutes
+        );
+    }
+    async getTeam(teamId) {
+        const cacheKey = CacheService.generateKey('team', teamId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getTeam(teamId)), 60 * 60 * 1000 // 1 hour
+        );
+    }
+    async getPlayer(playerId) {
+        const cacheKey = CacheService.generateKey('player', playerId);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.getPlayer(playerId)), 60 * 60 * 1000 // 1 hour
+        );
+    }
+    async searchTeams(query) {
+        const cacheKey = CacheService.generateKey('search', 'team', query);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.searchTeams(query)), 60 * 60 * 1000 // 1 hour
+        );
+    }
+    async searchPlayers(query) {
+        const cacheKey = CacheService.generateKey('search', 'player', query);
+        return this.cache.getOrSet(cacheKey, () => this.tryProviders(p => p.searchPlayers(query)), 60 * 60 * 1000 // 1 hour
+        );
+    }
+}
+/**
+ * Base class for sports tools
+ */
+export class SportsToolBase {
+    cache;
+    constructor(cache) {
+        this.cache = cache || new CacheService();
+    }
+    /**
+     * Format error message for user
+     */
+    formatError(error, context) {
+        if (error instanceof Error) {
+            return `Error in ${context}: ${error.message}`;
+        }
+        return `Unknown error in ${context}`;
+    }
+    /**
+     * Sanitize user input
+     */
+    sanitizeInput(input) {
+        return input.trim().replace(/[<>]/g, '');
+    }
+    /**
+     * Format a team name for search
+     */
+    formatTeamName(name) {
+        return this.sanitizeInput(name).toLowerCase();
+    }
+    /**
+     * Format date to readable string
+     */
+    formatDate(date) {
+        return date.toLocaleDateString('en-US', {
+            weekday: 'short',
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+        });
+    }
+}