@gotza02/sequential-thinking 2026.1.28 → 2026.2.0

package/dist/verify_notes.test.js

@@ -0,0 +1,36 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { NotesManager } from './notes.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+describe('Notes Manager', () => {
+    const testFile = path.join(__dirname, 'test_notes.json');
+    let manager;
+    beforeEach(async () => {
+        manager = new NotesManager(testFile);
+    });
+    afterEach(async () => {
+        try {
+            await fs.unlink(testFile);
+        }
+        catch { }
+    });
+    it('should add and list notes', async () => {
+        await manager.addNote("My Note", "Content", ["tag1"]);
+        const notes = await manager.listNotes();
+        expect(notes.length).toBe(1);
+        expect(notes[0].title).toBe("My Note");
+    });
+    it('should search notes', async () => {
+        await manager.addNote("React Tips", "Use hooks", ["react"]);
+        await manager.addNote("Vue Tips", "Use composition", ["vue"]);
+        const results = await manager.searchNotes("hooks");
+        expect(results.length).toBe(1);
+        expect(results[0].title).toBe("React Tips");
+    });
+    it('should delete note', async () => {
+        const note = await manager.addNote("To Delete", "...");
+        await manager.deleteNote(note.id);
+        const notes = await manager.listNotes();
+        expect(notes.length).toBe(0);
+    });
+});

package/dist/verify_viz.test.js

@@ -0,0 +1,25 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ProjectKnowledgeGraph } from './graph.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+describe('Graph Visualization', () => {
+    const testDir = path.join(__dirname, 'test_viz_env');
+    const graph = new ProjectKnowledgeGraph();
+    beforeEach(async () => {
+        await fs.mkdir(testDir, { recursive: true });
+        await fs.writeFile(path.join(testDir, 'a.ts'), 'import { b } from "./b";');
+        await fs.writeFile(path.join(testDir, 'b.ts'), 'export const b = 1;');
+    });
+    afterEach(async () => {
+        await fs.rm(testDir, { recursive: true, force: true });
+    });
+    it('should generate mermaid diagram', async () => {
+        await graph.build(testDir);
+        const mermaid = graph.toMermaid();
+        console.log("Generated Mermaid:", mermaid);
+        expect(mermaid).toContain('graph TD');
+        expect(mermaid).toMatch(/N\d+\["a\.ts"\]/);
+        expect(mermaid).toMatch(/N\d+\["b\.ts"\]/);
+        expect(mermaid).toContain('-->');
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "2026.1.28",
+  "version": "2026.2.0",
   "publishConfig": {
     "access": "public"
   },
@@ -22,7 +22,8 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsc && shx chmod +x dist/*.js",
+    "build": "tsc",
+    "start": "node dist/index.js",
     "prepare": "npm run build",
     "watch": "tsc --watch",
     "test": "vitest run --coverage"
@@ -45,4 +46,4 @@
     "shx": "^0.3.4",
     "vitest": "^2.1.8"
   }
-}
+}

package/dist/verify_new_tools.test.js

@@ -1,67 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { SequentialThinkingServer } from './lib';
-// Mock dependencies for read_webpage if needed, 
-// but for now let's test the logic we can control.
-describe('New Tools Verification', () => {
-    const testDir = path.resolve('test_sandbox');
-    beforeEach(async () => {
-        await fs.mkdir(testDir, { recursive: true });
-    });
-    afterEach(async () => {
-        await fs.rm(testDir, { recursive: true, force: true });
-    });
-    it('search_code should find patterns and ignore node_modules', async () => {
-        // Setup files
-        await fs.writeFile(path.join(testDir, 'target.ts'), 'const x = "FIND_ME";');
-        await fs.writeFile(path.join(testDir, 'other.ts'), 'const y = "nope";');
-        const modulesDir = path.join(testDir, 'node_modules');
-        await fs.mkdir(modulesDir);
-        await fs.writeFile(path.join(modulesDir, 'ignored.ts'), 'const z = "FIND_ME";');
-        // Logic from search_code (replicated here for unit testing the logic itself, 
-        // effectively testing the implementation I wrote in index.ts)
-        async function searchDir(dir, pattern) {
-            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, pattern));
-                }
-                else if (/\.(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 results = await searchDir(testDir, 'FIND_ME');
-        expect(results).toHaveLength(1);
-        expect(results[0]).toContain('target.ts');
-        expect(results[0]).not.toContain('node_modules');
-    });
-    it('SequentialThinkingServer should clear history', async () => {
-        const historyFile = path.join(testDir, 'test_history.json');
-        const server = new SequentialThinkingServer(historyFile);
-        // Add a thought
-        await server.processThought({
-            thought: "Test thought",
-            thoughtNumber: 1,
-            totalThoughts: 1,
-            nextThoughtNeeded: false
-        });
-        // Verify it was written
-        const contentBefore = JSON.parse(await fs.readFile(historyFile, 'utf-8'));
-        expect(contentBefore).toHaveLength(1);
-        // Clear history
-        await server.clearHistory();
-        // Verify it is empty
-        const contentAfter = JSON.parse(await fs.readFile(historyFile, 'utf-8'));
-        expect(contentAfter).toHaveLength(0);
-    });
-});