tracelattice 1.2.5

package/dist/core/HistoryManager.d.ts

@@ -0,0 +1,514 @@
+/**
+ * History and branch management for sequential thinking.
+ *
+ * This module provides the `HistoryManager` class which manages thought history,
+ * branching, and optional persistence with per-session state isolation.
+ *
+ * @module HistoryManager
+ */
+import type { IMetrics } from '../contracts/index.js';
+import type { Logger } from '../logger/StructuredLogger.js';
+import type { PersistenceBackend } from '../persistence/PersistenceBackend.js';
+import type { IHistoryManager } from './IHistoryManager.js';
+import type { ThoughtData } from './thought.js';
+/**
+ * Absolute maximum history size. Cannot be overridden by configuration.
+ * Prevents unbounded memory growth from misconfiguration.
+ * At ~2KB per thought, 10K thoughts ≈ ~20MB — reasonable for server-side.
+ * @constant
+ */
+export declare const ABSOLUTE_MAX_HISTORY_SIZE = 10000;
+/**
+ * Interface for emitting persistence error events.
+ * Compatible with EventEmitter's emit method signature.
+ */
+export interface PersistenceEventEmitter {
+    emit(event: 'persistenceError', payload: {
+        operation: string;
+        error: Error;
+    }): boolean;
+}
+/**
+ * Configuration options for creating a `HistoryManager` instance.
+ *
+ * @example
+ * ```typescript
+ * const config: HistoryManagerConfig = {
+ *   maxHistorySize: 500,
+ *   maxBranches: 25,
+ *   maxBranchSize: 50,
+ *   logger: new StructuredLogger(),
+ *   persistence: filePersistence
+ * };
+ * ```
+ */
+export interface HistoryManagerConfig {
+    /**
+     * Maximum number of thoughts to keep in main history.
+     * @default 1000
+     */
+    maxHistorySize?: number;
+    /**
+     * Maximum number of branches to maintain.
+     * @default 50
+     */
+    maxBranches?: number;
+    /**
+     * Maximum size of each branch.
+     * @default 100
+     */
+    maxBranchSize?: number;
+    /** Optional logger for diagnostics. */
+    logger?: Logger;
+    /** Optional persistence backend for saving/loading history. */
+    persistence?: PersistenceBackend | null;
+    metrics?: IMetrics;
+    /**
+     * Maximum number of thoughts to buffer before flushing to persistence.
+     * @default 100
+     */
+    persistenceBufferSize?: number;
+    /**
+     * Interval in milliseconds between periodic persistence flushes.
+     * @default 1000
+     */
+    persistenceFlushInterval?: number;
+    /**
+     * Maximum number of retries for failed persistence flushes.
+     * @default 3
+     */
+    persistenceMaxRetries?: number;
+    /**
+     * Event emitter for persistence error events.
+     * When provided, persistenceError events are emitted on persistent failures.
+     */
+    eventEmitter?: PersistenceEventEmitter;
+}
+/**
+ * Manages thought history and branching for sequential thinking.
+ *
+ * This class is the central component for managing the state of sequential thinking
+ * operations. It handles thought storage, branch management, and optional persistence
+ * for state recovery. State is isolated per session via a `Map<string, SessionState>`.
+ *
+ * @remarks
+ * **History Management:**
+ * - Thoughts are stored in a linear history array per session
+ * - Auto-trimming occurs when `maxHistorySize` is exceeded
+ * - Oldest thoughts are removed first (FIFO eviction)
+ *
+ * **Session Isolation:**
+ * - Each session maintains its own thought history, branches, and cached tools/skills
+ * - Sessions are identified by optional `session_id` on ThoughtData
+ * - Default (undefined) session_id maps to `__global__`
+ * - TTL-based cleanup prevents unbounded memory growth
+ * - LRU eviction when MAX_SESSIONS exceeded
+ *
+ * **Branch Management:**
+ * - Branches allow exploring alternative reasoning paths
+ * - Each branch has its own thought array within a session
+ * - Branches are created when `branch_from_thought` and `branch_id` are set
+ * - Branch count and size are limited by `maxBranches` and `maxBranchSize`
+ *
+ * **Persistence:**
+ * - Optional persistence backend for saving/loading state
+ * - Persists thoughts and branches asynchronously (fire-and-forget)
+ * - Does not block on persistence failures
+ *
+ * @example
+ * ```typescript
+ * const manager = new HistoryManager({
+ *   maxHistorySize: 500,
+ *   maxBranches: 25,
+ *   logger: new StructuredLogger({ context: 'History' })
+ * });
+ *
+ * // Add a thought
+ * manager.addThought({
+ *   thought: 'I need to analyze the problem',
+ *   thought_number: 1,
+ *   total_thoughts: 5,
+ *   next_thought_needed: true
+ * });
+ *
+ * // Get history
+ * const history = manager.getHistory();
+ * console.log(`Thoughts: ${history.length}`);
+ *
+ * // Get branches
+ * const branches = manager.getBranches();
+ * console.log(`Branches: ${Object.keys(branches).length}`);
+ *
+ * // Clear all state
+ * manager.clear();
+ * ```
+ */
+export declare class HistoryManager implements IHistoryManager {
+    /** Default session key for backward-compatible global state. */
+    private static readonly DEFAULT_SESSION;
+    /** TTL for inactive sessions in milliseconds (default: 30 minutes). */
+    private static readonly SESSION_TTL_MS;
+    /** Maximum number of concurrent sessions before eviction. */
+    private static readonly MAX_SESSIONS;
+    /** Session state storage. */
+    private _sessions;
+    /** Timer for periodic session cleanup. */
+    private _sessionCleanupTimer;
+    /** Maximum history size before auto-trimming. */
+    private _maxHistorySize;
+    /** Maximum number of branches before cleanup. */
+    private _maxBranches;
+    /** Maximum size of each branch. */
+    private _maxBranchSize;
+    /** Logger for diagnostics. */
+    private _logger;
+    /** Persistence backend for saving/loading state. */
+    private _persistence;
+    /** Whether persistence is enabled. */
+    private _persistenceEnabled;
+    private _metrics?;
+    /** Timer for periodic buffer flushes. */
+    private _flushTimer;
+    /** Guard to prevent concurrent flushes. */
+    private _isFlushing;
+    /** Tracks consecutive flush failures for backoff. */
+    private _flushRetryCount;
+    /** Maximum buffer size before triggering immediate flush. */
+    private _persistenceBufferSize;
+    /** Interval in milliseconds between periodic flushes. */
+    private _persistenceFlushInterval;
+    /** Maximum number of retries for failed flushes. */
+    private _persistenceMaxRetries;
+    /** Event emitter for persistence error events. */
+    private _eventEmitter;
+    /**
+     * Creates a new HistoryManager instance.
+     *
+     * @param config - Configuration options for the history manager
+     *
+     * @example
+     * ```typescript
+     * const manager = new HistoryManager({
+     *   maxHistorySize: 500,
+     *   maxBranches: 25,
+     *   logger: new StructuredLogger(),
+     *   persistence: filePersistence
+     * });
+     * ```
+     */
+    constructor(config?: HistoryManagerConfig);
+    /**
+     * Internal logging method.
+     * @param message - The message to log
+     * @param meta - Optional metadata
+     * @private
+     */
+    private log;
+    /**
+     * Gets or creates the session state for a given session ID.
+     * Creates a new SessionState if one doesn't exist.
+     * Updates lastAccessedAt on every access.
+     *
+     * @param sessionId - Optional session ID (defaults to `__global__`)
+     * @returns The session state
+     * @private
+     */
+    private _getSession;
+    /**
+     * Adds a thought to the history.
+     *
+     * The thought is appended to the session's history array. If history exceeds
+     * `maxHistorySize`, the oldest thoughts are removed. If the thought
+     * has `branch_from_thought` and `branch_id` set, it's also added to
+     * the appropriate branch. The thought is persisted asynchronously if
+     * persistence is enabled.
+     *
+     * @param thought - The thought data to add
+     *
+     * @example
+     * ```typescript
+     * manager.addThought({
+     *   thought: 'I should read the README file',
+     *   thought_number: 1,
+     *   total_thoughts: 3,
+     *   next_thought_needed: true
+     * });
+     * ```
+     */
+    addThought(thought: ThoughtData): void;
+    /**
+     * Buffers a thought for persistence if enabled.
+     * @param session - The session state to buffer into
+     * @param thought - The thought to buffer
+     * @private
+     */
+    private _bufferForPersistence;
+    /**
+     * Adds a thought to a branch within a specific session.
+     * @param session - The session state
+     * @param branchId - The branch identifier
+     * @param thought - The thought data to add
+     * @private
+     */
+    private _addToSessionBranch;
+    /**
+     * Removes old branches when count exceeds maxBranches within a session.
+     * @param session - The session state
+     * @private
+     */
+    private _cleanupSessionBranches;
+    /**
+     * Trims a branch to maxBranchSize within a session.
+     * @param session - The session state
+     * @param branchId - The branch identifier to trim
+     * @private
+     */
+    private _trimSessionBranchSize;
+    /**
+     * Gets the complete thought history.
+     *
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns An array of all thoughts in chronological order
+     *
+     * @example
+     * ```typescript
+     * const history = manager.getHistory();
+     * history.forEach(thought => {
+     *   console.log(`${thought.thought_number}: ${thought.thought}`);
+     * });
+     * ```
+     */
+    getHistory(sessionId?: string): ThoughtData[];
+    /**
+     * Gets the current length of the thought history.
+     *
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns The number of thoughts in history
+     *
+     * @example
+     * ```typescript
+     * console.log(`Total thoughts: ${manager.getHistoryLength()}`);
+     * ```
+     */
+    getHistoryLength(sessionId?: string): number;
+    /**
+     * Gets all branches.
+     *
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns A record mapping branch IDs to their thought arrays
+     *
+     * @example
+     * ```typescript
+     * const branches = manager.getBranches();
+     * for (const [branchId, thoughts] of Object.entries(branches)) {
+     *   console.log(`Branch ${branchId}: ${thoughts.length} thoughts`);
+     * }
+     * ```
+     */
+    getBranches(sessionId?: string): Record<string, ThoughtData[]>;
+    /**
+     * Gets all branch IDs.
+     *
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns An array of branch identifiers
+     *
+     * @example
+     * ```typescript
+     * const branchIds = manager.getBranchIds();
+     * console.log(`Active branches: ${branchIds.join(', ')}`);
+     * ```
+     */
+    getBranchIds(sessionId?: string): string[];
+    /**
+     * Gets the most recently available MCP tools from the session.
+     *
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns The last-seen array of MCP tool names, or undefined if never set
+     *
+     * @example
+     * ```typescript
+     * const tools = manager.getAvailableMcpTools();
+     * // ['Read', 'Grep', 'Glob'] or undefined
+     * ```
+     */
+    getAvailableMcpTools(sessionId?: string): string[] | undefined;
+    /**
+     * Gets the most recently available skills from the session.
+     *
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns The last-seen array of skill names, or undefined if never set
+     *
+     * @example
+     * ```typescript
+     * const skills = manager.getAvailableSkills();
+     * // ['commit', 'review-pr'] or undefined
+     * ```
+     */
+    getAvailableSkills(sessionId?: string): string[] | undefined;
+    /**
+     * Gets a specific branch by ID.
+     *
+     * @param branchId - The branch identifier
+     * @param sessionId - Optional session ID for session-scoped results
+     * @returns The branch's thought array, or undefined if not found
+     *
+     * @example
+     * ```typescript
+     * const branch = manager.getBranch('alternative-approach');
+     * if (branch) {
+     *   console.log(`Branch has ${branch.length} thoughts`);
+     * } else {
+     *   console.log('Branch not found');
+     * }
+     * ```
+     */
+    getBranch(branchId: string, sessionId?: string): ThoughtData[] | undefined;
+    /**
+     * Clears history and branches.
+     * If sessionId is provided, clears only that session.
+     * If omitted, clears all sessions.
+     *
+     * @param sessionId - Optional session ID to clear
+     *
+     * @example
+     * ```typescript
+     * manager.clear();
+     * console.log('All history and branches cleared');
+     * ```
+     */
+    clear(sessionId?: string): void;
+    /** Clears state for a specific session. Alias for clear(sessionId). */
+    clearSession(sessionId: string): void;
+    /** Gets all active session IDs. */
+    getSessionIds(): string[];
+    /** Gets the number of active sessions. */
+    getSessionCount(): number;
+    /**
+     * Loads history from the persistence backend.
+     *
+     * This should be called during initialization to restore previous state.
+     * Only loads if persistence is enabled and the backend is healthy.
+     * Loads into the global session.
+     *
+     * @returns Promise that resolves when loading is complete
+     *
+     * @example
+     * ```typescript
+     * await manager.loadFromPersistence();
+     * console.log(`Loaded ${manager.getHistoryLength()} thoughts`);
+     * ```
+     */
+    loadFromPersistence(): Promise<void>;
+    /**
+     * Checks if persistence is enabled.
+     *
+     * @returns true if persistence is enabled, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (manager.isPersistenceEnabled()) {
+     *   console.log('Persistence is active');
+     * }
+     * ```
+     */
+    isPersistenceEnabled(): boolean;
+    /**
+     * Gets the persistence backend instance.
+     *
+     * @returns The persistence backend, or null if not configured
+     *
+     * @example
+     * ```typescript
+     * const backend = manager.getPersistenceBackend();
+     * if (backend) {
+     *   await backend.healthy();
+     * }
+     * ```
+     */
+    getPersistenceBackend(): PersistenceBackend | null;
+    /**
+     * Sets the event emitter for persistence error events.
+     * This allows wiring up the event emitter after construction
+     * (e.g., when the server instance is the emitter).
+     *
+     * @param emitter - The event emitter to use for persistence error events
+     */
+    setEventEmitter(emitter: PersistenceEventEmitter): void;
+    /**
+     * Gracefully shuts down the write buffer and session cleanup.
+     * Stops the periodic flush timer and session cleanup timer,
+     * then flushes any remaining buffered writes.
+     * Should be called during server shutdown before closing the persistence backend.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Starts the periodic flush timer for the write buffer.
+     * @private
+     */
+    private _startFlushTimer;
+    /**
+     * Stops the periodic flush timer.
+     * @private
+     */
+    private _stopFlushTimer;
+    /**
+     * Starts the periodic session cleanup timer.
+     * Runs every 5 minutes to evict sessions that exceeded TTL.
+     * @private
+     */
+    private _startSessionCleanupTimer;
+    /**
+     * Stops the periodic session cleanup timer.
+     * @private
+     */
+    private _stopSessionCleanupTimer;
+    /**
+     * Evicts sessions that have been inactive longer than SESSION_TTL_MS.
+     * The global session is never evicted.
+     * @private
+     */
+    private _cleanupStaleSessions;
+    /**
+     * Evicts oldest sessions when MAX_SESSIONS is exceeded (LRU).
+     * The global session is never evicted.
+     * @private
+     */
+    private _evictExcessSessions;
+    /**
+     * Flushes the write buffer to the persistence backend.
+     *
+     * Collects all buffered thoughts across all sessions and saves them
+     * individually with retry logic. On persistent failure (all retries exhausted),
+     * emits a `persistenceError` event and re-queues failed items.
+     *
+     * This method is safe to call concurrently — duplicate calls are skipped.
+     * @internal
+     */
+    _flushBuffer(): Promise<void>;
+    /**
+     * Flushes a single thought to persistence with retry logic.
+     * @param thought - The thought to flush
+     * @returns true if saved successfully, false otherwise
+     * @private
+     */
+    private _flushSingleThought;
+    /**
+     * Handles the result of a flush operation, re-queuing failures.
+     * @param failedItems - Thoughts that failed to persist
+     * @param totalCount - Total number of thoughts attempted
+     * @private
+     */
+    private _handleFlushResult;
+    /**
+     * Returns a promise that resolves after the specified delay.
+     * @param ms - Delay in milliseconds
+     * @private
+     */
+    private _delay;
+    /**
+     * Gets the current write buffer length across all sessions.
+     * Useful for monitoring and testing.
+     */
+    getWriteBufferLength(): number;
+}
+//# sourceMappingURL=HistoryManager.d.ts.map

package/dist/core/HistoryManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HistoryManager.d.ts","sourceRoot":"","sources":["../../src/core/HistoryManager.ts"],"names":[],"mappings":"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"}