@gotza02/sequential-thinking 2026.2.32 → 2026.2.33

package/dist/index.js

@@ -16,6 +16,7 @@ import { registerNoteTools } from './tools/notes.js';
 import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
 import { registerHumanTools } from './tools/human.js';
+import { registerSportsTools } from './tools/sports.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
@@ -36,6 +37,7 @@ registerNoteTools(server, notesManager);
 registerCodingTools(server, knowledgeGraph);
 registerCodeDbTools(server, codeDb);
 registerHumanTools(server);
+registerSportsTools(server);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/tools/sports.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerSportsTools(server: McpServer): void;

package/dist/tools/sports.js

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { fetchWithRetry } from "../utils.js";
+import { scrapeWebpage } from "./web.js";
+export function registerSportsTools(server) {
+    // 19. analyze_football_match
+    server.tool("analyze_football_match", "Gather comprehensive data for a football (soccer) match to perform a detailed analysis. Fetches Head-to-Head, Recent Form, Team News, and Predictions from the web. It also performs a 'Deep Dive' on the best data source found.", {
+        homeTeam: z.string().describe("Name of the home team"),
+        awayTeam: z.string().describe("Name of the away team"),
+        league: z.string().optional().describe("League name (optional, helps with accuracy)"),
+        context: z.string().optional().describe("Any specific angle to focus on (e.g., 'betting', 'tactical', 'injury news')")
+    }, async ({ homeTeam, awayTeam, league, context }) => {
+        const errors = [];
+        // Identify available search provider
+        let searchProvider = null;
+        if (process.env.BRAVE_API_KEY)
+            searchProvider = 'brave';
+        else if (process.env.EXA_API_KEY)
+            searchProvider = 'exa';
+        else if (process.env.GOOGLE_SEARCH_API_KEY && process.env.GOOGLE_SEARCH_CX)
+            searchProvider = 'google';
+        if (!searchProvider) {
+            return {
+                content: [{ type: "text", text: "Error: No search provider configured (BRAVE_API_KEY, EXA_API_KEY, or GOOGLE_SEARCH_API_KEY). Cannot fetch live match data." }],
+                isError: true
+            };
+        }
+        const leagueStr = league ? `${league} ` : '';
+        const baseQuery = `${leagueStr}${homeTeam} vs ${awayTeam}`;
+        // Critical: Add date context to ensure freshness (Accuracy Upgrade)
+        const today = new Date().toLocaleDateString('en-US', { month: 'long', year: 'numeric' }); // e.g., "January 2025"
+        const dateQuery = ` ${today}`;
+        // Define targeted queries for "Detailed" analysis
+        const queries = [
+            { type: 'General & Prediction', query: `${baseQuery} match prediction stats${dateQuery}` },
+            { type: 'Head to Head', query: `${baseQuery} head to head history` },
+            { type: 'Recent Form', query: `${homeTeam} ${awayTeam} recent form last 5 matches results${dateQuery}` },
+            { type: 'Team News & Lineups', query: `${baseQuery} team news injuries suspensions predicted confirmed lineups${dateQuery}` },
+            { type: 'Advanced Metrics', query: `${baseQuery} xG expected goals stats possession shots per game${dateQuery}` },
+            // Combine Manager/Press with "Sack Race/Pressure" context
+            { type: 'Manager & Atmosphere', query: `${homeTeam} ${awayTeam} manager quotes fan sentiment sack race pressure${dateQuery}` },
+            // NEW: Market Intelligence
+            { type: 'Market & Odds', query: `${baseQuery} odds movement dropping odds betting trends${dateQuery}` },
+            // NEW: Environmental Factors
+            { type: 'Ref & Weather', query: `${baseQuery} referee stats cards per game weather forecast stadium${dateQuery}` },
+            // NEW: Fatigue & Schedule (Critical for late game performance)
+            { type: 'Fatigue & Schedule', query: `${homeTeam} ${awayTeam} days rest fixture congestion travel distance${dateQuery}` },
+            // NEW: Set Piece Analysis (Where 30% of goals come from)
+            { type: 'Set Pieces', query: `${homeTeam} ${awayTeam} set piece goals scored conceded corners stats aerial duels${dateQuery}` }
+        ];
+        if (context) {
+            queries.push({ type: 'Specific Context', query: `${baseQuery} ${context} ${today}` });
+        }
+        let combinedResults = `--- FOOTBALL MATCH DATA: ${homeTeam} vs ${awayTeam} ---\nMatch Context Date: ${today}\n\n`;
+        // Store potential URLs for deep dive
+        const candidateUrls = [];
+        // Execute searches in parallel
+        const searchPromises = queries.map(async (q) => {
+            try {
+                let resultsText = "";
+                if (searchProvider === 'brave') {
+                    const response = await fetchWithRetry(`https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(q.query)}&count=4`, {
+                        headers: {
+                            'X-Subscription-Token': process.env.BRAVE_API_KEY,
+                            'Accept': 'application/json'
+                        }
+                    });
+                    if (!response.ok)
+                        throw new Error(`Brave Status ${response.status}`);
+                    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');
+                }
+                else if (searchProvider === 'exa') {
+                    const response = await fetchWithRetry('https://api.exa.ai/search', {
+                        method: 'POST',
+                        headers: {
+                            'x-api-key': process.env.EXA_API_KEY,
+                            'Content-Type': 'application/json'
+                        },
+                        body: JSON.stringify({ query: q.query, numResults: 4 })
+                    });
+                    if (!response.ok)
+                        throw new Error(`Exa Status ${response.status}`);
+                    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');
+                }
+                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`);
+                    if (!response.ok)
+                        throw new Error(`Google Status ${response.status}`);
+                    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');
+                }
+                return `### ${q.type}\n${resultsText}\n`;
+            }
+            catch (error) {
+                return `### ${q.type} (Failed)\nError: ${error instanceof Error ? error.message : String(error)}\n`;
+            }
+        });
+        const results = await Promise.all(searchPromises);
+        combinedResults += results.join('\n');
+        // --- Deep Dive: Scrape the best URL ---
+        if (candidateUrls.length > 0) {
+            // Priority domains for sports data
+            const priorityDomains = ['whoscored.com', 'flashscore', 'sofascore', 'bbc.co.uk/sport', 'skysports.com', 'sportsmole', 'goal.com', 'understat.com', 'fbref.com'];
+            // Find first match from priority list, else take the first valid URL
+            const bestUrl = candidateUrls.find(url => priorityDomains.some(domain => url.includes(domain))) || candidateUrls[0];
+            if (bestUrl) {
+                combinedResults += `\n--- DEEP DIVE ANALYSIS (${bestUrl}) ---\n`;
+                try {
+                    // Stability: Wrap scrape in a 15s timeout to prevent hanging
+                    const scrapePromise = scrapeWebpage(bestUrl);
+                    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Deep dive timeout (15s)")), 15000));
+                    const scrapedContent = await Promise.race([scrapePromise, timeoutPromise]);
+                    combinedResults += scrapedContent;
+                }
+                catch (scrapeError) {
+                    combinedResults += `(Deep dive failed/skipped: ${scrapeError instanceof Error ? scrapeError.message : String(scrapeError)})`;
+                }
+                combinedResults += `\n--- END DEEP DIVE ---\n`;
+            }
+        }
+        combinedResults += `\n--- END DATA ---\n\nINSTRUCTIONS: Act as a World-Class Football Analysis Panel. Provide a deep, non-obvious analysis using this framework:\n\n1. 📊 THE DATA SCIENTIST (Quantitative):\n   - Analyze xG trends & Possession stats.\n   - Assess Home/Away variance.\n\n2. 🧠 THE TACTICAL SCOUT (Qualitative):\n   - Stylistic Matchup (Press vs Block).\n   - Key Battles.\n\n3. 🚑 THE PHYSIO (Physical Condition):\n   - FATIGUE CHECK: Days rest? Travel distance? (Critical for last 20 mins).\n   - Squad Depth: Who has the better bench?\n\n4. 🎯 SET PIECE ANALYST (Special Teams):\n   - Corners/Free Kicks: Strong vs Weak? (Aerial Duel stats).\n   - Who is most likely to score from a header?\n\n5. 💎 THE INSIDER (External Factors):\n   - Market Movements (Odds dropping?).\n   - Referee & Weather impact.\n   - Managerial Pressure/Sack Race context.\n\n6. 🕵️ THE SKEPTIC & SCENARIOS:\n   - Why might the favorite LOSE? (The "Trap").\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"`;
+        return {
+            content: [{ type: "text", text: combinedResults }]
+        };
+    });
+}

package/dist/tools/web.d.ts

@@ -1,2 +1,3 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function scrapeWebpage(url: string): Promise<string>;
 export declare function registerWebTools(server: McpServer): void;

package/dist/tools/web.js

@@ -3,6 +3,56 @@ import { fetchWithRetry, validatePublicUrl } from "../utils.js";
 import { JSDOM } from 'jsdom';
 import { Readability } from '@mozilla/readability';
 import TurndownService from 'turndown';
+export async function scrapeWebpage(url) {
+    await validatePublicUrl(url);
+    const response = await fetchWithRetry(url);
+    const html = await response.text();
+    const doc = new JSDOM(html, { url });
+    const reader = new Readability(doc.window.document);
+    const article = reader.parse();
+    if (!article)
+        throw new Error("Could not parse article content");
+    const turndownService = new TurndownService({
+        headingStyle: 'atx',
+        codeBlockStyle: 'fenced'
+    });
+    // Custom Rule for GitHub Flavored Markdown Tables
+    turndownService.addRule('tables', {
+        filter: ['table'],
+        replacement: function (content, node) {
+            const rows = [];
+            const table = node;
+            const trs = Array.from(table.querySelectorAll('tr'));
+            trs.forEach((tr, index) => {
+                const cols = [];
+                const tds = Array.from(tr.querySelectorAll('th, td'));
+                tds.forEach(td => {
+                    // Clean content: remove newlines and pipe characters
+                    cols.push(td.textContent?.replace(/[\n\r]/g, ' ').replace(/\|/g, '\\|').trim() || "");
+                });
+                if (cols.length > 0) {
+                    rows.push(`| ${cols.join(' | ')} |`);
+                    // Add separator after header
+                    if (index === 0 || tr.querySelector('th')) {
+                        rows.push(`| ${cols.map(() => '---').join(' | ')} |`);
+                    }
+                }
+            });
+            // Filter out duplicate separator lines if any
+            const uniqueRows = rows.filter((row, i) => {
+                if (row.includes('---') && rows[i - 1]?.includes('---'))
+                    return false;
+                return true;
+            });
+            return '\n\n' + uniqueRows.join('\n') + '\n\n';
+        }
+    });
+    let markdown = turndownService.turndown(article.content || "");
+    if (markdown.length > 20000) {
+        markdown = markdown.substring(0, 20000) + "\n...(truncated)";
+    }
+    return `Title: ${article.title}\n\n${markdown}`;
+}
 export function registerWebTools(server) {
     // 1. web_search
     server.tool("web_search", "Search the web using Brave or Exa APIs (requires API keys in environment variables: BRAVE_API_KEY or EXA_API_KEY).", {
@@ -128,57 +178,11 @@ export function registerWebTools(server) {
         url: z.string().url().describe("The URL to read")
     }, async ({ url }) => {
         try {
-            await validatePublicUrl(url);
-            const response = await fetchWithRetry(url);
-            const html = await response.text();
-            const doc = new JSDOM(html, { url });
-            const reader = new Readability(doc.window.document);
-            const article = reader.parse();
-            if (!article)
-                throw new Error("Could not parse article content");
-            const turndownService = new TurndownService({
-                headingStyle: 'atx',
-                codeBlockStyle: 'fenced'
-            });
-            // Custom Rule for GitHub Flavored Markdown Tables
-            turndownService.addRule('tables', {
-                filter: ['table'],
-                replacement: function (content, node) {
-                    const rows = [];
-                    const table = node;
-                    const trs = Array.from(table.querySelectorAll('tr'));
-                    trs.forEach((tr, index) => {
-                        const cols = [];
-                        const tds = Array.from(tr.querySelectorAll('th, td'));
-                        tds.forEach(td => {
-                            // Clean content: remove newlines and pipe characters
-                            cols.push(td.textContent?.replace(/[\n\r]/g, ' ').replace(/\|/g, '\\|').trim() || "");
-                        });
-                        if (cols.length > 0) {
-                            rows.push(`| ${cols.join(' | ')} |`);
-                            // Add separator after header
-                            if (index === 0 || tr.querySelector('th')) {
-                                rows.push(`| ${cols.map(() => '---').join(' | ')} |`);
-                            }
-                        }
-                    });
-                    // Filter out duplicate separator lines if any
-                    const uniqueRows = rows.filter((row, i) => {
-                        if (row.includes('---') && rows[i - 1]?.includes('---'))
-                            return false;
-                        return true;
-                    });
-                    return '\n\n' + uniqueRows.join('\n') + '\n\n';
-                }
-            });
-            let markdown = turndownService.turndown(article.content || "");
-            if (markdown.length > 20000) {
-                markdown = markdown.substring(0, 20000) + "\n...(truncated)";
-            }
+            const result = await scrapeWebpage(url);
             return {
                 content: [{
                         type: "text",
-                        text: `Title: ${article.title}\n\n${markdown}`
+                        text: result
                     }]
             };
         }

package/dist/verify_all_tools.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/verify_all_tools.js

@@ -0,0 +1,129 @@
+import { SequentialThinkingServer } from './lib.js';
+import { ProjectKnowledgeGraph } from './graph.js';
+import { NotesManager } from './notes.js';
+import { CodeDatabase } from './codestore.js';
+import { fetchWithRetry } from './utils.js';
+import * as fs from 'fs/promises';
+// ANSI Colors
+const colors = {
+    reset: "\x1b[0m",
+    green: "\x1b[32m",
+    blue: "\x1b[34m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    bold: "\x1b[1m"
+};
+function log(step, msg) {
+    console.log(`${colors.blue}[${step}]${colors.reset} ${msg}`);
+}
+function success(msg) {
+    console.log(`${colors.green}  ✓ ${msg}${colors.reset}`);
+}
+async function main() {
+    console.log(`${colors.bold}=== STARTING AUTOMATED TOOL VERIFICATION ===${colors.reset}\n`);
+    // 1. Initialize Managers
+    log("INIT", "Initializing Core Managers...");
+    const thinking = new SequentialThinkingServer('test_thoughts.json', 0);
+    const graph = new ProjectKnowledgeGraph();
+    const notes = new NotesManager('test_notes.json');
+    const codeDb = new CodeDatabase('test_codedb.json');
+    // Clean up previous tests
+    try {
+        await Promise.all([
+            fs.unlink('test_thoughts.json').catch(() => { }),
+            fs.unlink('test_notes.json').catch(() => { }),
+            fs.unlink('test_codedb.json').catch(() => { })
+        ]);
+    }
+    catch { } // This catch block is intentionally empty
+    // 2. Test Thinking Engine
+    log("THINKING", "Testing Sequential Thinking Engine...");
+    await thinking.processThought({
+        thought: "Analysis step for testing",
+        thoughtNumber: 1,
+        totalThoughts: 3,
+        nextThoughtNeeded: true,
+        thoughtType: "analysis",
+        blockId: "test-block"
+    });
+    await thinking.processThought({
+        thought: "Planning step",
+        thoughtNumber: 2,
+        totalThoughts: 3,
+        nextThoughtNeeded: true,
+        thoughtType: "planning",
+        blockId: "test-block"
+    });
+    const history = await thinking.searchHistory("Analysis");
+    if (history.length > 0)
+        success(`History recorded and retrieved (${history.length} items)`);
+    else
+        throw new Error("Thinking history failed");
+    // 3. Test Notes Manager
+    log("NOTES", "Testing Notes Manager...");
+    const note = await notes.addNote("Test Note", "This is a test content", ["test"], "high");
+    success(`Note created: ${note.id}`);
+    const foundNotes = await notes.searchNotes("test content");
+    if (foundNotes.length > 0)
+        success(`Search successful (found ${foundNotes.length})`);
+    else
+        throw new Error("Note search failed");
+    await notes.deleteNote(note.id);
+    success("Note deleted");
+    // 4. Test Code Database
+    log("CODEDB", "Testing Code Database...");
+    const snippet = await codeDb.addSnippet({
+        title: "Hello World",
+        code: "console.log('Hello');",
+        language: "typescript",
+        description: "Simple log",
+        tags: ["example"],
+        context: "test.ts"
+    });
+    success(`Snippet added: ${snippet.id}`);
+    await codeDb.learnPattern("Singleton", "Use a static instance...");
+    success("Pattern learned");
+    const searchRes = await codeDb.searchSnippets("Hello");
+    if (searchRes.length > 0)
+        success(`Snippet search working`);
+    // 5. Test Knowledge Graph
+    log("GRAPH", "Testing Project Knowledge Graph...");
+    const buildRes = await graph.build(process.cwd());
+    success(`Graph built: ${buildRes.nodeCount} nodes, ${buildRes.totalFiles} files`);
+    const summary = graph.getSummary();
+    success(`Summary retrieved: ${summary.fileCount} files in graph`);
+    const rel = graph.getRelationships('src/index.ts');
+    if (rel) {
+        success(`Relationships for src/index.ts found (${rel.imports.length} imports)`);
+    }
+    else {
+        console.warn(`${colors.yellow}  ! Warning: src/index.ts not found in graph (might be excluded or path issue)${colors.reset}`);
+    }
+    // 6. Test FileSystem Logic (Reading self)
+    log("FS", "Testing File Operations...");
+    const content = await fs.readFile('src/index.ts', 'utf-8');
+    if (content.length > 0)
+        success("read_file working");
+    // 7. Test Web Tools (Utils)
+    log("WEB", "Testing Web Utilities...");
+    try {
+        const res = await fetchWithRetry('https://example.com');
+        if (res.ok)
+            success("Web fetch working");
+    }
+    catch (e) {
+        console.warn(`${colors.yellow}  ! Web fetch failed (network might be offline), skipping.${colors.reset}`);
+    }
+    // Cleanup
+    log("CLEANUP", "Removing test artifacts...");
+    await Promise.all([
+        fs.unlink('test_thoughts.json').catch(() => { }),
+        fs.unlink('test_notes.json').catch(() => { }),
+        fs.unlink('test_codedb.json').catch(() => { })
+    ]);
+    console.log(`\n${colors.green}${colors.bold}=== ALL TESTS PASSED SUCCESSFULLY ===${colors.reset}`);
+}
+main().catch(err => {
+    console.error(`\n${colors.red}${colors.bold}FATAL ERROR:${colors.reset}`, err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.2.32",
+  "version": "2026.2.33",
   "publishConfig": {
     "access": "public"
   },