@j0hanz/thinkseq-mcp 1.2.6 → 2.0.0

package/README.md

@@ -133,6 +133,7 @@ Record a concise thinking step. Be brief: capture only the essential insight, ca
 | Field            | Type   | Required | Description                                                        |
 | :--------------- | :----- | :------: | :----------------------------------------------------------------- |
 | `thought`        | string |   yes    | Current thinking step (1-8000 chars).                              |
+| `sessionId`      | string |    no    | Optional session identifier to isolate thought histories.          |
 | `totalThoughts`  | number |    no    | Estimated total thoughts (1-25, default: 3).                       |
 | `revisesThought` | number |    no    | Revise a previous thought by number. Original preserved for audit. |
 

package/dist/app.d.ts

@@ -1,4 +1,5 @@
-import { type ProcessLike, type RunDependencies } from './appConfig.js';
+import type { RunDependencies } from './appConfig/runDependencies.js';
+import type { ProcessLike } from './appConfig/types.js';
 interface ProcessErrorHandlerDeps {
     processLike?: ProcessLike;
     logError?: (message: string) => void;
@@ -7,4 +8,3 @@ interface ProcessErrorHandlerDeps {
 export declare function installProcessErrorHandlers(deps?: ProcessErrorHandlerDeps): void;
 export declare function run(deps?: RunDependencies): Promise<void>;
 export {};
-//# sourceMappingURL=app.d.ts.map

package/dist/app.js

@@ -1,4 +1,5 @@
-import { buildShutdownDependencies, resolvePackageIdentity, resolveRunDependencies, } from './appConfig.js';
+import { resolvePackageIdentity, resolveRunDependencies, } from './appConfig/runDependencies.js';
+import { buildShutdownDependencies } from './appConfig/shutdown.js';
 import { installConsoleBridge, installMcpLogging } from './lib/mcpLogging.js';
 const toError = (value) => value instanceof Error ? value : new Error(String(value));
 const createExit = (proc, exit) => exit ?? ((code) => proc.exit(code));
@@ -21,7 +22,8 @@ export async function run(deps = {}) {
     const { name, version } = resolvePackageIdentity(pkg);
     const server = resolved.createServer(name, version);
     installMcpLogging(server);
-    installConsoleBridge(server);
+    const { flush: flushConsole, restore: restoreConsole } = installConsoleBridge(server);
+    process.on('exit', restoreConsole);
     resolved.publishLifecycleEvent({
         type: 'lifecycle.started',
         ts: resolved.now(),
@@ -29,6 +31,6 @@ export async function run(deps = {}) {
     const engine = resolved.engineFactory();
     resolved.registerTool(server, engine);
     const transport = await resolved.connectServer(server);
+    flushConsole();
     resolved.installShutdownHandlers(buildShutdownDependencies(resolved, { server, engine, transport }));
 }
-//# sourceMappingURL=app.js.map

package/dist/appConfig/runDependencies.d.ts

@@ -33,4 +33,3 @@ export declare function resolvePackageIdentity(pkg: PackageInfo): {
     name: string;
     version: string;
 };
-//# sourceMappingURL=runDependencies.d.ts.map

package/dist/appConfig/runDependencies.js

@@ -23,7 +23,17 @@ function loadServerInstructions() {
     return trimmed.length > 0 ? trimmed : INSTRUCTIONS_FALLBACK;
 }
 function registerInstructionsResource(server) {
-    server.registerResource('instructions', new ResourceTemplate('internal://instructions', { list: undefined }), { title: 'Instructions', mimeType: 'text/markdown' }, (uri) => ({
+    server.registerResource('instructions', new ResourceTemplate('internal://instructions', {
+        list: () => ({
+            resources: [
+                {
+                    uri: 'internal://instructions',
+                    name: 'Instructions',
+                    mimeType: 'text/markdown',
+                },
+            ],
+        }),
+    }), { title: 'Instructions', mimeType: 'text/markdown' }, (uri) => ({
         contents: [
             {
                 uri: uri.href,
@@ -40,7 +50,7 @@ function buildServerConfig() {
         instructions: SERVER_INSTRUCTIONS,
         capabilities: {
             logging: {},
-            tools: { listChanged: true },
+            tools: { listChanged: false },
             resources: { subscribe: false, listChanged: false },
             prompts: { listChanged: false },
         },
@@ -105,4 +115,3 @@ export function resolvePackageIdentity(pkg) {
         version: pkg.version ?? '0.0.0',
     };
 }
-//# sourceMappingURL=runDependencies.js.map

package/dist/appConfig/shutdown.d.ts

@@ -16,4 +16,3 @@ export declare function buildShutdownDependencies(resolved: ResolvedRunDependenc
     engine: unknown;
     transport: unknown;
 }): ShutdownDependencies;
-//# sourceMappingURL=shutdown.d.ts.map

package/dist/appConfig/shutdown.js

@@ -67,4 +67,3 @@ export function buildShutdownDependencies(resolved, payload) {
         ? { ...base, shutdownTimeoutMs: resolved.shutdownTimeoutMs }
         : base;
 }
-//# sourceMappingURL=shutdown.js.map

package/dist/appConfig/types.d.ts

@@ -3,4 +3,3 @@ export type { CloseFn, EngineLike } from '../lib/types.js';
 export type ProcessLike = Pick<typeof process, 'on' | 'exit'>;
 export type TransportLike = Parameters<McpServer['connect']>[0];
 export type ServerLike = Pick<McpServer, 'connect' | 'registerTool' | 'registerResource' | 'registerPrompt' | 'sendLoggingMessage'>;
-//# sourceMappingURL=types.d.ts.map

package/dist/appConfig/types.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=types.js.map

package/dist/engine/revision.d.ts

@@ -1,9 +1,10 @@
 import type { ProcessResult, StoredThought, ThoughtData } from '../lib/types.js';
-export declare function resolveRevisionTarget(input: ThoughtData, getThoughtByNumber: (thoughtNumber: number) => StoredThought | undefined): {
+export type RevisionTargetResolution = {
     ok: true;
     targetNumber: number;
+    target: StoredThought;
 } | {
     ok: false;
-    error: ProcessResult;
+    result: ProcessResult;
 };
-//# sourceMappingURL=revision.d.ts.map
+export declare function resolveRevisionTarget(input: ThoughtData, getThoughtByNumber: (thoughtNumber: number) => StoredThought | undefined): RevisionTargetResolution;

package/dist/engine/revision.js

@@ -1,26 +1,31 @@
+function missingRevisionError() {
+    return {
+        ok: false,
+        result: buildRevisionError('E_REVISION_MISSING', 'revisesThought is required for revision'),
+    };
+}
+function targetNotFoundError(targetNumber) {
+    return {
+        ok: false,
+        result: buildRevisionError('E_REVISION_TARGET_NOT_FOUND', `Thought ${targetNumber} not found`),
+    };
+}
+function targetSupersededError(targetNumber) {
+    return {
+        ok: false,
+        result: buildRevisionError('E_REVISION_TARGET_SUPERSEDED', `Thought ${targetNumber} was already superseded`),
+    };
+}
 export function resolveRevisionTarget(input, getThoughtByNumber) {
     const targetNumber = input.revisesThought;
-    if (targetNumber === undefined) {
-        return {
-            ok: false,
-            error: buildRevisionError('E_REVISION_MISSING', 'revisesThought is required for revision'),
-        };
-    }
-    const validationError = validateRevisionTarget(getThoughtByNumber, targetNumber);
-    if (validationError) {
-        return { ok: false, error: validationError };
-    }
-    return { ok: true, targetNumber };
-}
-function validateRevisionTarget(getThoughtByNumber, targetNumber) {
+    if (targetNumber === undefined)
+        return missingRevisionError();
     const target = getThoughtByNumber(targetNumber);
-    if (!target) {
-        return buildRevisionError('E_REVISION_TARGET_NOT_FOUND', `Thought ${targetNumber} not found`);
-    }
-    if (!target.isActive) {
-        return buildRevisionError('E_REVISION_TARGET_SUPERSEDED', `Thought ${targetNumber} was already superseded`);
-    }
-    return undefined;
+    if (!target)
+        return targetNotFoundError(targetNumber);
+    if (!target.isActive)
+        return targetSupersededError(targetNumber);
+    return { ok: true, targetNumber, target };
 }
 function buildRevisionError(code, message) {
     return {
@@ -28,4 +33,3 @@ function buildRevisionError(code, message) {
         error: { code, message },
     };
 }
-//# sourceMappingURL=revision.js.map

package/dist/engine/thoughtQueries.d.ts

@@ -1,3 +1,2 @@
 import type { ContextSummary, RevisionInfo, StoredThought } from '../lib/types.js';
 export declare function buildContextSummary(activeThoughts: readonly StoredThought[], revisionInfo?: RevisionInfo): ContextSummary;
-//# sourceMappingURL=thoughtQueries.d.ts.map

package/dist/engine/thoughtQueries.js

@@ -1,35 +1,42 @@
+const MAX_PREVIEW_CHARS = 100;
+const MAX_RECENT_THOUGHTS = 5;
+const RECENT_TAIL_COUNT = 4;
 function selectRecentThoughts(activeThoughts) {
-    if (activeThoughts.length <= 5) {
-        const recent = activeThoughts.slice();
-        const stepIndexes = recent.map((_, index) => index + 1);
-        return { recent, stepIndexes };
+    const len = activeThoughts.length;
+    const recent = [];
+    const stepIndexes = [];
+    if (len > MAX_RECENT_THOUGHTS) {
+        const anchor = activeThoughts[0];
+        if (!anchor)
+            throw new Error('Invariant violation: anchor thought missing');
+        recent.push(anchor);
+        stepIndexes.push(1);
+    }
+    const start = len <= MAX_RECENT_THOUGHTS ? 0 : Math.max(0, len - RECENT_TAIL_COUNT);
+    for (let i = start; i < len; i += 1) {
+        const thought = activeThoughts[i];
+        if (thought) {
+            recent.push(thought);
+            stepIndexes.push(i + 1);
+        }
     }
-    const anchor = activeThoughts[0];
-    if (!anchor)
-        throw new Error('Invariant violation: anchor thought missing');
-    const tail = activeThoughts.slice(-4);
-    const recent = [anchor, ...tail];
-    const stepIndexes = [
-        1,
-        ...tail.map((_, index) => activeThoughts.length - 4 + index + 1),
-    ];
     return { recent, stepIndexes };
 }
-function formatThoughtPreview(thought) {
-    if (thought.length <= 100)
-        return thought;
-    return `${thought.slice(0, 100)}...`;
+function truncatePreview(input, maxChars) {
+    const codepoints = Array.from(input);
+    if (codepoints.length <= maxChars)
+        return input;
+    return `${codepoints.slice(0, maxChars).join('')}...`;
 }
 export function buildContextSummary(activeThoughts, revisionInfo) {
     const { recent, stepIndexes } = selectRecentThoughts(activeThoughts);
     const recentThoughts = recent.map((thought, index) => ({
         stepIndex: stepIndexes[index] ?? index + 1,
         number: thought.thoughtNumber,
-        preview: formatThoughtPreview(thought.thought),
+        preview: truncatePreview(thought.thought, MAX_PREVIEW_CHARS),
     }));
     if (revisionInfo !== undefined) {
         return { recentThoughts, revisionInfo };
     }
     return { recentThoughts };
 }
-//# sourceMappingURL=thoughtQueries.js.map

package/dist/engine/thoughtStore.d.ts

@@ -4,6 +4,12 @@ export interface ThoughtStoreOptions {
     maxMemoryBytes: number;
     estimatedThoughtOverheadBytes: number;
 }
+export interface PruneStats {
+    truncatedActive: boolean;
+    droppedActiveCount: number;
+    removedThoughtsCount: number;
+    oldestAvailableThoughtNumber: number | null;
+}
 export declare class ThoughtStore {
     #private;
     constructor(options: ThoughtStoreOptions);
@@ -11,12 +17,15 @@ export declare class ThoughtStore {
         thoughtNumber: number;
         totalThoughts: number;
     };
+    getLastPruneStats(): PruneStats | null;
     storeThought(stored: StoredThought): void;
-    supersedeFrom(targetNumber: number, supersededBy: number): readonly number[];
+    supersedeFrom(targetNumber: number, supersededBy: number, maxSupersedes?: number): {
+        supersedes: number[];
+        supersedesTotal: number;
+    };
     getActiveThoughts(): readonly StoredThought[];
-    getActiveThoughtNumbers(): readonly number[];
+    getActiveThoughtNumbers(max?: number): number[];
     getThoughtByNumber(thoughtNumber: number): StoredThought | undefined;
     getTotalLength(): number;
     pruneHistoryIfNeeded(): void;
 }
-//# sourceMappingURL=thoughtStore.d.ts.map

package/dist/engine/thoughtStore.js

@@ -8,6 +8,7 @@ export class ThoughtStore {
     #headIndex = 0;
     #nextThoughtNumber = 1;
     #estimatedBytes = 0;
+    #lastPruneStats = null;
     #maxThoughts;
     #maxMemoryBytes;
     #estimatedThoughtOverheadBytes;
@@ -19,11 +20,11 @@ export class ThoughtStore {
     nextThoughtNumbers(totalThoughts) {
         const thoughtNumber = this.#nextThoughtNumber;
         this.#nextThoughtNumber += 1;
-        const effectiveTotalThoughts = Math.max(totalThoughts, thoughtNumber, this.#activeMaxTotalThoughts);
-        return {
-            thoughtNumber,
-            totalThoughts: effectiveTotalThoughts,
-        };
+        const effectiveTotalThoughts = Math.max(totalThoughts, this.#activeMaxTotalThoughts);
+        return { thoughtNumber, totalThoughts: effectiveTotalThoughts };
+    }
+    getLastPruneStats() {
+        return this.#lastPruneStats;
     }
     storeThought(stored) {
         this.#thoughts.push(stored);
@@ -42,34 +43,45 @@ export class ThoughtStore {
         }
         this.#activeMaxTotalThoughts = maxTotal;
     }
-    #findActiveThoughtIndex(thoughtNumber) {
+    #findActiveLowerBound(thoughtNumber) {
         const activeThoughtNumbers = this.#activeThoughtNumbers;
         let low = 0;
         let high = activeThoughtNumbers.length;
         while (low < high) {
             const mid = (low + high) >>> 1;
             const midValue = activeThoughtNumbers[mid];
-            if (midValue === undefined) {
+            if (midValue === undefined)
                 return -1;
-            }
-            if (midValue < thoughtNumber) {
+            if (midValue < thoughtNumber)
                 low = mid + 1;
-            }
-            else {
+            else
                 high = mid;
-            }
-        }
-        if (low < activeThoughtNumbers.length &&
-            activeThoughtNumbers[low] === thoughtNumber) {
-            return low;
         }
+        return low;
+    }
+    #findActiveThoughtIndex(thoughtNumber) {
+        const index = this.#findActiveLowerBound(thoughtNumber);
+        if (index < 0)
+            return -1;
+        if (index < this.#activeThoughtNumbers.length &&
+            this.#activeThoughtNumbers[index] === thoughtNumber)
+            return index;
         return -1;
     }
-    supersedeFrom(targetNumber, supersededBy) {
+    #findFirstActiveIndexAfter(thoughtNumber) {
+        const index = this.#findActiveLowerBound(thoughtNumber);
+        if (index < 0)
+            return 0;
+        if (this.#activeThoughtNumbers[index] === thoughtNumber)
+            return index + 1;
+        return index;
+    }
+    supersedeFrom(targetNumber, supersededBy, maxSupersedes) {
         const startIndex = this.#findActiveThoughtIndex(targetNumber);
         if (startIndex < 0)
-            return [];
+            return { supersedes: [], supersedesTotal: 0 };
         const supersedes = [];
+        let supersedesTotal = 0;
         for (let i = startIndex; i < this.#activeThoughts.length; i += 1) {
             const thought = this.#activeThoughts[i];
             if (!thought)
@@ -78,18 +90,29 @@ export class ThoughtStore {
                 thought.isActive = false;
                 thought.supersededBy = supersededBy;
             }
-            supersedes.push(thought.thoughtNumber);
+            supersedesTotal += 1;
+            if (maxSupersedes === undefined || supersedes.length < maxSupersedes) {
+                supersedes.push(thought.thoughtNumber);
+            }
         }
         this.#activeThoughts.length = startIndex;
         this.#activeThoughtNumbers.length = startIndex;
         this.#recomputeActiveMaxTotalThoughts();
-        return supersedes;
+        return { supersedes, supersedesTotal };
     }
     getActiveThoughts() {
         return this.#activeThoughts;
     }
-    getActiveThoughtNumbers() {
-        return this.#activeThoughtNumbers.slice();
+    getActiveThoughtNumbers(max) {
+        if (max === undefined) {
+            return this.#activeThoughtNumbers.slice();
+        }
+        if (max <= 0)
+            return [];
+        if (this.#activeThoughtNumbers.length <= max) {
+            return this.#activeThoughtNumbers.slice();
+        }
+        return this.#activeThoughtNumbers.slice(-max);
     }
     getThoughtByNumber(thoughtNumber) {
         return this.#thoughtIndex.get(thoughtNumber);
@@ -98,6 +121,18 @@ export class ThoughtStore {
         return this.#thoughts.length - this.#headIndex;
     }
     pruneHistoryIfNeeded() {
+        const beforeTotal = this.getTotalLength();
+        const beforeActive = this.#activeThoughts.length;
+        this.#lastPruneStats = {
+            truncatedActive: false,
+            droppedActiveCount: 0,
+            removedThoughtsCount: 0,
+            oldestAvailableThoughtNumber: this.#thoughts[this.#headIndex]?.thoughtNumber ?? null,
+        };
+        this.#performPruning();
+        this.#updatePruneStats(beforeTotal, beforeActive);
+    }
+    #performPruning() {
         const excess = this.getTotalLength() - this.#maxThoughts;
         if (excess > 0) {
             const batch = Math.max(excess, Math.ceil(this.#maxThoughts * 0.1));
@@ -109,19 +144,24 @@ export class ThoughtStore {
             this.#removeOldest(toRemove, { forceCompact: true });
         }
     }
+    #updatePruneStats(beforeTotal, beforeActive) {
+        if (!this.#lastPruneStats)
+            return;
+        const afterActive = this.#activeThoughts.length;
+        const stats = this.#lastPruneStats;
+        stats.removedThoughtsCount = Math.max(0, beforeTotal - this.getTotalLength());
+        stats.droppedActiveCount = Math.max(0, beforeActive - afterActive);
+        stats.truncatedActive = stats.droppedActiveCount > 0;
+        stats.oldestAvailableThoughtNumber =
+            this.#thoughts[this.#headIndex]?.thoughtNumber ?? null;
+    }
     #estimateThoughtBytes(thought) {
-        return thought.thought.length * 2 + this.#estimatedThoughtOverheadBytes;
+        return thought.byteLength + this.#estimatedThoughtOverheadBytes;
     }
     #dropActiveThoughtsUpTo(thoughtNumber) {
         if (this.#activeThoughts.length === 0)
             return;
-        let startIndex = 0;
-        while (startIndex < this.#activeThoughts.length) {
-            const thought = this.#activeThoughts[startIndex];
-            if (!thought || thought.thoughtNumber > thoughtNumber)
-                break;
-            startIndex += 1;
-        }
+        const startIndex = this.#findFirstActiveIndexAfter(thoughtNumber);
         if (startIndex === 0)
             return;
         this.#activeThoughts = this.#activeThoughts.slice(startIndex);
@@ -186,6 +226,6 @@ export class ThoughtStore {
         this.#headIndex = 0;
         this.#nextThoughtNumber = 1;
         this.#estimatedBytes = 0;
+        this.#lastPruneStats = null;
     }
 }
-//# sourceMappingURL=thoughtStore.js.map

package/dist/engine.d.ts

@@ -3,11 +3,12 @@ export interface ThinkingEngineOptions {
     maxThoughts?: number;
     maxMemoryBytes?: number;
     estimatedThoughtOverheadBytes?: number;
+    maxSessions?: number;
 }
 export declare class ThinkingEngine {
     #private;
     static readonly DEFAULT_TOTAL_THOUGHTS = 3;
     constructor(options?: ThinkingEngineOptions);
     processThought(input: ThoughtData): ProcessResult;
+    processThoughtWithSession(sessionId: string, input: ThoughtData): ProcessResult;
 }
-//# sourceMappingURL=engine.d.ts.map