@gotza02/sequential-thinking 2026.2.20 → 2026.2.21

package/dist/graph.test.js

@@ -1,150 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ProjectKnowledgeGraph } from './graph.js';
-import * as fs from 'fs/promises';
-vi.mock('fs/promises');
-describe('ProjectKnowledgeGraph', () => {
-    let graph;
-    beforeEach(() => {
-        graph = new ProjectKnowledgeGraph();
-        vi.resetAllMocks();
-        // Default mocks for stat and writeFile
-        fs.stat.mockResolvedValue({
-            isDirectory: () => true,
-            mtimeMs: 1000
-        });
-        fs.writeFile.mockResolvedValue(undefined);
-    });
-    it('should ignore imports in comments', async () => {
-        const mockFiles = ['/app/index.ts', '/app/utils.ts', '/app/oldUtils.ts'];
-        const mockContentIndex = `
-            import { something } from './utils';
-            // import { oldThing } from './oldUtils';
-            /* import { other } from './other' */
-        `;
-        const mockContentUtils = 'export const something = 1;';
-        fs.readdir.mockResolvedValue([
-            { name: 'index.ts', isDirectory: () => false },
-            { name: 'utils.ts', isDirectory: () => false },
-            { name: 'oldUtils.ts', isDirectory: () => false }
-        ]);
-        fs.readFile.mockImplementation(async (path) => {
-            if (path.includes('graph_cache.json'))
-                return '{}'; // Mock empty cache
-            if (path.includes('index.ts'))
-                return mockContentIndex;
-            return '';
-        });
-        // Mock resolvePath behavior indirectly by mocking existing files check in graph.build logic
-        // But since graph.ts uses fs.readdir recursively, we need to mock that structure.
-        // For simplicity in this unit test, we'll mock 'getAllFiles' if it were public, 
-        // but since it's private, we have to mock fs structure carefully or rely on the implementation.
-        // Let's rely on the fact that build calls getAllFiles which calls readdir.
-        // We need to ensure 'utils.ts' and 'oldUtils.ts' resolution is tested.
-        // Actually, since we mock readFile, the file existence check in resolvePath uses "this.nodes.has".
-        // "this.nodes" is populated by getAllFiles.
-        // So we need getAllFiles to return both index.ts and utils.ts.
-        // And NOT oldUtils.ts so we can see if it tries to resolve it?
-        // Actually, if it tries to resolve 'oldUtils', it might fail if not in nodes.
-        // But the bug is that it SHOULD NOT even try to resolve 'oldUtils' because it's commented out.
-        await graph.build('/app');
-        const relationships = graph.getRelationships('/app/index.ts');
-        expect(relationships?.imports).toContain('utils.ts');
-        expect(relationships?.imports).not.toContain('oldUtils.ts');
-    });
-    it('should resolve .js imports to .ts files', async () => {
-        const mockContentIndex = `import { something } from './lib.js';`;
-        fs.readdir.mockResolvedValue([
-            { name: 'index.ts', isDirectory: () => false },
-            { name: 'lib.ts', isDirectory: () => false }
-        ]);
-        fs.readFile.mockImplementation(async (filePath) => {
-            if (filePath.includes('graph_cache.json'))
-                return '{}';
-            if (filePath.endsWith('index.ts'))
-                return mockContentIndex;
-            return '';
-        });
-        await graph.build('/app');
-        const relationships = graph.getRelationships('/app/index.ts');
-        // The output of getRelationships.imports is relative paths.
-        // If imports ./lib.js, and we have lib.ts, it should resolve to /app/lib.ts
-        // And path.relative('/app', '/app/lib.ts') is 'lib.ts'
-        expect(relationships?.imports).toContain('lib.ts');
-    });
-    it('should resolve .js imports to .jsx files', async () => {
-        const mockContentIndex = `import { Button } from './Button.js';`;
-        fs.readdir.mockResolvedValue([
-            { name: 'index.js', isDirectory: () => false },
-            { name: 'Button.jsx', isDirectory: () => false }
-        ]);
-        fs.readFile.mockImplementation(async (filePath) => {
-            if (filePath.includes('graph_cache.json'))
-                return '{}';
-            if (filePath.endsWith('index.js'))
-                return mockContentIndex;
-            return '';
-        });
-        await graph.build('/app');
-        const relationships = graph.getRelationships('/app/index.js');
-        expect(relationships?.imports).toContain('Button.jsx');
-    });
-    it('should handle circular dependencies', async () => {
-        const contentA = `import { b } from './b'; export const a = 1;`;
-        const contentB = `import { a } from './a'; export const b = 2;`;
-        fs.readdir.mockResolvedValue([
-            { name: 'a.ts', isDirectory: () => false },
-            { name: 'b.ts', isDirectory: () => false }
-        ]);
-        fs.readFile.mockImplementation(async (filePath) => {
-            if (filePath.includes('graph_cache.json'))
-                return '{}';
-            if (filePath.endsWith('a.ts'))
-                return contentA;
-            if (filePath.endsWith('b.ts'))
-                return contentB;
-            return '';
-        });
-        await graph.build('/app');
-        const relA = graph.getRelationships('/app/a.ts');
-        const relB = graph.getRelationships('/app/b.ts');
-        expect(relA?.imports).toContain('b.ts');
-        expect(relA?.importedBy).toContain('b.ts');
-        expect(relB?.imports).toContain('a.ts');
-        expect(relB?.importedBy).toContain('a.ts');
-    });
-    it('should gracefully handle missing imports', async () => {
-        const contentA = `import { ghost } from './ghost';`;
-        fs.readdir.mockResolvedValue([
-            { name: 'a.ts', isDirectory: () => false }
-        ]);
-        fs.readFile.mockImplementation(async (filePath) => {
-            if (filePath.includes('graph_cache.json'))
-                return '{}';
-            if (filePath.endsWith('a.ts'))
-                return contentA;
-            return '';
-        });
-        await graph.build('/app');
-        const relA = graph.getRelationships('/app/a.ts');
-        // ghost.ts doesn't exist, so imports should be empty (filtered out)
-        expect(relA?.imports).toHaveLength(0);
-    });
-    it('should ignore directory traversal attempts outside root', async () => {
-        // If we pretend root is /app, and we try to import ../outside
-        const contentA = `import { secret } from '../secret';`;
-        fs.readdir.mockResolvedValue([
-            { name: 'a.ts', isDirectory: () => false }
-        ]);
-        fs.readFile.mockImplementation(async (filePath) => {
-            if (filePath.includes('graph_cache.json'))
-                return '{}';
-            if (filePath.endsWith('a.ts'))
-                return contentA;
-            return '';
-        });
-        await graph.build('/app');
-        const relA = graph.getRelationships('/app/a.ts');
-        // Should be empty because '../secret' is not in the scanned file list (nodes)
-        expect(relA?.imports).toHaveLength(0);
-    });
-});

package/dist/graph_repro.test.js

@@ -1,63 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ProjectKnowledgeGraph } from './graph.js';
-import * as fs from 'fs/promises';
-vi.mock('fs/promises');
-describe('ProjectKnowledgeGraph Reproduction', () => {
-    let graph;
-    beforeEach(() => {
-        graph = new ProjectKnowledgeGraph();
-        vi.resetAllMocks();
-    });
-    it('should resolve absolute imports from project root', async () => {
-        // Scenario: /app/src/feature/a.ts imports 'src/shared/b.ts'
-        const mockContentA = `import { b } from 'src/shared/b';`;
-        fs.readdir.mockResolvedValue([
-            { name: 'src', isDirectory: () => true },
-            { name: 'feature', isDirectory: () => true },
-            { name: 'shared', isDirectory: () => true },
-            { name: 'a.ts', isDirectory: () => false },
-            { name: 'b.ts', isDirectory: () => false }
-        ]);
-        // Mock getAllFiles behavior by manually setting up the file system structure conceptually
-        // Since getAllFiles is recursive and hard to mock perfectly with just readdir,
-        // we'll focus on the result of getAllFiles which populates the graph.
-        // Wait, the test uses the REAL getAllFiles, so we must mock readdir correctly.
-        // Let's simplify: Flat structure for test.
-        // Root: /app
-        // Files: /app/a.ts, /app/b.ts
-        // a.ts content: "import ... from 'b'" (no dot)
-        // OR
-        // a.ts content: "import ... from 'app/b'" (if root is /)
-        // Let's try the 'src/...' pattern which is common.
-        // Root: /root
-        // File: /root/src/index.ts -> imports 'src/utils'
-        // File: /root/src/utils.ts
-        const rootDir = '/root';
-        const indexFile = '/root/src/index.ts';
-        const utilsFile = '/root/src/utils.ts';
-        // Mock readdir to simulate:
-        // /root -> [src]
-        // /root/src -> [index.ts, utils.ts]
-        fs.readdir.mockImplementation(async (dir) => {
-            if (dir === '/root')
-                return [{ name: 'src', isDirectory: () => true }];
-            if (dir === '/root/src')
-                return [
-                    { name: 'index.ts', isDirectory: () => false },
-                    { name: 'utils.ts', isDirectory: () => false }
-                ];
-            return [];
-        });
-        fs.readFile.mockImplementation(async (filePath) => {
-            if (filePath === indexFile)
-                return `import { u } from 'src/utils';`;
-            return '';
-        });
-        await graph.build(rootDir);
-        const relationships = graph.getRelationships(indexFile);
-        // We expect 'src/utils.ts' to be in imports.
-        // Note: graph.getRelationships returns relative paths.
-        // relative('/root', '/root/src/utils.ts') -> 'src/utils.ts'
-        expect(relationships?.imports).toContain('src/utils.ts');
-    });
-});

package/dist/integration.test.js

@@ -1,58 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// We need to import the register functions to get the callbacks, 
-// but we can just use the classes directly for this integration logic test.
-// Actually, testing the *interaction* via the tool layer is better.
-import { registerThinkingTools } from './tools/thinking.js';
-import { registerGraphTools } from './tools/graph.js';
-import { registerNoteTools } from './tools/notes.js';
-describe('Integration Workflow', () => {
-    let toolCallbacks = {};
-    const mockServer = {
-        tool: (name, desc, schema, cb) => {
-            toolCallbacks[name] = cb;
-        }
-    };
-    // Mocks
-    const mockThinking = { processThought: vi.fn(), clearHistory: vi.fn() };
-    const mockGraph = { build: vi.fn(), getRelationships: vi.fn() };
-    const mockNotes = { addNote: vi.fn() };
-    beforeEach(() => {
-        toolCallbacks = {};
-        registerThinkingTools(mockServer, mockThinking);
-        registerGraphTools(mockServer, mockGraph);
-        registerNoteTools(mockServer, mockNotes);
-        vi.clearAllMocks();
-    });
-    it('should support a full analysis workflow', async () => {
-        // Step 1: Start Thinking
-        mockThinking.processThought.mockResolvedValue({
-            content: [{ type: "text", text: "Thought processed" }]
-        });
-        await toolCallbacks['sequentialthinking']({
-            thought: "Analyze architecture",
-            thoughtNumber: 1,
-            totalThoughts: 5,
-            nextThoughtNeeded: true,
-            thoughtType: 'analysis'
-        });
-        expect(mockThinking.processThought).toHaveBeenCalledWith(expect.objectContaining({
-            thought: "Analyze architecture"
-        }));
-        // Step 2: Build Graph
-        mockGraph.build.mockResolvedValue({ nodeCount: 10, totalFiles: 20 });
-        await toolCallbacks['build_project_graph']({ path: '.' });
-        expect(mockGraph.build).toHaveBeenCalled();
-        // Step 3: Get Relationships
-        mockGraph.getRelationships.mockReturnValue({ imports: ['utils.ts'] });
-        const relResult = await toolCallbacks['get_file_relationships']({ filePath: 'src/index.ts' });
-        expect(JSON.parse(relResult.content[0].text).imports).toContain('utils.ts');
-        // Step 4: Add Note
-        mockNotes.addNote.mockResolvedValue({ id: '123', title: 'Arch Note' });
-        await toolCallbacks['manage_notes']({
-            action: 'add',
-            title: 'Architecture Review',
-            content: 'Found circular deps'
-        });
-        expect(mockNotes.addNote).toHaveBeenCalledWith('Architecture Review', 'Found circular deps', undefined, undefined, undefined);
-    });
-});

package/dist/notes.test.js

@@ -1,74 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-import { NotesManager } from './notes.js';
-import * as fs from 'fs/promises';
-vi.mock('fs/promises');
-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;
-        });
-        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");
-        expect(JSON.parse(mockStore)).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[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.js

@@ -1,39 +0,0 @@
-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/repro_dollar.js

@@ -1,30 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { registerFileSystemTools } from './tools/filesystem.js';
-// Mock server
-const server = new McpServer({ name: "test", version: "1" });
-// Mock tool registration to capture the handler
-let editHandler;
-server.tool = (name, desc, schema, handler) => {
-    if (name === 'edit_file')
-        editHandler = handler;
-    return undefined;
-};
-registerFileSystemTools(server);
-async function test() {
-    console.log("Testing edit_file with dollar signs...");
-    const result = await editHandler({
-        path: 'test_dollar.txt',
-        oldText: 'OLD',
-        newText: '$100' // This usually becomes empty or weird if interpreted as regex replacement
-    });
-    const fs = await import('fs/promises');
-    const content = await fs.readFile('test_dollar.txt', 'utf-8');
-    console.log("File content:", content.trim());
-    if (content.trim() === 'Price: $100') {
-        console.log("PASS: $ preserved");
-    }
-    else {
-        console.log("FAIL: $ corrupted");
-    }
-}
-test();

package/dist/repro_dollar_simple.js

@@ -1,22 +0,0 @@
-async function test() {
-    console.log("Testing edit_file logic...");
-    // Simulate the logic in filesystem.ts
-    const content = "Price: OLD";
-    const oldText = "OLD";
-    const newText = "$&"; // Should be "$&" literally, but replace will make it "OLD"
-    // Logic from tool
-    // If allowMultiple is false, it passes string directly
-    const buggedResult = content.replace(oldText, newText);
-    console.log(`Original: "${content}"`);
-    console.log(`Old: "${oldText}"`);
-    console.log(`New: "${newText}"`);
-    console.log(`Result: "${buggedResult}"`);
-    if (buggedResult === "Price: OLD") {
-        console.log("FAIL: $& was interpreted as the matched string");
-    }
-    else if (buggedResult === "Price: $&") {
-        console.log("PASS: $& was preserved literally");
-    }
-}
-test();
-export {};

package/dist/repro_history.js

@@ -1,41 +0,0 @@
-import { SequentialThinkingServer } from './lib.js';
-import * as fs from 'fs/promises';
-async function test() {
-    const server = new SequentialThinkingServer('test_history_bug.json');
-    await server.clearHistory();
-    // Create thoughts: 1, 2, 3, 4
-    await server.processThought({ thought: "1", thoughtNumber: 1, totalThoughts: 4, nextThoughtNeeded: true });
-    await server.processThought({ thought: "2", thoughtNumber: 2, totalThoughts: 4, nextThoughtNeeded: true });
-    await server.processThought({ thought: "3", thoughtNumber: 3, totalThoughts: 4, nextThoughtNeeded: true });
-    // Thought 4 branches from 3
-    await server.processThought({
-        thought: "4",
-        thoughtNumber: 4,
-        totalThoughts: 4,
-        nextThoughtNeeded: false,
-        branchFromThought: 3,
-        branchId: "test"
-    });
-    // Verify initial state
-    // History: [1, 2, 3, 4(from 3)]
-    // Summarize 2-3
-    await server.archiveHistory(2, 3, "Summary of 2 and 3");
-    // Expected History: [1, Summary(2), 4(3)]
-    // Thought 4 should now contain "branchFromThought: 2" (pointing to summary)
-    // Or if it broke, it might still say 3 (which is itself!) or not be updated.
-    // Read file manually to check JSON content
-    const data = JSON.parse(await fs.readFile('test_history_bug.json', 'utf-8'));
-    const lastThought = data[data.length - 1];
-    console.log("Last Thought:", lastThought);
-    if (lastThought.branchFromThought === 3) {
-        console.log("FAIL: branchFromThought was NOT updated. It points to 3 (which is now itself).");
-    }
-    else if (lastThought.branchFromThought === 2) {
-        console.log("PASS: branchFromThought was updated to point to Summary.");
-    }
-    else {
-        console.log(`FAIL: branchFromThought is ${lastThought.branchFromThought} (Unknown state)`);
-    }
-    await fs.unlink('test_history_bug.json');
-}
-test();

package/dist/repro_path.js

@@ -1,17 +0,0 @@
-import * as path from 'path';
-async function test() {
-    console.log("Testing path traversal vulnerability...");
-    const cwd = process.cwd();
-    const maliciousPath = '/etc/passwd'; // Or any file outside cwd
-    const resolved = path.resolve(maliciousPath);
-    console.log(`CWD: ${cwd}`);
-    console.log(`Input: ${maliciousPath}`);
-    console.log(`Resolved: ${resolved}`);
-    if (!resolved.startsWith(cwd)) {
-        console.log("FAIL: Path is outside CWD and would be allowed by current logic.");
-    }
-    else {
-        console.log("PASS: Path is inside CWD.");
-    }
-}
-test();

package/dist/repro_search.test.js

@@ -1,79 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-async function searchCodeLogic(pattern, searchPath = '.') {
-    try {
-        const resolvedPath = path.resolve(searchPath);
-        const stat = await fs.stat(resolvedPath);
-        if (stat.isFile()) {
-            const content = await fs.readFile(resolvedPath, 'utf-8');
-            if (content.includes(pattern)) {
-                return {
-                    content: [{ type: "text", text: `Found "${pattern}" in:\n${resolvedPath}` }]
-                };
-            }
-            else {
-                return {
-                    content: [{ type: "text", text: `No matches found for "${pattern}"` }]
-                };
-            }
-        }
-        async function searchDir(dir) {
-            const results = [];
-            const entries = await fs.readdir(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    if (['node_modules', '.git', 'dist', 'coverage', '.gemini'].includes(entry.name))
-                        continue;
-                    results.push(...await searchDir(fullPath));
-                }
-                else if (new RegExp('\\.(ts|js|json|md|txt|html|css|py|java|c|cpp|h|rs|go)$').test(entry.name)) {
-                    const content = await fs.readFile(fullPath, 'utf-8');
-                    if (content.includes(pattern)) {
-                        results.push(fullPath);
-                    }
-                }
-            }
-            return results;
-        }
-        const matches = await searchDir(resolvedPath);
-        const joinedMatches = matches.join('\n');
-        return {
-            content: [{
-                    type: "text",
-                    text: matches.length > 0 ? `Found "${pattern}" in:\n${joinedMatches}` : `No matches found for "${pattern}"`
-                }]
-        };
-    }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Search Error: ${error instanceof Error ? error.message : String(error)}` }],
-            isError: true
-        };
-    }
-}
-describe('search_code tool', () => {
-    const testDir = path.join(__dirname, 'test_search_env');
-    beforeEach(async () => {
-        await fs.mkdir(testDir, { recursive: true });
-        await fs.writeFile(path.join(testDir, 'target.ts'), 'function myFunction() { return "found me"; }');
-        await fs.writeFile(path.join(testDir, 'other.ts'), 'const x = 10;');
-        await fs.mkdir(path.join(testDir, 'nested'), { recursive: true });
-        await fs.writeFile(path.join(testDir, 'nested', 'deep.ts'), 'export const secret = "found me too";');
-        await fs.mkdir(path.join(testDir, 'node_modules'), { recursive: true });
-        await fs.writeFile(path.join(testDir, 'node_modules', 'ignored.ts'), 'found me');
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    // ... (previous tests)
-    it('should handle single file path', async () => {
-        // This test will FAIL with current implementation (simulated here with the fix applied? No, I need to test failure first)
-        // Wait, I updated searchCodeLogic above with the FIX. 
-        // So this test checks if the FIX works.
-        const result = await searchCodeLogic('found me', path.join(testDir, 'target.ts'));
-        expect(result.isError).toBeUndefined();
-        expect(result.content[0].text).toContain('target.ts');
-    });
-});

package/dist/repro_ts_req.js

@@ -1,3 +0,0 @@
-import { createRequire as _createRequire } from "module";
-const __require = _createRequire(import.meta.url);
-const fs = __require("fs");