@gotza02/sequential-thinking 2026.2.19 → 2026.2.20

package/README.md

@@ -62,7 +62,7 @@ Add this to your MCP settings (`~/.gemini/settings.json` or `claude_desktop_conf
 
 ## 🛠️ Tools Summary
 - **Thinking:** `sequentialthinking`, `summarize_history`, `clear_thought_history`
-- **Code:** `build_project_graph`, `deep_code_analyze`, `deep_code_edit`, `search_code` (Regex/Line Numbers)
+- **Code:** `build_project_graph`, `deep_code_analyze` (Context+Usages), `deep_code_edit`, `search_code` (Regex/Line Numbers)
 - **Memory:** `add_code_snippet`, `search_code_db`, `manage_notes`
 - **Web:** `web_search`, `read_webpage`, `fetch`
 - **System:** `read_file`, `write_file`, `edit_file`, `shell_execute`

package/dist/coding.test.js

@@ -65,7 +65,14 @@ describe('Deep Coding Tools', () => {
                 dependencies: [{ path: 'src/dep.ts', symbols: ['Helper'] }],
                 dependents: [{ path: 'src/usage.ts', symbols: ['App'] }]
             });
-            fs.readFile.mockResolvedValue('const a = 1;');
+            // Mock fs.readFile to return specific content for usage analysis
+            fs.readFile.mockImplementation((fpath) => {
+                if (fpath.includes('target.ts'))
+                    return Promise.resolve('export class MyClass {}');
+                if (fpath.includes('usage.ts'))
+                    return Promise.resolve('import { MyClass } from "./target";\nconst app = new MyClass();');
+                return Promise.resolve('');
+            });
             const result = await handler({ filePath: 'src/target.ts', taskDescription: 'Analyze this' });
             expect(result.isError).toBeUndefined();
             const text = result.content[0].text;
@@ -74,6 +81,9 @@ describe('Deep Coding Tools', () => {
             expect(text).toContain('MyClass'); // Symbol
             expect(text).toContain('src/dep.ts'); // Dependency
             expect(text).toContain('src/usage.ts'); // Dependent
+            // Verify usage finding
+            expect(text).toContain('Line 1: import { MyClass } from "./target";');
+            expect(text).toContain('Line 2: const app = new MyClass();');
         });
         it('should handle fs errors gracefully', async () => {
             registerCodingTools(mockServer, mockGraph);

package/dist/tools/coding.js

@@ -31,9 +31,46 @@ export function registerCodingTools(server, graph) {
                 doc += `- ${d.path} (Symbols: ${d.symbols.join(', ')})\n`;
             });
             doc += `\nDEPENDENTS (Files that use this file):\n`;
-            context.dependents.forEach(d => {
-                doc += `- ${d.path} (Symbols: ${d.symbols.join(', ')})\n`;
-            });
+            // Helper to find usages (defined inline to capture context/scope)
+            const findUsages = async (fileToSearch, targetPath, symbols) => {
+                try {
+                    const content = await fs.readFile(fileToSearch, 'utf-8');
+                    const lines = content.split('\n');
+                    const matches = [];
+                    const baseName = path.basename(targetPath, path.extname(targetPath));
+                    // Escape regex special chars
+                    const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const symbolRegexes = symbols.map(s => new RegExp(`\\b${escapeRegExp(s)}\\b`));
+                    lines.forEach((line, index) => {
+                        // Check for import of the file itself (simple heuristic)
+                        if ((line.includes('import') || line.includes('require')) && line.includes(baseName)) {
+                            matches.push(`Line ${index + 1}: ${line.trim()}`);
+                            return;
+                        }
+                        // Check for symbols
+                        for (const regex of symbolRegexes) {
+                            if (regex.test(line)) {
+                                matches.push(`Line ${index + 1}: ${line.trim()}`);
+                                break; // One match per line is enough
+                            }
+                        }
+                    });
+                    return matches;
+                }
+                catch (e) {
+                    return [];
+                }
+            };
+            for (const d of context.dependents) {
+                doc += `- ${d.path}\n`;
+                const usages = await findUsages(d.path, filePath, context.targetFile.symbols);
+                if (usages.length > 0) {
+                    // Limit to top 3 to save context
+                    usages.slice(0, 3).forEach(u => doc += `  ${u}\n`);
+                    if (usages.length > 3)
+                        doc += `  ... (${usages.length - 3} more references)\n`;
+                }
+            }
             doc += `\n--- END OF CONTEXT ---`;
             return {
                 content: [{ type: "text", text: doc }]

package/package.json

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