@gotza02/sequential-thinking 10000.0.0 → 10000.0.1

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

@@ -0,0 +1,100 @@
+import { describe, it, expect, beforeEach, afterAll } from 'vitest';
+import { PredictionTracker } from './core/tracker.js';
+import * as fs from 'fs/promises';
+const TEST_LOG_FILE = 'test_betting_log.json';
+describe('ROI Tracker System', () => {
+    let tracker;
+    beforeEach(async () => {
+        // Use a test file instead of the real one
+        tracker = new PredictionTracker(TEST_LOG_FILE);
+        // Clear previous test data
+        try {
+            await fs.unlink(TEST_LOG_FILE);
+        }
+        catch { }
+    });
+    afterAll(async () => {
+        try {
+            await fs.unlink(TEST_LOG_FILE);
+        }
+        catch { }
+    });
+    it('should track a new prediction', async () => {
+        const bet = await tracker.track({
+            league: 'Premier League',
+            homeTeam: 'Arsenal',
+            awayTeam: 'Man City',
+            selection: 'Over 2.5 Goals',
+            odds: 1.85,
+            stake: 10,
+            confidence: 80,
+            analysis: 'High scoring teams',
+            date: new Date().toISOString()
+        });
+        expect(bet.id).toBeDefined();
+        expect(bet.status).toBe('pending');
+        expect(bet.profit).toBeUndefined();
+        const pending = await tracker.list('pending');
+        expect(pending.length).toBe(1);
+        expect(pending[0].id).toBe(bet.id);
+    });
+    it('should resolve a prediction and calculate profit correctly', async () => {
+        const bet = await tracker.track({
+            league: 'Premier League',
+            homeTeam: 'Liverpool',
+            awayTeam: 'Chelsea',
+            selection: 'Liverpool Win',
+            odds: 2.0,
+            stake: 50,
+            confidence: 90,
+            analysis: 'Form is good',
+            date: new Date().toISOString()
+        });
+        // Resolve as WON
+        const resolved = await tracker.resolve(bet.id, 'won', '2-0');
+        expect(resolved).toBeDefined();
+        expect(resolved.status).toBe('won');
+        expect(resolved.profit).toBe(50); // (50 * 2.0) - 50 = 50
+        expect(resolved.resultScore).toBe('2-0');
+        // Check Stats
+        const stats = await tracker.getStats();
+        expect(stats.totalBets).toBe(1);
+        expect(stats.wins).toBe(1);
+        expect(stats.totalProfit).toBe(50);
+        expect(stats.roi).toBe(100); // (50/50)*100
+    });
+    it('should handle lost bets correctly', async () => {
+        const bet = await tracker.track({
+            league: 'La Liga',
+            homeTeam: 'Real Madrid',
+            awayTeam: 'Barca',
+            selection: 'Real Win',
+            odds: 2.5,
+            stake: 100,
+            confidence: 60,
+            analysis: 'El Classico',
+            date: new Date().toISOString()
+        });
+        // Resolve as LOST
+        const resolved = await tracker.resolve(bet.id, 'lost', '0-3');
+        expect(resolved.status).toBe('lost');
+        expect(resolved.profit).toBe(-100);
+        const stats = await tracker.getStats();
+        expect(stats.totalProfit).toBe(-100);
+        expect(stats.roi).toBe(-100); // (-100/100)*100
+    });
+    it('should filter stats by league', async () => {
+        await tracker.track({
+            league: 'EPL', homeTeam: 'A', awayTeam: 'B', selection: 'Win', odds: 2.0, stake: 10, confidence: 50, analysis: '.', date: new Date().toISOString()
+        }).then(b => tracker.resolve(b.id, 'won')); // Profit +10
+        await tracker.track({
+            league: 'La Liga', homeTeam: 'C', awayTeam: 'D', selection: 'Win', odds: 2.0, stake: 10, confidence: 50, analysis: '.', date: new Date().toISOString()
+        }).then(b => tracker.resolve(b.id, 'lost')); // Profit -10
+        const eplStats = await tracker.getStats({ league: 'EPL' });
+        expect(eplStats.totalProfit).toBe(10);
+        const ligaStats = await tracker.getStats({ league: 'La Liga' });
+        expect(ligaStats.totalProfit).toBe(-10);
+        const allStats = await tracker.getStats();
+        expect(allStats.totalProfit).toBe(0);
+    });
+});

package/dist/utils.test.d.ts

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

package/dist/utils.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { validatePath } from './utils.js';
+import * as path from 'path';
+describe('Utils: validatePath', () => {
+    // Mock process.cwd to be a known fixed path
+    const mockCwd = '/app/project';
+    beforeEach(() => {
+        vi.spyOn(process, 'cwd').mockReturnValue(mockCwd);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should allow paths within the project root', () => {
+        const p = validatePath('src/index.ts');
+        expect(p).toBe(path.resolve(mockCwd, 'src/index.ts'));
+    });
+    it('should allow explicit ./ paths', () => {
+        const p = validatePath('./package.json');
+        expect(p).toBe(path.resolve(mockCwd, 'package.json'));
+    });
+    it('should block traversal to parent directory', () => {
+        expect(() => {
+            validatePath('../outside.txt');
+        }).toThrow(/Access denied/);
+    });
+    it('should block multiple level traversal', () => {
+        expect(() => {
+            validatePath('src/../../etc/passwd');
+        }).toThrow(/Access denied/);
+    });
+    it('should block absolute paths outside root', () => {
+        // Only run this check if we can reliably simulate absolute paths
+        // For now, let's assume standard unix paths for the test logic
+        if (path.sep === '/') {
+            expect(() => {
+                validatePath('/etc/passwd');
+            }).toThrow(/Access denied/);
+        }
+    });
+});

package/dist/verify_cache.test.d.ts

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

package/dist/verify_cache.test.js

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+describe('Graph Caching Verification', () => {
+    const root = process.cwd();
+    const cachePath = path.join(root, '.gemini_graph_cache.json');
+    beforeEach(async () => {
+        // Cleanup existing cache before each test
+        try {
+            await fs.unlink(cachePath);
+        }
+        catch (e) { }
+    });
+    it('should use cache on second run', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-cache-test-'));
+        const testFile = path.join(tempDir, 'main.ts');
+        try {
+            // Create a dummy file to scan
+            await fs.writeFile(testFile, 'export const val = 1;', 'utf-8');
+            console.log('--- Run 1 (Fresh) ---');
+            const res1 = await graph.build(tempDir);
+            console.log('Result 1:', res1);
+            expect(res1.parsedFiles).toBeGreaterThan(0);
+            expect(res1.cachedFiles).toBe(0);
+            console.log('--- Run 2 (Cached) ---');
+            const res2 = await graph.build(tempDir);
+            console.log('Result 2:', res2);
+            expect(res2.parsedFiles).toBe(0);
+            expect(res2.cachedFiles).toBeGreaterThan(0);
+            expect(res2.nodeCount).toBe(res1.nodeCount);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should invalidate cache when file mtime changes', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-mtime-test-'));
+        const testFile = path.join(tempDir, 'test.ts');
+        try {
+            // Create initial file
+            await fs.writeFile(testFile, 'export const foo = 1;', 'utf-8');
+            // Build 1: Fresh
+            const res1 = await graph.build(tempDir);
+            expect(res1.parsedFiles).toBe(1);
+            expect(res1.cachedFiles).toBe(0);
+            console.log('Build 1 (fresh):', res1);
+            // Build 2: Should use cache
+            const res2 = await graph.build(tempDir);
+            expect(res2.parsedFiles).toBe(0);
+            expect(res2.cachedFiles).toBe(1);
+            console.log('Build 2 (cached):', res2);
+            // Modify file content (this changes mtime)
+            await new Promise(resolve => setTimeout(resolve, 50)); // Small delay to ensure mtime changes
+            await fs.writeFile(testFile, 'export const bar = 2;', 'utf-8');
+            // Build 3: Should detect mtime change and re-parse
+            const res3 = await graph.build(tempDir);
+            expect(res3.parsedFiles).toBe(1); // File should be re-parsed due to mtime change
+            expect(res3.cachedFiles).toBe(0);
+            console.log('Build 3 (mtime changed):', res3);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should detect new files added after cache was built', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-newfile-test-'));
+        const file1 = path.join(tempDir, 'a.ts');
+        const file2 = path.join(tempDir, 'b.ts');
+        try {
+            // Create initial file
+            await fs.writeFile(file1, 'export const a = 1;', 'utf-8');
+            // Build 1: Only one file
+            const res1 = await graph.build(tempDir);
+            expect(res1.nodeCount).toBe(1);
+            expect(res1.totalFiles).toBe(1);
+            console.log('Build 1 (1 file):', res1);
+            // Add new file
+            await fs.writeFile(file2, 'export const b = 2;', 'utf-8');
+            // Build 2: Should detect new file
+            const res2 = await graph.build(tempDir);
+            expect(res2.nodeCount).toBe(2);
+            expect(res2.totalFiles).toBe(2);
+            expect(res2.parsedFiles).toBe(1); // Only the new file should be parsed
+            expect(res2.cachedFiles).toBe(1); // Old file should use cache
+            console.log('Build 2 (new file added):', res2);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should handle deleted files by pruning from cache', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-delete-test-'));
+        const file1 = path.join(tempDir, 'keep.ts');
+        const file2 = path.join(tempDir, 'delete.ts');
+        try {
+            // Create two files
+            await fs.writeFile(file1, 'export const keep = 1;', 'utf-8');
+            await fs.writeFile(file2, 'export const deleted = 2;', 'utf-8');
+            // Build 1: Two files
+            const res1 = await graph.build(tempDir);
+            expect(res1.nodeCount).toBe(2);
+            console.log('Build 1 (2 files):', res1);
+            // Delete one file
+            await fs.unlink(file2);
+            // Build 2: Should only have one file, cache pruned
+            const res2 = await graph.build(tempDir);
+            expect(res2.nodeCount).toBe(1);
+            expect(res2.totalFiles).toBe(1);
+            console.log('Build 2 (after delete):', res2);
+            // Verify cache file doesn't have deleted file
+            const cacheContent = JSON.parse(await fs.readFile(path.join(tempDir, '.gemini_graph_cache.json'), 'utf-8'));
+            expect(cacheContent.files[file2]).toBeUndefined();
+            expect(cacheContent.files[file1]).toBeDefined();
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should force rebuild when forceRebuild() is called', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-force-test-'));
+        const testFile = path.join(tempDir, 'test.ts');
+        try {
+            // Create file
+            await fs.writeFile(testFile, 'export const x = 1;', 'utf-8');
+            // Build 1: Fresh
+            const res1 = await graph.build(tempDir);
+            expect(res1.parsedFiles).toBe(1);
+            console.log('Build 1 (fresh):', res1);
+            // Build 2: Should use cache
+            const res2 = await graph.build(tempDir);
+            expect(res2.parsedFiles).toBe(0);
+            expect(res2.cachedFiles).toBe(1);
+            console.log('Build 2 (cached):', res2);
+            // Force rebuild: Should ignore cache
+            const res3 = await graph.forceRebuild(tempDir);
+            expect(res3.parsedFiles).toBe(1); // Force re-parse everything
+            expect(res3.cachedFiles).toBe(0);
+            console.log('Build 3 (force):', res3);
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+    it('should have consistent results between cached and fresh builds', async () => {
+        const graph = new ProjectKnowledgeGraph();
+        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'graph-consistent-test-'));
+        const file1 = path.join(tempDir, 'main.ts');
+        const file2 = path.join(tempDir, 'utils.ts');
+        try {
+            // Create files with imports
+            await fs.writeFile(file2, 'export function helper() { return 42; }', 'utf-8');
+            await fs.writeFile(file1, 'import { helper } from "./utils.js";\nexport const result = helper();', 'utf-8');
+            // Build 1: Fresh
+            const res1 = await graph.build(tempDir);
+            const rel1 = graph.getRelationships('main.ts');
+            // Build 2: Cached
+            const res2 = await graph.build(tempDir);
+            const rel2 = graph.getRelationships('main.ts');
+            // Force rebuild: Fresh again
+            const res3 = await graph.forceRebuild(tempDir);
+            const rel3 = graph.getRelationships('main.ts');
+            // All should have same relationships
+            expect(rel1).toEqual(rel2);
+            expect(rel2).toEqual(rel3);
+            expect(rel1?.imports.length).toBeGreaterThan(0);
+            console.log('Relationships consistent:', JSON.stringify(rel1, null, 2));
+        }
+        finally {
+            // Cleanup
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/web_fallback.test.d.ts

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

package/dist/web_fallback.test.js

@@ -0,0 +1,103 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { registerWebTools } from './tools/web.js';
+import * as utils from './utils.js';
+// Mock utils
+vi.mock('./utils.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        fetchWithRetry: vi.fn(),
+    };
+});
+describe('web_search fallback', () => {
+    let mockToolCallback;
+    const mockServer = {
+        tool: vi.fn((name, desc, schema, callback) => {
+            if (name === 'web_search') {
+                mockToolCallback = callback;
+            }
+        })
+    };
+    const originalEnv = process.env;
+    beforeEach(() => {
+        process.env = { ...originalEnv };
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    it('should use Brave if configured and no provider specified', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        delete process.env.EXA_API_KEY;
+        delete process.env.GOOGLE_SEARCH_API_KEY;
+        registerWebTools(mockServer);
+        const mockResponse = {
+            ok: true,
+            json: async () => ({ web: { results: ['brave result'] } })
+        };
+        utils.fetchWithRetry.mockResolvedValue(mockResponse);
+        const result = await mockToolCallback({ query: 'test' });
+        expect(utils.fetchWithRetry).toHaveBeenCalledWith(expect.stringContaining('api.search.brave.com'), expect.anything());
+        expect(result.isError).toBeUndefined();
+        expect(JSON.parse(result.content[0].text)).toEqual(['brave result']);
+    });
+    it('should fallback to Exa if Brave fails', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        process.env.EXA_API_KEY = 'test-exa-key';
+        registerWebTools(mockServer);
+        // First call (Brave) fails
+        utils.fetchWithRetry
+            .mockResolvedValueOnce({ ok: false, statusText: 'Brave Error', status: 500 })
+            // Second call (Exa) succeeds
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ results: ['exa result'] })
+        });
+        const result = await mockToolCallback({ query: 'test' });
+        expect(utils.fetchWithRetry).toHaveBeenCalledTimes(2);
+        // 1. Brave
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(1, expect.stringContaining('api.search.brave.com'), expect.anything());
+        // 2. Exa
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(2, expect.stringContaining('api.exa.ai'), expect.anything());
+        expect(result.isError).toBeUndefined();
+        expect(JSON.parse(result.content[0].text)).toEqual(['exa result']);
+    });
+    it('should respect requested provider and verify its availability', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        // Exa not configured
+        delete process.env.EXA_API_KEY;
+        registerWebTools(mockServer);
+        const result = await mockToolCallback({ query: 'test', provider: 'exa' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Requested provider 'exa' is not configured");
+    });
+    it('should try requested provider first, then fallback', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        process.env.EXA_API_KEY = 'test-exa-key';
+        registerWebTools(mockServer);
+        // Request Exa
+        // Mock Exa fail, Brave success
+        utils.fetchWithRetry
+            .mockResolvedValueOnce({ ok: false, statusText: 'Exa Error', status: 500 })
+            .mockResolvedValueOnce({
+            ok: true,
+            json: async () => ({ web: { results: ['brave result'] } })
+        });
+        const result = await mockToolCallback({ query: 'test', provider: 'exa' });
+        expect(utils.fetchWithRetry).toHaveBeenCalledTimes(2);
+        // 1. Exa (requested)
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(1, expect.stringContaining('api.exa.ai'), expect.anything());
+        // 2. Brave (fallback)
+        expect(utils.fetchWithRetry).toHaveBeenNthCalledWith(2, expect.stringContaining('api.search.brave.com'), expect.anything());
+        expect(result.isError).toBeUndefined();
+    });
+    it('should return error if all fail', async () => {
+        process.env.BRAVE_API_KEY = 'test-brave-key';
+        registerWebTools(mockServer);
+        utils.fetchWithRetry.mockResolvedValue({ ok: false, statusText: 'Some Error', status: 500 });
+        const result = await mockToolCallback({ query: 'test' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("All search providers failed");
+        expect(result.content[0].text).toContain("Brave API error");
+    });
+});

package/dist/web_read.test.d.ts

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

package/dist/web_read.test.js

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { registerWebTools } from './tools/web.js';
+import * as utils from './utils.js';
+vi.mock('./utils.js', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        fetchWithRetry: vi.fn(),
+        validatePublicUrl: vi.fn(),
+    };
+});
+describe('read_webpage tool', () => {
+    let mockToolCallback;
+    const mockServer = {
+        tool: vi.fn((name, desc, schema, callback) => {
+            if (name === 'read_webpage') {
+                mockToolCallback = callback;
+            }
+        })
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        registerWebTools(mockServer);
+    });
+    it('should convert HTML to Markdown', async () => {
+        const mockHtml = `
+            <html>
+                <head><title>Test Article</title></head>
+                <body>
+                    <h1>Main Header</h1>
+                    <p>Paragraph <b>bold</b>.</p>
+                </body>
+            </html>
+        `;
+        utils.fetchWithRetry.mockResolvedValue({
+            ok: true,
+            text: async () => mockHtml
+        });
+        utils.validatePublicUrl.mockResolvedValue(undefined);
+        const result = await mockToolCallback({ url: 'https://example.com' });
+        expect(result.isError).toBeUndefined();
+        const content = result.content[0].text;
+        expect(content).toContain("Title: Test Article");
+        expect(content).toContain("Main Header");
+        expect(content).toContain("**bold**"); // Markdown bold
+    });
+    it('should handle private URL validation error', async () => {
+        utils.validatePublicUrl.mockRejectedValue(new Error("Access denied: Private IP"));
+        const result = await mockToolCallback({ url: 'http://localhost' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Access denied");
+    });
+    it('should handle fetch errors', async () => {
+        utils.validatePublicUrl.mockResolvedValue(undefined);
+        utils.fetchWithRetry.mockRejectedValue(new Error("Network Error"));
+        const result = await mockToolCallback({ url: 'https://example.com' });
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Network Error");
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.0.0",
+  "version": "10000.0.1",
   "publishConfig": {
     "access": "public"
   },
@@ -53,12 +53,13 @@
     "@types/node": "^25.0.9",
     "@types/turndown": "^5.0.6",
     "@types/yargs": "^17.0.35",
-    "@vitest/coverage-v8": "^3.2.4",
-    "eslint": "^8.57.0",
-    "@typescript-eslint/parser": "^7.1.1",
-    "@typescript-eslint/eslint-plugin": "^7.1.1",
+    "@vitest/coverage-v8": "^4.0.18",
+    "eslint": "^9.39.2",
+    "@typescript-eslint/parser": "^8.54.0",
+    "@typescript-eslint/eslint-plugin": "^8.54.0",
+    "typescript-eslint": "^8.54.0",
     "prettier": "^3.2.5",
     "shx": "^0.4.0",
-    "vitest": "^3.2.4"
+    "vitest": "^4.0.18"
   }
 }