@gotza02/sequential-thinking 2026.3.0 → 2026.3.1

package/dist/graph.d.ts

@@ -65,5 +65,5 @@ export declare class ProjectKnowledgeGraph {
             referencedBy: number;
         }[];
     };
-    toMermaid(): string;
+    toMermaid(type?: 'flowchart' | 'classDiagram'): string;
 }

package/dist/graph.js

@@ -833,7 +833,59 @@ export class ProjectKnowledgeGraph {
             }))
         };
     }
-    toMermaid() {
+    toMermaid(type = 'flowchart') {
+        if (type === 'classDiagram') {
+            const lines = ['classDiagram'];
+            const fileToClasses = new Map();
+            for (const [filePath, node] of this.nodes) {
+                const classesInFile = [];
+                // Parse symbols to find classes/interfaces
+                for (const symbol of node.symbols) {
+                    const parts = symbol.split(':');
+                    if (parts.length < 2)
+                        continue; // Skip malformed symbols
+                    const kind = parts[0];
+                    const name = parts[1];
+                    if (['class', 'interface', 'type', 'enum'].includes(kind)) {
+                        lines.push(`  class ${name} {`);
+                        lines.push(`    <<${kind}>>`);
+                        lines.push(`  }`);
+                        classesInFile.push(name);
+                    }
+                }
+                if (classesInFile.length > 0) {
+                    fileToClasses.set(filePath, classesInFile);
+                }
+            }
+            // Add relationships based on imports
+            // This is tricky because imports are file-based, not class-based.
+            // We'll link all classes in File A to all classes in File B if A imports B.
+            // To reduce noise, we limit this to explicit class dependencies if possible, 
+            // but our graph only knows file dependencies.
+            // We'll stick to a simplified view: Classes in A depend on Classes in B.
+            for (const [filePath, node] of this.nodes) {
+                const sources = fileToClasses.get(filePath);
+                if (!sources)
+                    continue;
+                for (const importPath of node.imports) {
+                    const targets = fileToClasses.get(importPath);
+                    if (targets) {
+                        for (const s of sources) {
+                            for (const t of targets) {
+                                // Avoid self-reference loops for simplicity in visualization
+                                if (s !== t) {
+                                    lines.push(`  ${s} ..> ${t}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            if (lines.length === 1)
+                return 'classDiagram\n  note "No classes/interfaces found to visualize"';
+            return lines.join('\n');
+        }
+        // Default: Flowchart (File Dependency Graph)
         const lines = ['graph TD'];
         const fileToId = new Map();
         let idCounter = 0;

package/dist/index.js

@@ -7,12 +7,14 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { SequentialThinkingServer } from './lib.js';
 import { ProjectKnowledgeGraph } from './graph.js';
 import { NotesManager } from './notes.js';
+import { KnowledgeGraphManager } from './knowledge.js';
 import { CodeDatabase } from './codestore.js';
 import { registerThinkingTools } from './tools/thinking.js';
 import { registerWebTools } from './tools/web.js';
 import { registerFileSystemTools } from './tools/filesystem.js';
 import { registerGraphTools } from './tools/graph.js';
 import { registerNoteTools } from './tools/notes.js';
+import { registerKnowledgeTools } from './tools/knowledge.js';
 import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
 import { registerHumanTools } from './tools/human.js';
@@ -26,6 +28,7 @@ const server = new McpServer({
 });
 const thinkingServer = new SequentialThinkingServer(process.env.THOUGHTS_STORAGE_PATH || 'thoughts_history.json', parseInt(process.env.THOUGHT_DELAY_MS || '0', 10));
 const knowledgeGraph = new ProjectKnowledgeGraph();
+const memoryGraph = new KnowledgeGraphManager(process.env.MEMORY_GRAPH_PATH || 'knowledge_graph.json');
 const notesManager = new NotesManager(process.env.NOTES_STORAGE_PATH || 'project_notes.json');
 const codeDb = new CodeDatabase(process.env.CODE_DB_PATH || 'code_database.json');
 // Register tools
@@ -34,6 +37,7 @@ registerWebTools(server);
 registerFileSystemTools(server);
 registerGraphTools(server, knowledgeGraph);
 registerNoteTools(server, notesManager);
+registerKnowledgeTools(server, memoryGraph);
 registerCodingTools(server, knowledgeGraph);
 registerCodeDbTools(server, codeDb);
 registerHumanTools(server);

package/dist/knowledge.d.ts

@@ -0,0 +1,50 @@
+export interface KnowledgeNode {
+    id: string;
+    label: string;
+    name: string;
+    properties: Record<string, any>;
+}
+export interface KnowledgeEdge {
+    source: string;
+    target: string;
+    relation: string;
+    weight?: number;
+    properties?: Record<string, any>;
+}
+export interface GraphQuery {
+    startNodeId?: string;
+    startNodeName?: string;
+    relationType?: string;
+    maxDepth?: number;
+}
+export declare class KnowledgeGraphManager {
+    private filePath;
+    private nodes;
+    private edges;
+    private lastModifiedTime;
+    private mutex;
+    constructor(storagePath?: string);
+    private load;
+    private save;
+    /**
+     * Add a new entity (node) to the graph.
+     * Updates existing node if ID or Name matches (simple dedup).
+     */
+    addNode(node: Omit<KnowledgeNode, 'id'> & {
+        id?: string;
+    }): Promise<KnowledgeNode>;
+    /**
+     * Create a relationship (edge) between two nodes.
+     */
+    addEdge(edge: KnowledgeEdge): Promise<KnowledgeEdge>;
+    /**
+     * Query the graph to find connected nodes.
+     * Simple BFS traversal up to maxDepth.
+     */
+    query(params: GraphQuery): Promise<{
+        nodes: KnowledgeNode[];
+        edges: KnowledgeEdge[];
+    }>;
+    deleteNode(id: string): Promise<boolean>;
+    searchNodes(query: string): Promise<KnowledgeNode[]>;
+}

package/dist/knowledge.js

@@ -0,0 +1,222 @@
+import * as fs from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+import * as path from 'path';
+import { AsyncMutex } from './utils.js';
+export class KnowledgeGraphManager {
+    filePath;
+    nodes = new Map();
+    edges = [];
+    lastModifiedTime = 0;
+    mutex = new AsyncMutex();
+    constructor(storagePath = 'knowledge_graph.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load(forceReload = false) {
+        try {
+            if (!existsSync(this.filePath)) {
+                this.nodes.clear();
+                this.edges = [];
+                this.lastModifiedTime = 0;
+                return;
+            }
+            const stats = statSync(this.filePath);
+            const currentMtime = stats.mtimeMs;
+            if (!forceReload && currentMtime === this.lastModifiedTime && this.nodes.size > 0) {
+                return;
+            }
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            if (!data.trim()) {
+                this.nodes.clear();
+                this.edges = [];
+                return;
+            }
+            const parsed = JSON.parse(data);
+            this.nodes.clear();
+            if (parsed.nodes) {
+                parsed.nodes.forEach(n => this.nodes.set(n.id, n));
+            }
+            this.edges = parsed.edges || [];
+            this.lastModifiedTime = currentMtime;
+        }
+        catch (error) {
+            console.error(`[KnowledgeGraphManager] Load error:`, error);
+            // Fallback to empty on error
+            this.nodes.clear();
+            this.edges = [];
+        }
+    }
+    async save() {
+        const tmpPath = `${this.filePath}.tmp`;
+        const storage = {
+            version: '1.0',
+            nodes: Array.from(this.nodes.values()),
+            edges: this.edges,
+            metadata: {
+                lastModified: new Date().toISOString()
+            }
+        };
+        try {
+            await fs.writeFile(tmpPath, JSON.stringify(storage, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.filePath);
+            const stats = await fs.stat(this.filePath);
+            this.lastModifiedTime = stats.mtimeMs;
+        }
+        catch (error) {
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { }
+            throw error;
+        }
+    }
+    /**
+     * Add a new entity (node) to the graph.
+     * Updates existing node if ID or Name matches (simple dedup).
+     */
+    async addNode(node) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            // Check if node exists by ID
+            if (node.id && this.nodes.has(node.id)) {
+                const existing = this.nodes.get(node.id);
+                // Update properties
+                existing.properties = { ...existing.properties, ...node.properties };
+                // Update other fields if provided
+                if (node.label)
+                    existing.label = node.label;
+                if (node.name)
+                    existing.name = node.name;
+                await this.save();
+                return existing;
+            }
+            // Check if node exists by Name + Label (fuzzy match avoidance)
+            // This prevents creating duplicate "Liverpool" nodes
+            const existingByName = Array.from(this.nodes.values()).find(n => n.name.toLowerCase() === node.name.toLowerCase() &&
+                n.label.toLowerCase() === node.label.toLowerCase());
+            if (existingByName) {
+                existingByName.properties = { ...existingByName.properties, ...node.properties };
+                await this.save();
+                return existingByName;
+            }
+            const newNode = {
+                id: node.id || `node-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`,
+                label: node.label,
+                name: node.name,
+                properties: node.properties || {}
+            };
+            this.nodes.set(newNode.id, newNode);
+            await this.save();
+            return newNode;
+        });
+    }
+    /**
+     * Create a relationship (edge) between two nodes.
+     */
+    async addEdge(edge) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            // Validate nodes exist
+            if (!this.nodes.has(edge.source))
+                throw new Error(`Source node ${edge.source} not found`);
+            if (!this.nodes.has(edge.target))
+                throw new Error(`Target node ${edge.target} not found`);
+            // Check for existing edge
+            const existingIndex = this.edges.findIndex(e => e.source === edge.source &&
+                e.target === edge.target &&
+                e.relation === edge.relation);
+            if (existingIndex >= 0) {
+                // Update existing edge
+                this.edges[existingIndex] = {
+                    ...this.edges[existingIndex],
+                    ...edge,
+                    properties: { ...this.edges[existingIndex].properties, ...edge.properties }
+                };
+                await this.save();
+                return this.edges[existingIndex];
+            }
+            this.edges.push(edge);
+            await this.save();
+            return edge;
+        });
+    }
+    /**
+     * Query the graph to find connected nodes.
+     * Simple BFS traversal up to maxDepth.
+     */
+    async query(params) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            let startNodeId = params.startNodeId;
+            // Resolve name to ID if needed
+            if (!startNodeId && params.startNodeName) {
+                const node = Array.from(this.nodes.values()).find(n => n.name.toLowerCase().includes(params.startNodeName.toLowerCase()));
+                if (node)
+                    startNodeId = node.id;
+            }
+            if (!startNodeId) {
+                // If no start node, return everything (or maybe limit?)
+                // For now, let's return everything if specific query is missing, but maybe that's too much.
+                // Better: Return error or empty if no entry point.
+                if (!params.startNodeName)
+                    return { nodes: Array.from(this.nodes.values()), edges: this.edges };
+                return { nodes: [], edges: [] };
+            }
+            const resultNodes = new Set();
+            const resultEdges = [];
+            const resultEdgesSet = new Set(); // To track unique edges
+            const queue = [{ id: startNodeId, depth: 0 }];
+            resultNodes.add(startNodeId);
+            const maxDepth = params.maxDepth || 1;
+            while (queue.length > 0) {
+                const current = queue.shift();
+                if (current.depth >= maxDepth)
+                    continue;
+                // Find outgoing edges
+                const outgoing = this.edges.filter(e => e.source === current.id);
+                // Find incoming edges (optional, but good for context)
+                const incoming = this.edges.filter(e => e.target === current.id);
+                const relevantEdges = [...outgoing, ...incoming];
+                for (const edge of relevantEdges) {
+                    if (params.relationType && edge.relation !== params.relationType)
+                        continue;
+                    // Create a unique key for the edge to prevent duplicates
+                    const edgeKey = `${edge.source}-${edge.target}-${edge.relation}`;
+                    if (!resultEdgesSet.has(edgeKey)) {
+                        resultEdges.push(edge);
+                        resultEdgesSet.add(edgeKey);
+                    }
+                    const neighborId = edge.source === current.id ? edge.target : edge.source;
+                    if (!resultNodes.has(neighborId)) {
+                        resultNodes.add(neighborId);
+                        queue.push({ id: neighborId, depth: current.depth + 1 });
+                    }
+                }
+            }
+            return {
+                nodes: Array.from(resultNodes).map(id => this.nodes.get(id)),
+                edges: resultEdges
+            };
+        });
+    }
+    async deleteNode(id) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            if (!this.nodes.has(id))
+                return false;
+            this.nodes.delete(id);
+            // Remove connected edges
+            this.edges = this.edges.filter(e => e.source !== id && e.target !== id);
+            await this.save();
+            return true;
+        });
+    }
+    async searchNodes(query) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const lowerQuery = query.toLowerCase();
+            return Array.from(this.nodes.values()).filter(n => n.name.toLowerCase().includes(lowerQuery) ||
+                n.label.toLowerCase().includes(lowerQuery) ||
+                JSON.stringify(n.properties).toLowerCase().includes(lowerQuery));
+        });
+    }
+}

package/dist/tools/coding.js

@@ -2,6 +2,9 @@ import { z } from "zod";
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { validatePath } from "../utils.js";
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
 export function registerCodingTools(server, graph) {
     // 14. deep_code_analyze
     server.tool("deep_code_analyze", "Generates a 'Codebase Context Document' for a specific file or task. This tool learns from the codebase structure and symbols to provide deep insights before coding.", {
@@ -85,8 +88,9 @@ export function registerCodingTools(server, graph) {
         path: z.string().describe("Path to the file to edit"),
         oldText: z.string().describe("The exact text to replace"),
         newText: z.string().describe("The new code to insert"),
-        reasoning: z.string().describe("The 'Deepest Thinking' reasoning behind this change")
-    }, async ({ path: filePath, oldText, newText, reasoning }) => {
+        reasoning: z.string().describe("The 'Deepest Thinking' reasoning behind this change"),
+        runTest: z.string().optional().describe("Optional: Shell command to run tests (e.g., 'npm test'). If tests fail, the edit is automatically rolled back.")
+    }, async ({ path: filePath, oldText, newText, reasoning, runTest }) => {
         try {
             const absolutePath = validatePath(filePath);
             const content = await fs.readFile(absolutePath, 'utf-8');
@@ -115,6 +119,33 @@ export function registerCodingTools(server, graph) {
             }
             try {
                 await fs.writeFile(absolutePath, newContent, 'utf-8');
+                // --- TDD: Run Test if requested ---
+                if (runTest) {
+                    try {
+                        // Execute the test command
+                        const { stdout, stderr } = await execAsync(runTest, { cwd: process.cwd() });
+                        // If we get here, exit code was 0 (success)
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `Successfully applied edit to ${filePath} and verified with tests.\n\nReasoning: ${reasoning}\n\nTest Command: '${runTest}'\nTest Result: PASSED ✅\nStdout: ${stdout.trim().slice(0, 200)}...\n(Backup created at ${backupPath})`
+                                }]
+                        };
+                    }
+                    catch (testError) {
+                        // Test failed (non-zero exit code)
+                        console.error(`Test failed for ${filePath}:`, testError);
+                        // Rollback
+                        await fs.copyFile(backupPath, absolutePath);
+                        return {
+                            content: [{
+                                    type: "text",
+                                    text: `⛔ TDD SAFETY ROLLBACK TRIGGERED ⛔\n\nThe edit was applied but the test command '${runTest}' failed.\nChanges have been automatically reverted to the original state.\n\nError Output:\n${testError.stdout || testError.message}\n${testError.stderr || ''}`
+                                }],
+                            isError: true
+                        };
+                    }
+                }
             }
             catch (writeError) {
                 // Rollback attempt

package/dist/tools/graph.js

@@ -76,12 +76,14 @@ export function registerGraphTools(server, knowledgeGraph) {
         }
     });
     // 14. get_project_graph_visualization
-    server.tool("get_project_graph_visualization", "Get a Mermaid Diagram string representing the project's dependency graph. You can render this string in a Markdown viewer that supports Mermaid.", {}, async () => {
+    server.tool("get_project_graph_visualization", "Get a Mermaid Diagram string representing the project's dependency graph. You can render this string in a Markdown viewer that supports Mermaid.", {
+        type: z.enum(['flowchart', 'classDiagram']).optional().default('flowchart').describe("Type of diagram to generate (default: 'flowchart' for file dependencies, 'classDiagram' for class structure)")
+    }, async ({ type }) => {
         try {
-            const diagram = knowledgeGraph.toMermaid();
-            if (diagram.trim() === 'graph TD') {
+            const diagram = knowledgeGraph.toMermaid(type);
+            if (diagram.trim() === 'graph TD' || diagram.trim() === 'classDiagram') {
                 return {
-                    content: [{ type: "text", text: "Graph is empty. Please run 'build_project_graph' first." }],
+                    content: [{ type: "text", text: "Graph is empty or no compatible symbols found. Please run 'build_project_graph' first." }],
                     isError: true
                 };
             }

package/dist/tools/knowledge.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { KnowledgeGraphManager } from '../knowledge.js';
+export declare function registerKnowledgeTools(server: McpServer, graphManager: KnowledgeGraphManager): void;

package/dist/tools/knowledge.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+export function registerKnowledgeTools(server, graphManager) {
+    // 1. add_knowledge_entity
+    server.tool("add_knowledge_entity", "Create a new entity (Node) in the Knowledge Graph. Use this to store structured information about people, teams, concepts, etc.", {
+        label: z.string().describe("Type of entity (e.g., 'Player', 'Team', 'Tactic', 'Concept')"),
+        name: z.string().describe("Name of the entity (e.g., 'Trent Alexander-Arnold', 'Liverpool')"),
+        properties: z.record(z.string(), z.any()).optional().describe("Additional attributes (e.g., { status: 'Injured', position: 'RB' })"),
+        id: z.string().optional().describe("Optional: Specific ID. If omitted, one is generated.")
+    }, async ({ label, name, properties, id }) => {
+        try {
+            const node = await graphManager.addNode({ label, name, properties: properties || {}, id });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Entity added/updated successfully.\nID: ${node.id}\nName: ${node.name} (${node.label})`
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error adding entity: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+        }
+    });
+    // 2. link_knowledge_nodes
+    server.tool("link_knowledge_nodes", "Create a relationship (Edge) between two entities in the Knowledge Graph. Use this to connect facts (e.g., Player -> plays for -> Team).", {
+        sourceId: z.string().describe("ID of the source node"),
+        targetId: z.string().describe("ID of the target node"),
+        relation: z.string().describe("Type of relationship (e.g., 'PLAYS_FOR', 'AFFECTS', 'IS_INJURED')"),
+        weight: z.number().optional().describe("Strength/Weight of connection (0.0 to 1.0)"),
+        properties: z.record(z.string(), z.any()).optional().describe("Edge attributes (e.g., { since: '2024' })")
+    }, async ({ sourceId, targetId, relation, weight, properties }) => {
+        try {
+            const edge = await graphManager.addEdge({
+                source: sourceId,
+                target: targetId,
+                relation,
+                weight,
+                properties
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: `Link created successfully: [${sourceId}] --(${relation})--> [${targetId}]`
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error linking nodes: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+        }
+    });
+    // 3. query_knowledge_graph
+    server.tool("query_knowledge_graph", "Search and traverse the Knowledge Graph to find connected facts. Use this to retrieve context for analysis.", {
+        query: z.string().optional().describe("Search term for node name/label (Start Node)"),
+        nodeId: z.string().optional().describe("Specific Node ID to start traversal from"),
+        relationType: z.string().optional().describe("Filter by relationship type"),
+        maxDepth: z.number().optional().default(1).describe("Traversal depth (default: 1)")
+    }, async ({ query, nodeId, relationType, maxDepth }) => {
+        try {
+            if (!query && !nodeId) {
+                // Fallback: list all nodes if no query (limit to top 20 to avoid spam)
+                const results = await graphManager.searchNodes("");
+                const preview = results.slice(0, 20);
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Graph Overview (${results.length} nodes total):\n${JSON.stringify(preview, null, 2)}`
+                        }]
+                };
+            }
+            const result = await graphManager.query({
+                startNodeId: nodeId,
+                startNodeName: query,
+                relationType,
+                maxDepth
+            });
+            if (result.nodes.length === 0) {
+                return { content: [{ type: "text", text: "No matching knowledge found." }] };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(result, null, 2)
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error querying graph: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+        }
+    });
+    // 4. delete_knowledge_entity
+    server.tool("delete_knowledge_entity", "Remove a node from the Knowledge Graph. Also removes connected edges.", {
+        id: z.string().describe("ID of the node to delete")
+    }, async ({ id }) => {
+        try {
+            const deleted = await graphManager.deleteNode(id);
+            return {
+                content: [{
+                        type: "text",
+                        text: deleted ? `Node ${id} deleted.` : `Node ${id} not found.`
+                    }]
+            };
+        }
+        catch (error) {
+            return { content: [{ type: "text", text: `Error deleting node: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
+        }
+    });
+}

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

@@ -0,0 +1,44 @@
+export interface Prediction {
+    id: string;
+    date: string;
+    league: string;
+    homeTeam: string;
+    awayTeam: string;
+    selection: string;
+    odds: number;
+    stake: number;
+    confidence: number;
+    analysis: string;
+    status: 'pending' | 'won' | 'lost' | 'void';
+    resultScore?: string;
+    profit?: number;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface PredictionStats {
+    totalBets: number;
+    wins: number;
+    losses: number;
+    voids: number;
+    totalStake: number;
+    totalProfit: number;
+    roi: number;
+    winRate: number;
+    strikeRate: number;
+}
+export declare class PredictionTracker {
+    private filePath;
+    private predictions;
+    private lastModifiedTime;
+    private mutex;
+    constructor(storagePath?: string);
+    private load;
+    private save;
+    track(bet: Omit<Prediction, 'id' | 'status' | 'resultScore' | 'profit' | 'createdAt' | 'updatedAt'>): Promise<Prediction>;
+    resolve(id: string, result: 'won' | 'lost' | 'void', score?: string): Promise<Prediction | null>;
+    getStats(filter?: {
+        league?: string;
+        lastDays?: number;
+    }): Promise<PredictionStats>;
+    list(status?: 'pending' | 'completed'): Promise<Prediction[]>;
+}

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

@@ -0,0 +1,160 @@
+import * as fs from 'fs/promises';
+import { existsSync, statSync } from 'fs';
+import * as path from 'path';
+import { AsyncMutex } from '../../../utils.js';
+export class PredictionTracker {
+    filePath;
+    predictions = [];
+    lastModifiedTime = 0;
+    mutex = new AsyncMutex();
+    constructor(storagePath = 'betting_log.json') {
+        this.filePath = path.resolve(storagePath);
+    }
+    async load(forceReload = false) {
+        try {
+            if (!existsSync(this.filePath)) {
+                this.predictions = [];
+                this.lastModifiedTime = 0;
+                return;
+            }
+            const stats = statSync(this.filePath);
+            const currentMtime = stats.mtimeMs;
+            if (!forceReload && currentMtime === this.lastModifiedTime && this.predictions.length > 0) {
+                return;
+            }
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            if (!data.trim()) {
+                this.predictions = [];
+                return;
+            }
+            try {
+                const parsed = JSON.parse(data);
+                if (parsed.version && parsed.predictions) {
+                    this.predictions = parsed.predictions;
+                }
+                else if (Array.isArray(parsed)) {
+                    this.predictions = parsed;
+                }
+                else {
+                    this.predictions = [];
+                }
+                this.lastModifiedTime = currentMtime;
+            }
+            catch (e) {
+                console.error('[PredictionTracker] Parse error:', e);
+                // Basic recovery: initialize empty
+                this.predictions = [];
+            }
+        }
+        catch (error) {
+            console.error('[PredictionTracker] Load error:', error);
+            this.predictions = [];
+        }
+    }
+    async save() {
+        const tmpPath = `${this.filePath}.tmp`;
+        const storage = {
+            version: '1.0',
+            predictions: this.predictions,
+            metadata: {
+                lastModified: new Date().toISOString()
+            }
+        };
+        try {
+            await fs.writeFile(tmpPath, JSON.stringify(storage, null, 2), 'utf-8');
+            await fs.rename(tmpPath, this.filePath);
+            const stats = await fs.stat(this.filePath);
+            this.lastModifiedTime = stats.mtimeMs;
+        }
+        catch (error) {
+            try {
+                await fs.unlink(tmpPath);
+            }
+            catch { }
+            throw error;
+        }
+    }
+    async track(bet) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const now = new Date().toISOString();
+            const prediction = {
+                id: `bet-${Date.now()}-${Math.random().toString(36).substr(2, 5)}`,
+                ...bet,
+                status: 'pending',
+                createdAt: now,
+                updatedAt: now
+            };
+            this.predictions.push(prediction);
+            await this.save();
+            return prediction;
+        });
+    }
+    async resolve(id, result, score) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            const index = this.predictions.findIndex(p => p.id === id);
+            if (index === -1)
+                return null;
+            const p = this.predictions[index];
+            p.status = result;
+            p.resultScore = score;
+            p.updatedAt = new Date().toISOString();
+            if (result === 'won') {
+                p.profit = (p.stake * p.odds) - p.stake;
+            }
+            else if (result === 'lost') {
+                p.profit = -p.stake;
+            }
+            else {
+                p.profit = 0;
+            }
+            await this.save();
+            return p;
+        });
+    }
+    async getStats(filter) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            let bets = this.predictions;
+            if (filter?.league) {
+                bets = bets.filter(p => p.league.toLowerCase().includes(filter.league.toLowerCase()));
+            }
+            if (filter?.lastDays) {
+                const cutoff = new Date();
+                cutoff.setDate(cutoff.getDate() - filter.lastDays);
+                bets = bets.filter(p => new Date(p.date) >= cutoff);
+            }
+            // Only count resolved bets for win rate/roi
+            const resolved = bets.filter(p => p.status !== 'pending');
+            const wins = resolved.filter(p => p.status === 'won').length;
+            const losses = resolved.filter(p => p.status === 'lost').length;
+            const voids = resolved.filter(p => p.status === 'void').length;
+            const totalStake = resolved.reduce((sum, p) => sum + p.stake, 0);
+            const totalProfit = resolved.reduce((sum, p) => sum + (p.profit || 0), 0);
+            return {
+                totalBets: bets.length,
+                wins,
+                losses,
+                voids,
+                totalStake,
+                totalProfit,
+                roi: totalStake > 0 ? (totalProfit / totalStake) * 100 : 0,
+                winRate: resolved.length > 0 ? (wins / resolved.length) * 100 : 0,
+                strikeRate: (wins + losses) > 0 ? (wins / (wins + losses)) * 100 : 0
+            };
+        });
+    }
+    async list(status) {
+        return this.mutex.dispatch(async () => {
+            await this.load();
+            if (status === 'pending') {
+                return this.predictions.filter(p => p.status === 'pending');
+            }
+            if (status === 'completed') {
+                return this.predictions.filter(p => p.status !== 'pending');
+            }
+            return this.predictions;
+        });
+    }
+}

package/dist/tools/sports/tools/team.js

@@ -8,6 +8,7 @@ import { getSearchProvider } from '../providers/search.js';
 import { getGlobalCache, CacheService } from '../core/cache.js';
 import { formatStandingsTable, formatComparisonResult } from '../utils/formatter.js';
 import { CACHE_CONFIG, LEAGUES } from '../core/constants.js';
+import { generateRadarChartUrl } from '../utils/charts.js';
 // ============= Helper Functions =============
 /**
  * Get league ID from league name
@@ -29,6 +30,39 @@ function getLeagueId(leagueName) {
     }
     return undefined;
 }
+/**
+ * Calculate normalized metrics (0-100) for radar chart
+ */
+function calculateMetrics(team) {
+    // Default [Attack, Defense, Form, Position, WinRate]
+    if (!team.stats)
+        return [50, 50, 50, 50, 50];
+    const s = team.stats;
+    const mp = s.matchesPlayed || 1;
+    // Attack: Goals per game (max ~3.0)
+    // 3.0 GPG = 100, 0.0 GPG = 0
+    const attack = Math.min(((s.goalsFor || 0) / mp) / 3.0 * 100, 100);
+    // Defense: Goals against per game (max ~3.0). Inverted.
+    // 0.0 GA = 100, 3.0 GA = 0
+    const gaPerGame = (s.goalsAgainst || 0) / mp;
+    const defense = Math.max(0, 100 - (gaPerGame / 3.0 * 100));
+    // Form: Last 5 points. Max 15.
+    let form = 50;
+    if (s.form) {
+        // Parse form string e.g. "WWDLL" or array
+        // Force to string to avoid runtime errors if API returns unexpected type
+        const formStr = String(Array.isArray(s.form) ? s.form.join('') : s.form);
+        const wins = (formStr.match(/W/g) || []).length;
+        const draws = (formStr.match(/D/g) || []).length;
+        const points = (wins * 3) + draws;
+        form = (points / 15) * 100;
+    }
+    // Position: 1-20. 1st=100, 20th=5.
+    const position = s.position ? Math.max(0, (21 - s.position) / 20 * 100) : 50;
+    // Win Rate: Wins / Matches * 100
+    const winRate = (s.wins / mp) * 100;
+    return [attack, defense, form, position, winRate].map(n => Math.round(n));
+}
 /**
  * Search for team by name using web search
  */
@@ -138,6 +172,9 @@ async function compareTeamsAnalysis(teamAName, teamBName) {
             else {
                 summary += `The teams are relatively evenly matched in terms of league standing. `;
             }
+            // Generate Radar Chart
+            const chartUrl = generateRadarChartUrl({ name: teamA.name, data: calculateMetrics(teamA) }, { name: teamB.name, data: calculateMetrics(teamB) });
+            summary += `\n\n![Visual Comparison](${chartUrl})\n\n`;
         }
         else {
             summary += `Detailed statistics not available via API. `;

package/dist/tools/sports/tools/tracker.d.ts

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

package/dist/tools/sports/tools/tracker.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { PredictionTracker } from "../core/tracker.js";
+const tracker = new PredictionTracker();
+export function registerTrackerTools(server) {
+    // 1. Log a new prediction
+    server.tool("track_prediction", "Log a sports prediction/bet to the ROI Tracker system. Use this immediately after generating a prediction to verify performance later.", {
+        league: z.string().describe("League name"),
+        homeTeam: z.string().describe("Home team name"),
+        awayTeam: z.string().describe("Away team name"),
+        selection: z.string().describe("The specific bet/prediction (e.g., 'Arsenal Win', 'Over 2.5 Goals')"),
+        odds: z.number().describe("Decimal odds at time of prediction"),
+        stake: z.number().describe("Stake units (1-10 recommended based on confidence)"),
+        confidence: z.number().min(0).max(100).describe("Confidence score (0-100)"),
+        analysis: z.string().describe("Brief summary of why this bet was picked"),
+        date: z.string().optional().describe("Match date (ISO format). Defaults to now if omitted.")
+    }, async (args) => {
+        const result = await tracker.track({
+            ...args,
+            date: args.date || new Date().toISOString()
+        });
+        return {
+            content: [{ type: "text", text: `Prediction logged successfully.\nID: ${result.id}\nSelection: ${result.selection} @ ${result.odds}\nStatus: PENDING` }]
+        };
+    });
+    // 2. Resolve a prediction
+    server.tool("resolve_prediction", "Update the status of a pending prediction (Win/Loss/Void). Use this after verifying match results.", {
+        id: z.string().describe("The Prediction ID (from track_prediction)"),
+        result: z.enum(['won', 'lost', 'void']).describe("The outcome of the bet"),
+        score: z.string().optional().describe("Final match score (e.g., '2-1')")
+    }, async ({ id, result, score }) => {
+        const updated = await tracker.resolve(id, result, score);
+        if (!updated) {
+            return { content: [{ type: "text", text: `Error: Prediction with ID '${id}' not found.` }], isError: true };
+        }
+        const profitStr = updated.profit > 0 ? `+${updated.profit.toFixed(2)}` : `${updated.profit}`;
+        return {
+            content: [{ type: "text", text: `Prediction resolved: ${result.toUpperCase()}\nProfit: ${profitStr} units\nROI Status updated.` }]
+        };
+    });
+    // 3. Analyze Performance
+    server.tool("analyze_roi", "Analyze the AI's betting performance (ROI, Strike Rate, Profit) to identify strengths and weaknesses.", {
+        league: z.string().optional().describe("Filter by specific league"),
+        lastDays: z.number().optional().describe("Analyze only the last N days")
+    }, async ({ league, lastDays }) => {
+        const stats = await tracker.getStats({ league, lastDays });
+        const roiColor = stats.roi > 0 ? "🟢" : (stats.roi < 0 ? "🔴" : "⚪");
+        let report = `--- 📊 ROI PERFORMANCE REPORT ---\n`;
+        if (league)
+            report += `Filter: League='${league}'\n`;
+        if (lastDays)
+            report += `Filter: Last ${lastDays} days\n`;
+        report += `\nTotal Bets: ${stats.totalBets}`;
+        report += `\nWin Rate:   ${stats.winRate.toFixed(1)}% (${stats.wins}W - ${stats.losses}L - ${stats.voids}V)`;
+        report += `\nTotal Stake: ${stats.totalStake.toFixed(1)}`;
+        report += `\nTotal Profit: ${stats.totalProfit > 0 ? '+' : ''}${stats.totalProfit.toFixed(2)}`;
+        report += `\nROI:        ${roiColor} ${stats.roi.toFixed(2)}%`;
+        return {
+            content: [{ type: "text", text: report }]
+        };
+    });
+    // 4. List Pending Predictions
+    server.tool("get_pending_predictions", "Get a list of all unresolved predictions that need result verification.", {}, async () => {
+        const pending = await tracker.list('pending');
+        if (pending.length === 0) {
+            return { content: [{ type: "text", text: "No pending predictions." }] };
+        }
+        let list = "--- PENDING PREDICTIONS ---\n";
+        pending.forEach(p => {
+            list += `- [${p.id}] ${p.homeTeam} vs ${p.awayTeam}: ${p.selection} @ ${p.odds} (${new Date(p.date).toLocaleDateString()})\n`;
+        });
+        return { content: [{ type: "text", text: list }] };
+    });
+}

package/dist/tools/sports/utils/charts.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Chart Generation Utilities using QuickChart.io
+ */
+export interface TeamMetrics {
+    name: string;
+    data: number[];
+}
+export declare function generateRadarChartUrl(teamA: TeamMetrics, teamB: TeamMetrics, labels?: string[]): string;

package/dist/tools/sports/utils/charts.js

@@ -0,0 +1,38 @@
+/**
+ * Chart Generation Utilities using QuickChart.io
+ */
+export function generateRadarChartUrl(teamA, teamB, labels = ['Attack', 'Defense', 'Form', 'Position', 'Win Rate']) {
+    const chartConfig = {
+        type: 'radar',
+        data: {
+            labels: labels,
+            datasets: [
+                {
+                    label: teamA.name,
+                    data: teamA.data,
+                    backgroundColor: 'rgba(255, 99, 132, 0.2)',
+                    borderColor: 'rgba(255, 99, 132, 1)',
+                    pointBackgroundColor: 'rgba(255, 99, 132, 1)',
+                },
+                {
+                    label: teamB.name,
+                    data: teamB.data,
+                    backgroundColor: 'rgba(54, 162, 235, 0.2)',
+                    borderColor: 'rgba(54, 162, 235, 1)',
+                    pointBackgroundColor: 'rgba(54, 162, 235, 1)',
+                }
+            ]
+        },
+        options: {
+            scale: {
+                ticks: {
+                    beginAtZero: true,
+                    min: 0,
+                    max: 100
+                }
+            }
+        }
+    };
+    const json = JSON.stringify(chartConfig);
+    return `https://quickchart.io/chart?c=${encodeURIComponent(json)}`;
+}

package/dist/tools/sports.js

@@ -8,6 +8,7 @@ import { registerTeamTools } from "./sports/tools/team.js";
 import { registerPlayerTools } from "./sports/tools/player.js";
 import { registerBettingTools } from "./sports/tools/betting.js";
 import { registerLiveTools } from "./sports/tools/live.js";
+import { registerTrackerTools } from "./sports/tools/tracker.js";
 // Legacy support - keep original analyze_football_match
 import { z } from "zod";
 import { fetchWithRetry } from "../utils.js";
@@ -22,6 +23,7 @@ export function registerSportsTools(server) {
     registerPlayerTools(server);
     registerBettingTools(server);
     registerLiveTools(server);
+    registerTrackerTools(server);
     // Keep original analyze_football_match for backward compatibility
     registerLegacyAnalyzeMatch(server);
 }

package/package.json

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