@gotza02/sequential-thinking 10000.0.0 → 10000.0.2

package/dist/knowledge.test.js

@@ -0,0 +1,105 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { KnowledgeGraphManager } from './knowledge.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+vi.mock('fs', () => ({
+    existsSync: vi.fn(() => true),
+    statSync: vi.fn(() => ({ mtimeMs: 123456789 })),
+    readFileSync: vi.fn()
+}));
+describe('KnowledgeGraphManager', () => {
+    let manager;
+    const testPath = 'test_graph.json';
+    let mockStore = '{}';
+    beforeEach(() => {
+        mockStore = '{}';
+        fs.readFile.mockImplementation(async () => mockStore);
+        fs.writeFile.mockImplementation(async (path, data) => {
+            mockStore = data;
+        });
+        fs.stat.mockImplementation(async () => ({ mtimeMs: 123456789 }));
+        fs.rename.mockImplementation(async () => { });
+        manager = new KnowledgeGraphManager(testPath);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should add a node correctly', async () => {
+        const node = await manager.addNode({
+            label: 'Player',
+            name: 'Trent Alexander-Arnold',
+            properties: { position: 'RB' }
+        });
+        expect(node.id).toBeDefined();
+        expect(node.name).toBe('Trent Alexander-Arnold');
+        // Verify storage update
+        const stored = JSON.parse(mockStore);
+        expect(stored.nodes).toHaveLength(1);
+    });
+    it('should deduplicate nodes by name and label', async () => {
+        const n1 = await manager.addNode({ label: 'Team', name: 'Liverpool', properties: {} });
+        const n2 = await manager.addNode({ label: 'Team', name: 'liverpool', properties: { league: 'PL' } });
+        expect(n1.id).toBe(n2.id); // Should be same ID
+        expect(n2.properties.league).toBe('PL'); // Should update properties
+        const stored = JSON.parse(mockStore);
+        expect(stored.nodes).toHaveLength(1);
+    });
+    it('should create relationships (edges)', async () => {
+        const player = await manager.addNode({ label: 'Player', name: 'Salah', properties: {} });
+        const team = await manager.addNode({ label: 'Team', name: 'Liverpool', properties: {} });
+        const edge = await manager.addEdge({
+            source: player.id,
+            target: team.id,
+            relation: 'PLAYS_FOR'
+        });
+        expect(edge.relation).toBe('PLAYS_FOR');
+        const stored = JSON.parse(mockStore);
+        expect(stored.edges).toHaveLength(1);
+    });
+    it('should traverse the graph (User Scenario: Tactic Impact)', async () => {
+        // Setup the scenario: Player Injury -> Tactic -> Win Probability
+        const player = await manager.addNode({
+            label: 'Player',
+            name: 'Trent',
+            properties: { status: 'Injured' }
+        });
+        const tactic = await manager.addNode({
+            label: 'Tactic',
+            name: 'Right-Side Attack',
+            properties: {}
+        });
+        const prediction = await manager.addNode({
+            label: 'Prediction',
+            name: 'Win Chance',
+            properties: {}
+        });
+        await manager.addEdge({ source: player.id, target: tactic.id, relation: 'AFFECTS' });
+        await manager.addEdge({ source: tactic.id, target: prediction.id, relation: 'IMPACTS' });
+        // Query starting from Trent
+        const result = await manager.query({
+            startNodeId: player.id,
+            maxDepth: 2
+        });
+        // Should find all 3 nodes
+        expect(result.nodes).toHaveLength(3);
+        const names = result.nodes.map(n => n.name);
+        expect(names).toContain('Trent');
+        expect(names).toContain('Right-Side Attack');
+        expect(names).toContain('Win Chance');
+        // Should find edges
+        expect(result.edges).toHaveLength(2);
+    });
+    it('should filter query by relation type', async () => {
+        const n1 = await manager.addNode({ label: 'A', name: 'A', properties: {} });
+        const n2 = await manager.addNode({ label: 'B', name: 'B', properties: {} });
+        const n3 = await manager.addNode({ label: 'C', name: 'C', properties: {} });
+        await manager.addEdge({ source: n1.id, target: n2.id, relation: 'FRIEND' });
+        await manager.addEdge({ source: n1.id, target: n3.id, relation: 'ENEMY' });
+        const result = await manager.query({
+            startNodeId: n1.id,
+            relationType: 'FRIEND'
+        });
+        expect(result.nodes).toHaveLength(2); // A and B
+        expect(result.nodes.map(n => n.name)).not.toContain('C');
+    });
+});

package/dist/lib.js

@@ -497,6 +497,7 @@ ${typeof wrappedThought === 'string' && wrappedThought.startsWith('│') ? wrapp
                                     "🚨 CONFIDENCE CRITICAL (<50). Execution blocked to prevent further damage.",
                                     "🛑 STOP: You are likely in a loop or making repeated errors.",
                                     "👉 REQUIRED ACTION: You must switch thoughtType to 'reflexion' to critique your errors.",
+                                    "⚠️ REMEMBER: You MUST provide a 'thought' string explaining your reflection. Do not leave it empty.",
                                     recoveryAdvice
                                 ],
                                 confidenceScore: this.confidenceScore

package/dist/notes.test.d.ts

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

package/dist/notes.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { NotesManager } from './notes.js';
+import * as fs from 'fs/promises';
+vi.mock('fs/promises');
+vi.mock('fs', () => ({
+    existsSync: vi.fn(() => true),
+    statSync: vi.fn(() => ({ mtimeMs: 123456789 })),
+    readFileSync: vi.fn()
+}));
+describe('NotesManager', () => {
+    let manager;
+    const testPath = 'test_notes.json';
+    let mockStore = '[]';
+    beforeEach(() => {
+        mockStore = '[]';
+        fs.readFile.mockImplementation(async () => mockStore);
+        fs.writeFile.mockImplementation(async (path, data) => {
+            mockStore = data;
+        });
+        fs.stat.mockImplementation(async () => ({ mtimeMs: 123456789 }));
+        manager = new NotesManager(testPath);
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should add a note correctly', async () => {
+        const note = await manager.addNote("Test Title", "Test Content", ["tag1"]);
+        expect(note.title).toBe("Test Title");
+        expect(note.tags).toContain("tag1");
+        // Check new format
+        const stored = JSON.parse(mockStore);
+        const storedNotes = stored.notes || stored;
+        expect(storedNotes).toHaveLength(1);
+    });
+    it('should list notes with sorting by priority', async () => {
+        await manager.addNote("Low Prio", "Content", [], "low");
+        await manager.addNote("High Prio", "Content", [], "high");
+        const notes = await manager.listNotes();
+        expect(notes).toHaveLength(2);
+        expect(notes[0].priority).toBe('high');
+        expect(notes[1].priority).toBe('low');
+    });
+    it('should filter notes by tag', async () => {
+        await manager.addNote("Note 1", "Content", ["react"]);
+        await manager.addNote("Note 2", "Content", ["vue"]);
+        const reactNotes = await manager.listNotes('react');
+        expect(reactNotes).toHaveLength(1);
+        expect(reactNotes[0].title).toBe("Note 1");
+    });
+    it('should search notes by query', async () => {
+        await manager.addNote("Deploy Script", "Run npm build", ["devops"]);
+        await manager.addNote("Meeting Notes", "Discuss API", ["meeting"]);
+        const results = await manager.searchNotes("build");
+        expect(results).toHaveLength(1);
+        expect(results[0].title).toBe("Deploy Script");
+    });
+    it('should update a note', async () => {
+        const note = await manager.addNote("Original", "Content");
+        const updated = await manager.updateNote(note.id, { title: "Updated" });
+        expect(updated?.title).toBe("Updated");
+        expect(updated?.content).toBe("Content"); // Should remain
+        const list = await manager.listNotes();
+        expect(list[0].title).toBe("Updated");
+    });
+    it('should delete a note', async () => {
+        const note = await manager.addNote("To Delete", "Content");
+        const success = await manager.deleteNote(note.id);
+        expect(success).toBe(true);
+        const list = await manager.listNotes();
+        expect(list).toHaveLength(0);
+    });
+    it('should hide expired notes by default', async () => {
+        // Expired yesterday
+        const yesterday = new Date();
+        yesterday.setDate(yesterday.getDate() - 1);
+        await manager.addNote("Expired", "Content", [], "medium", yesterday.toISOString());
+        await manager.addNote("Active", "Content");
+        const list = await manager.listNotes();
+        expect(list).toHaveLength(1);
+        expect(list[0].title).toBe("Active");
+        const all = await manager.listNotes(undefined, true);
+        expect(all).toHaveLength(2);
+    });
+});

package/dist/registration.test.d.ts

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

package/dist/registration.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from 'vitest';
+import { registerThinkingTools } from './tools/thinking.js';
+import { registerGraphTools } from './tools/graph.js';
+import { registerNoteTools } from './tools/notes.js';
+import { registerWebTools } from './tools/web.js';
+import { registerFileSystemTools } from './tools/filesystem.js';
+import { registerCodingTools } from './tools/coding.js';
+import { registerCodeDbTools } from './tools/codestore.js';
+describe('Tool Registration', () => {
+    it('should register all tools without duplicates', () => {
+        const registeredTools = new Set();
+        const mockServer = {
+            tool: (name, desc, schema, cb) => {
+                if (registeredTools.has(name)) {
+                    throw new Error(`Duplicate tool name: ${name}`);
+                }
+                registeredTools.add(name);
+            }
+        };
+        // Mock dependencies
+        const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn(), archiveHistory: vi.fn() };
+        const mockGraph = { build: vi.fn(), getRelationships: vi.fn(), getSummary: vi.fn(), toMermaid: vi.fn() };
+        const mockNotes = {};
+        const mockCodeDb = {};
+        registerThinkingTools(mockServer, mockThinking);
+        registerGraphTools(mockServer, mockGraph);
+        registerNoteTools(mockServer, mockNotes);
+        registerWebTools(mockServer);
+        registerFileSystemTools(mockServer);
+        registerCodingTools(mockServer, mockGraph);
+        registerCodeDbTools(mockServer, mockCodeDb);
+        expect(registeredTools.has('sequentialthinking')).toBe(true);
+        expect(registeredTools.has('build_project_graph')).toBe(true);
+        expect(registeredTools.has('read_file')).toBe(true);
+        expect(registeredTools.has('web_search')).toBe(true);
+        // ... and so on
+        console.log('Registered tools:', Array.from(registeredTools).join(', '));
+    });
+});

package/dist/server.test.d.ts

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

package/dist/server.test.js

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { SequentialThinkingServer } from './lib.js';
+import * as fs from 'fs';
+describe('SequentialThinkingServer', () => {
+    let server;
+    const testStoragePath = 'test_thoughts.json';
+    beforeEach(() => {
+        if (fs.existsSync(testStoragePath)) {
+            fs.unlinkSync(testStoragePath);
+        }
+        server = new SequentialThinkingServer(testStoragePath);
+    });
+    afterAll(() => {
+        if (fs.existsSync(testStoragePath)) {
+            fs.unlinkSync(testStoragePath);
+        }
+    });
+    it('should process a basic linear thought', async () => {
+        const input = {
+            thought: "First step",
+            thoughtNumber: 1,
+            totalThoughts: 3,
+            nextThoughtNeeded: true,
+            thoughtType: 'analysis'
+        };
+        const result = await server.processThought(input);
+        expect(result.isError).toBeUndefined();
+        const content = JSON.parse(result.content[0].text);
+        expect(content.thoughtNumber).toBe(1);
+        expect(content.thoughtHistoryLength).toBe(1);
+    });
+    it('should handle branching correctly', async () => {
+        // Initial thought
+        await server.processThought({
+            thought: "Root thought",
+            thoughtNumber: 1,
+            totalThoughts: 3,
+            nextThoughtNeeded: true
+        });
+        // Branch 1
+        const branch1Input = {
+            thought: "Alternative A",
+            thoughtNumber: 2,
+            totalThoughts: 3,
+            nextThoughtNeeded: true,
+            branchFromThought: 1,
+            branchId: "branch-A",
+            thoughtType: 'generation'
+        };
+        const result1 = await server.processThought(branch1Input);
+        const content1 = JSON.parse(result1.content[0].text);
+        expect(content1.branches).toContain("1-branch-A");
+        // Branch 2
+        const branch2Input = {
+            thought: "Alternative B",
+            thoughtNumber: 2,
+            totalThoughts: 3,
+            nextThoughtNeeded: true,
+            branchFromThought: 1,
+            branchId: "branch-B",
+            thoughtType: 'generation'
+        };
+        const result2 = await server.processThought(branch2Input);
+        const content2 = JSON.parse(result2.content[0].text);
+        expect(content2.branches).toContain("1-branch-B");
+        expect(content2.branches.length).toBe(2);
+    });
+    it('should handle evaluation with scores', async () => {
+        const input = {
+            thought: "Evaluating option X",
+            thoughtNumber: 3,
+            totalThoughts: 5,
+            nextThoughtNeeded: true,
+            thoughtType: 'evaluation',
+            score: 8,
+            options: ['Option X', 'Option Y']
+        };
+        const result = await server.processThought(input);
+        expect(result.isError).toBeUndefined();
+        // Since we don't return the score in the simple JSON response (only in logs or history),
+        // we mainly check that it doesn't crash and processes correctly.
+        // If we exposed history in the response, we could check that too.
+    });
+    it('should adjust totalThoughts if thoughtNumber exceeds it', async () => {
+        const input = {
+            thought: "Unexpected long process",
+            thoughtNumber: 6,
+            totalThoughts: 5,
+            nextThoughtNeeded: true
+        };
+        const result = await server.processThought(input);
+        const content = JSON.parse(result.content[0].text);
+        expect(content.totalThoughts).toBe(6);
+    });
+    it('should clear thought history', async () => {
+        await server.processThought({
+            thought: "To be forgotten",
+            thoughtNumber: 1,
+            totalThoughts: 1,
+            nextThoughtNeeded: false
+        });
+        await server.clearHistory();
+        // Since we can't easily peek into private state, we'll process a new thought
+        // and check if thoughtHistoryLength is 1 (meaning it started over or is just this one)
+        const result = await server.processThought({
+            thought: "Fresh start",
+            thoughtNumber: 1,
+            totalThoughts: 1,
+            nextThoughtNeeded: false
+        });
+        const content = JSON.parse(result.content[0].text);
+        expect(content.thoughtHistoryLength).toBe(1);
+    });
+    it('should summarize history correctly', async () => {
+        // Add 3 thoughts
+        await server.processThought({ thought: "T1", thoughtNumber: 1, totalThoughts: 3, nextThoughtNeeded: true });
+        await server.processThought({ thought: "T2", thoughtNumber: 2, totalThoughts: 3, nextThoughtNeeded: true });
+        await server.processThought({ thought: "T3", thoughtNumber: 3, totalThoughts: 3, nextThoughtNeeded: false });
+        const result = await server.archiveHistory(1, 2, "Summary of T1 and T2");
+        expect(result.newHistoryLength).toBe(2); // Summary + T3
+        expect(result.summaryInsertedAt).toBe(1);
+    });
+    it('should throw error when summarizing invalid range', async () => {
+        await server.processThought({ thought: "T1", thoughtNumber: 1, totalThoughts: 1, nextThoughtNeeded: false });
+        await expect(server.archiveHistory(1, 5, "Invalid")).rejects.toThrow();
+    });
+});

package/dist/stress.test.d.ts

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

package/dist/stress.test.js

@@ -0,0 +1,72 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SequentialThinkingServer } from './lib.js';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// Mock fs for graph test
+vi.mock('fs/promises', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        readdir: vi.fn(),
+        readFile: vi.fn(),
+        writeFile: vi.fn(),
+        rename: vi.fn(),
+        unlink: vi.fn(),
+        stat: vi.fn().mockImplementation(async (p) => ({
+            isDirectory: () => p === path.resolve('.') || p === '.',
+            mtimeMs: Date.now()
+        }))
+    };
+});
+// Mock existsSync and readFileSync from 'fs' (non-promise) for SequentialThinkingServer
+vi.mock('fs', async () => {
+    return {
+        existsSync: () => false,
+        readFileSync: () => '[]',
+        unlinkSync: () => { }
+    };
+});
+describe('Stress Testing', () => {
+    it('should handle 1000 sequential thoughts', async () => {
+        // We use a real instance but mocked fs
+        const server = new SequentialThinkingServer('stress_thoughts.json');
+        const startTime = Date.now();
+        for (let i = 1; i <= 1000; i++) {
+            await server.processThought({
+                thought: `Thought ${i}`,
+                thoughtNumber: i,
+                totalThoughts: 1000,
+                nextThoughtNeeded: i < 1000
+            });
+        }
+        const duration = Date.now() - startTime;
+        console.log(`Processed 1000 thoughts in ${duration}ms`);
+        expect(duration).toBeLessThan(15000); // Should be fast enough (< 15s)
+    }, 15000);
+    it('should handle large graph construction', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        // Mock 1000 files
+        const files = Array.from({ length: 1000 }, (_, i) => `file${i}.ts`);
+        // Mock readdir to return these files (recursively? no, just flat for stress test)
+        // logic in getAllFiles is recursive. We need to mock it to return all at once or handle recursion.
+        // Actually, ProjectKnowledgeGraph.getAllFiles calls readdir.
+        // Let's mock readdir to return files for root, and then nothing for subdirs.
+        fs.readdir.mockImplementation(async (dir) => {
+            if (dir === path.resolve('.')) {
+                return files.map(f => ({
+                    name: f,
+                    isDirectory: () => false
+                }));
+            }
+            return [];
+        });
+        fs.readFile.mockResolvedValue("import { x } from './file0';");
+        const startTime = Date.now();
+        const result = await graph.build('.');
+        const duration = Date.now() - startTime;
+        console.log(`Built graph of ${result.totalFiles} files in ${duration}ms`);
+        expect(result.totalFiles).toBe(1000);
+        expect(duration).toBeLessThan(5000);
+    });
+});

package/dist/tools/codestore_tools.test.d.ts

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

package/dist/tools/codestore_tools.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerCodeDbTools } from './codestore.js';
+describe('CodeStore Tools', () => {
+    let mockServer;
+    let mockDb;
+    let registeredTools;
+    beforeEach(() => {
+        registeredTools = new Map();
+        mockServer = {
+            tool: (name, description, schema, handler) => {
+                registeredTools.set(name, handler);
+            }
+        };
+        mockDb = {
+            addSnippet: vi.fn(),
+            searchSnippets: vi.fn(),
+            listAllPatterns: vi.fn(),
+            learnPattern: vi.fn()
+        };
+        registerCodeDbTools(mockServer, mockDb);
+    });
+    describe('add_code_snippet', () => {
+        it('should add a snippet successfully', async () => {
+            const handler = registeredTools.get('add_code_snippet');
+            const mockSnippet = { id: '123', title: 'Test', code: 'console.log()', language: 'ts' };
+            mockDb.addSnippet.mockResolvedValue(mockSnippet);
+            const result = await handler({
+                title: 'Test',
+                code: 'console.log()',
+                language: 'ts',
+                description: 'test desc'
+            });
+            expect(mockDb.addSnippet).toHaveBeenCalledWith(expect.objectContaining({
+                title: 'Test',
+                code: 'console.log()'
+            }));
+            expect(result.content[0].text).toContain('Snippet saved with ID: 123');
+        });
+        it('should handle errors gracefully', async () => {
+            const handler = registeredTools.get('add_code_snippet');
+            mockDb.addSnippet.mockRejectedValue(new Error('Database error'));
+            const result = await handler({
+                title: 'Test',
+                code: 'console.log()',
+                language: 'ts',
+                description: 'test desc'
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Error adding snippet: Database error');
+        });
+    });
+    describe('search_code_db', () => {
+        it('should search snippets and patterns', async () => {
+            const handler = registeredTools.get('search_code_db');
+            const mockSnippets = [{
+                    snippet: {
+                        id: '1',
+                        title: 'Auth',
+                        code: 'login()',
+                        language: 'ts',
+                        description: 'Login flow',
+                        tags: [],
+                        updatedAt: '2023-01-01'
+                    },
+                    relevance: 1
+                }];
+            const mockPatterns = { 'auth-flow': 'How auth works' };
+            mockDb.searchSnippets.mockResolvedValue(mockSnippets);
+            mockDb.listAllPatterns.mockResolvedValue(mockPatterns);
+            const result = await handler({ query: 'auth' });
+            expect(mockDb.searchSnippets).toHaveBeenCalledWith('auth');
+            expect(mockDb.listAllPatterns).toHaveBeenCalled();
+            expect(result.content[0].text).toContain('SNIPPETS FOUND');
+            expect(result.content[0].text).toContain('Login flow');
+            expect(result.content[0].text).toContain('PATTERNS FOUND');
+            expect(result.content[0].text).toContain('auth-flow');
+        });
+        it('should report no results found', async () => {
+            const handler = registeredTools.get('search_code_db');
+            mockDb.searchSnippets.mockResolvedValue([]);
+            mockDb.listAllPatterns.mockResolvedValue({});
+            const result = await handler({ query: 'xyz' });
+            expect(result.content[0].text).toContain('No results found in the Code Database');
+        });
+        it('should handle errors gracefully', async () => {
+            const handler = registeredTools.get('search_code_db');
+            mockDb.searchSnippets.mockRejectedValue(new Error('Search failed'));
+            const result = await handler({ query: 'test' });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Error searching code DB: Search failed');
+        });
+    });
+    describe('learn_architecture_pattern', () => {
+        it('should learn a pattern successfully', async () => {
+            const handler = registeredTools.get('learn_architecture_pattern');
+            mockDb.learnPattern.mockResolvedValue(undefined);
+            const result = await handler({
+                name: 'test-pattern',
+                description: 'test description'
+            });
+            expect(mockDb.learnPattern).toHaveBeenCalledWith('test-pattern', 'test description');
+            expect(result.content[0].text).toContain("Pattern 'test-pattern' learned");
+        });
+        it('should handle errors gracefully', async () => {
+            const handler = registeredTools.get('learn_architecture_pattern');
+            mockDb.learnPattern.mockRejectedValue(new Error('Learn failed'));
+            const result = await handler({
+                name: 'test-pattern',
+                description: 'test description'
+            });
+            expect(result.isError).toBe(true);
+            expect(result.content[0].text).toContain('Error learning pattern: Learn failed');
+        });
+    });
+});

package/dist/tools/filesystem.js

@@ -251,6 +251,7 @@ export function registerFileSystemTools(server) {
                 try {
                     const content = await fs.readFile(filePath, 'utf-8');
                     // Skip binary-like files (high proportion of non-printable chars)
+                    // eslint-disable-next-line no-control-regex
                     const nonPrintableRatio = (content.match(/[\x00-\x08\x0E-\x1F]/g) || []).length / content.length;
                     if (nonPrintableRatio > 0.3) {
                         return; // Likely binary file

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

@@ -31,7 +31,8 @@ export declare const CACHE_CONFIG: {
     readonly MAX_SIZE: 1000;
 };
 export declare const SCRAPER_CONFIG: {
-    readonly PRIORITY_DOMAINS: readonly ["whoscored.com", "sofascore.com", "flashscore.com", "understat.com", "fbref.com", "bbc.co.uk/sport", "skysports.com", "sportsmole.co.uk", "goal.com", "thesquareball.net"];
+    readonly PRIORITY_DOMAINS: readonly ["understat.com", "bbc.co.uk/sport", "sportsmole.co.uk", "skysports.com", "goal.com", "thesquareball.net", "fbref.com", "whoscored.com", "sofascore.com", "flashscore.com"];
+    readonly NEWS_DOMAINS: readonly ["bbc.co.uk/sport", "skysports.com", "sportsmole.co.uk", "standard.co.uk/sport", "goal.com", "espn.co.uk/football", "talksport.com", "mirror.co.uk/sport", "dailymail.co.uk/sport"];
     readonly TIMEOUT: 15000;
     readonly USER_AGENT: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36";
     readonly MAX_CONTENT_LENGTH: 50000;

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

@@ -44,16 +44,28 @@ export const CACHE_CONFIG = {
 export const SCRAPER_CONFIG = {
     // Priority domains for sports data
     PRIORITY_DOMAINS: [
-        'whoscored.com',
-        'sofascore.com',
-        'flashscore.com',
-        'understat.com',
-        'fbref.com',
+        'understat.com', // High accuracy (Smart Extractor)
+        'bbc.co.uk/sport', // Text-heavy, reliable
+        'sportsmole.co.uk', // Text-heavy, reliable
+        'skysports.com', // Good text/stats mix
+        'goal.com', // Text-heavy
+        'thesquareball.net', // Text-heavy
+        'fbref.com', // Structured data
+        'whoscored.com', // Hard to scrape (JS heavy)
+        'sofascore.com', // Hard to scrape (JS heavy)
+        'flashscore.com', // Hard to scrape (JS heavy)
+    ],
+    // News-focused domains (for lineups, injuries)
+    NEWS_DOMAINS: [
         'bbc.co.uk/sport',
         'skysports.com',
         'sportsmole.co.uk',
+        'standard.co.uk/sport',
         'goal.com',
-        'thesquareball.net'
+        'espn.co.uk/football',
+        'talksport.com',
+        'mirror.co.uk/sport',
+        'dailymail.co.uk/sport'
     ],
     // Scraping timeout in milliseconds
     TIMEOUT: 15000,

package/dist/tools/sports/providers/scraper.d.ts

@@ -20,7 +20,8 @@ export declare class ScraperProvider extends ScraperProviderBase {
      */
     protected scrape<T>(url: string, extractor?: (html: string) => T): Promise<APIResponse<T>>;
     /**
-     * Specialized extractor for Understat (Example)
+     * Specialized extractor for Understat
+     * Extracts xG, shots, and other advanced metrics from the JSON data embedded in script tags.
      */
     private extractUnderstatData;
     /**
@@ -72,3 +73,7 @@ export declare function scrapeMatchContent(url: string): Promise<APIResponse<str
  * Find best URL for match data from search results
  */
 export declare function findBestMatchUrl(urls: string[]): string | null;
+/**
+ * Find best URL for news/lineups from search results
+ */
+export declare function findBestNewsUrl(urls: string[]): string | null;