@gotza02/sequential-thinking 2026.2.20 → 2026.2.22

package/README.md

@@ -90,6 +90,7 @@ npm run start:http
 ## 🧪 Testing & Robustness
 This project is rigorously tested using **TestSprite** and **Vitest**.
 - **Current Status:** ✅ **100% Pass Rate** (10/10 core requirements).
+- **Test Isolation:** Graph tests now run in isolated temporary environments to prevent race conditions.
 - **Path Security:** Enhanced `validatePath` with symlink resolution (`realpathSync`) for stable operation in restricted environments like Termux/Android.
 - **Error Handling:** Improved HTTP status mapping and descriptive error reporting.
 

package/dist/codestore.d.ts

@@ -0,0 +1,28 @@
+export interface CodeSnippet {
+    id: string;
+    title: string;
+    language: string;
+    code: string;
+    description: string;
+    tags: string[];
+    context?: string;
+    updatedAt: string;
+}
+export interface CodeKnowledge {
+    snippets: CodeSnippet[];
+    patterns: Record<string, string>;
+}
+export declare class CodeDatabase {
+    private filePath;
+    private db;
+    private loaded;
+    private mutex;
+    constructor(storagePath?: string);
+    private load;
+    private save;
+    addSnippet(snippet: Omit<CodeSnippet, 'id' | 'updatedAt'>): Promise<CodeSnippet>;
+    searchSnippets(query: string): Promise<CodeSnippet[]>;
+    learnPattern(name: string, description: string): Promise<void>;
+    getPattern(name: string): Promise<string | null>;
+    listAllPatterns(): Promise<Record<string, string>>;
+}

package/dist/graph.d.ts

@@ -0,0 +1,60 @@
+export interface FileNode {
+    path: string;
+    imports: string[];
+    importedBy: string[];
+    symbols: string[];
+}
+export declare class ProjectKnowledgeGraph {
+    private nodes;
+    private rootDir;
+    private cache;
+    private cachePath;
+    constructor();
+    /**
+     * Force rebuild the graph by clearing cache first.
+     * Use this when cache seems stale or files are not detected properly.
+     */
+    forceRebuild(rootDir: string): Promise<{
+        nodeCount: number;
+        totalFiles: number;
+        cachedFiles: number;
+        parsedFiles: number;
+    }>;
+    build(rootDir: string): Promise<{
+        nodeCount: number;
+        totalFiles: number;
+        cachedFiles: number;
+        parsedFiles: number;
+    }>;
+    private loadCache;
+    private saveCache;
+    private getAllFiles;
+    private parseFile;
+    private parseTypeScript;
+    private parseGeneric;
+    private linkFileNodes;
+    private resolvePath;
+    getRelationships(filePath: string): {
+        path: string;
+        imports: string[];
+        importedBy: string[];
+        symbols: string[];
+    } | null;
+    getDeepContext(filePath: string): {
+        targetFile: {
+            path: string;
+            symbols: string[];
+        };
+        dependencies: any[];
+        dependents: any[];
+    } | null;
+    getSummary(): {
+        root: string;
+        fileCount: number;
+        mostReferencedFiles: {
+            file: string;
+            referencedBy: number;
+        }[];
+    };
+    toMermaid(): string;
+}

package/dist/graph.js

@@ -7,6 +7,25 @@ export class ProjectKnowledgeGraph {
     cache = { version: '1.0', files: {} };
     cachePath = '';
     constructor() { }
+    /**
+     * Force rebuild the graph by clearing cache first.
+     * Use this when cache seems stale or files are not detected properly.
+     */
+    async forceRebuild(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.cachePath = path.join(this.rootDir, '.gemini_graph_cache.json');
+        // Clear in-memory cache
+        this.cache = { version: '1.0', files: {} };
+        // Delete cache file if exists
+        try {
+            await fs.unlink(this.cachePath);
+        }
+        catch (e) {
+            // File doesn't exist, that's fine
+        }
+        // Now build fresh
+        return await this.build(rootDir);
+    }
     async build(rootDir) {
         try {
             this.rootDir = path.resolve(rootDir);

package/dist/http-server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/http-server.js

@@ -67,7 +67,13 @@ app.get('/api/thinking/history', async (req, res) => {
             thought: t.thought,
             type: t.thoughtType,
             thoughtNumber: t.thoughtNumber,
-            totalThoughts: t.totalThoughts
+            totalThoughts: t.totalThoughts,
+            nextThoughtNeeded: t.nextThoughtNeeded,
+            isRevision: t.isRevision,
+            revisesThought: t.revisesThought,
+            branchFromThought: t.branchFromThought,
+            branchId: t.branchId,
+            blockId: t.blockId
         }));
         res.json(transformedHistory);
     }

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -12,6 +12,7 @@ import { registerGraphTools } from './tools/graph.js';
 import { registerNoteTools } from './tools/notes.js';
 import { registerCodingTools } from './tools/coding.js';
 import { registerCodeDbTools } from './tools/codestore.js';
+import { registerHumanTools } from './tools/human.js';
 const server = new McpServer({
     name: "sequential-thinking-server",
     version: "2026.2.6",
@@ -28,6 +29,7 @@ registerGraphTools(server, knowledgeGraph);
 registerNoteTools(server, notesManager);
 registerCodingTools(server, knowledgeGraph);
 registerCodeDbTools(server, codeDb);
+registerHumanTools(server);
 async function runServer() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/lib.d.ts

@@ -0,0 +1,67 @@
+export type ThoughtType = 'analysis' | 'planning' | 'execution' | 'observation' | 'hypothesis' | 'reflexion' | 'solution' | 'generation' | 'evaluation' | 'selection';
+export interface ThoughtData {
+    thought: string;
+    thoughtNumber: number;
+    totalThoughts: number;
+    nextThoughtNeeded: boolean;
+    thoughtType?: ThoughtType;
+    blockId?: string;
+    relatedToolCall?: string;
+    toolResult?: string;
+    isRevision?: boolean;
+    revisesThought?: number;
+    branchFromThought?: number;
+    branchId?: string;
+    needsMoreThoughts?: boolean;
+    score?: number;
+    options?: string[];
+    selectedOption?: string;
+}
+interface ThinkingBlock {
+    id: string;
+    topic: string;
+    status: 'active' | 'completed' | 'failed';
+    thoughts: ThoughtData[];
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class SequentialThinkingServer {
+    private thoughtHistory;
+    private blocks;
+    private currentBlockId;
+    private branches;
+    private disableThoughtLogging;
+    private storagePath;
+    private delayMs;
+    private saveMutex;
+    constructor(storagePath?: string, delayMs?: number);
+    private loadHistory;
+    private attemptRecovery;
+    private rebuildBlocks;
+    private rebuildBranches;
+    private saveHistory;
+    private autoPrune;
+    clearHistory(): Promise<void>;
+    archiveHistory(startIndex: number, endIndex: number, summary: string): Promise<{
+        newHistoryLength: number;
+        summaryInsertedAt: number;
+    }>;
+    searchHistory(query: string): Promise<ThoughtData[]>;
+    private addToMemory;
+    private formatThought;
+    processThought(input: ThoughtData): Promise<{
+        content: any[];
+        isError?: boolean;
+    }>;
+    private getInterleavedState;
+    private generateMermaid;
+    startNewBlock(blockId: string, topic: string): void;
+    getCurrentBlock(): ThinkingBlock | null;
+    getBlocksSummary(): {
+        id: string;
+        topic: string;
+        status: string;
+        thoughtCount: number;
+    }[];
+}
+export {};