tracelattice 1.2.5

package/dist/health/HealthChecker.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Aggregate health checking system.
+ *
+ * Provides liveness and readiness checks by aggregating the health
+ * status of registered backend components (persistence, pool, etc.).
+ *
+ * @module health
+ */
+import type { Logger } from '../logger/StructuredLogger.js';
+import type { PersistenceBackend } from '../persistence/PersistenceBackend.js';
+/**
+ * Health status of an individual component.
+ */
+export interface HealthComponent {
+    name: string;
+    healthy: boolean;
+    details?: string;
+    latencyMs?: number;
+}
+/**
+ * Aggregate health check result.
+ */
+export interface HealthCheckResult {
+    status: 'ok' | 'degraded' | 'unhealthy';
+    timestamp: string;
+    components: Record<string, HealthComponent>;
+}
+/**
+ * Options for constructing a HealthChecker.
+ */
+export interface HealthCheckerOptions {
+    persistence?: PersistenceBackend | null;
+    logger?: Logger;
+}
+/**
+ * Aggregates component health into liveness and readiness checks.
+ *
+ * - `checkLiveness()` always returns 'ok' if the process is running.
+ * - `checkReadiness()` checks all registered backends and returns an aggregate status.
+ *
+ * @example
+ * ```typescript
+ * const checker = new HealthChecker({ persistence: myBackend });
+ * const readiness = await checker.checkReadiness();
+ * // { status: 'ok', timestamp: '...', components: { persistence: { ... } } }
+ * ```
+ */
+export declare class HealthChecker {
+    private _persistence;
+    private _logger;
+    constructor(options?: HealthCheckerOptions);
+    /**
+     * Liveness check — returns 'ok' if the process is alive.
+     *
+     * This is a synchronous check that always succeeds; if this code
+     * can execute, the process is alive.
+     */
+    checkLiveness(): HealthCheckResult;
+    /**
+     * Readiness check — aggregates health of all registered backends.
+     *
+     * Checks each component and returns:
+     * - 'ok' if all components are healthy (or no components registered)
+     * - 'degraded' if some components are unhealthy
+     * - 'unhealthy' if all components are unhealthy
+     */
+    checkReadiness(): Promise<HealthCheckResult>;
+    /**
+     * Check persistence backend health with latency measurement.
+     */
+    private _checkPersistence;
+}
+//# sourceMappingURL=HealthChecker.d.ts.map

package/dist/health/HealthChecker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HealthChecker.d.ts","sourceRoot":"","sources":["../../src/health/HealthChecker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,+BAA+B,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,sCAAsC,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC,MAAM,EAAE,IAAI,GAAG,UAAU,GAAG,WAAW,CAAC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;CAC5C;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,WAAW,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACxC,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAYD;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;IACzB,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,OAAO,CAAoD;gBAEvD,OAAO,GAAE,oBAAyB;IAK9C;;;;;OAKG;IACH,aAAa,IAAI,iBAAiB;IAQlC;;;;;;;OAOG;IACG,cAAc,IAAI,OAAO,CAAC,iBAAiB,CAAC;IAyClD;;OAEG;YACW,iBAAiB;CAsB/B"}

package/dist/health/HealthChecker.js

@@ -0,0 +1,69 @@
+class NoopLogger {
+    info() {}
+    warn() {}
+    error() {}
+    debug() {}
+}
+class HealthChecker {
+    _persistence;
+    _logger;
+    constructor(options = {}){
+        this._persistence = options.persistence ?? null;
+        this._logger = options.logger ?? new NoopLogger();
+    }
+    checkLiveness() {
+        return {
+            status: 'ok',
+            timestamp: new Date().toISOString(),
+            components: {}
+        };
+    }
+    async checkReadiness() {
+        const components = {};
+        let healthyCount = 0;
+        let totalCount = 0;
+        if (this._persistence) {
+            totalCount++;
+            const component = await this._checkPersistence();
+            components['persistence'] = component;
+            if (component.healthy) healthyCount++;
+        }
+        let status;
+        status = 0 === totalCount || healthyCount === totalCount ? 'ok' : 0 === healthyCount ? 'unhealthy' : 'degraded';
+        const result = {
+            status,
+            timestamp: new Date().toISOString(),
+            components
+        };
+        if ('ok' !== status) this._logger.warn('Readiness check returned non-ok status', {
+            status,
+            components
+        });
+        return result;
+    }
+    async _checkPersistence() {
+        const start = Date.now();
+        try {
+            const healthy = await this._persistence.healthy();
+            return {
+                name: 'persistence',
+                healthy,
+                latencyMs: Date.now() - start,
+                details: healthy ? 'Backend is responsive' : 'Backend reported unhealthy'
+            };
+        } catch (error) {
+            this._logger.error('Persistence health check failed', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return {
+                name: 'persistence',
+                healthy: false,
+                latencyMs: Date.now() - start,
+                details: `Health check error: ${error instanceof Error ? error.message : String(error)}`
+            };
+        }
+    }
+}
+export { HealthChecker };
+
+//# sourceMappingURL=HealthChecker.js.map

package/dist/health/HealthChecker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"health/HealthChecker.js","sources":["../../src/health/HealthChecker.ts"],"sourcesContent":["/**\n * Aggregate health checking system.\n *\n * Provides liveness and readiness checks by aggregating the health\n * status of registered backend components (persistence, pool, etc.).\n *\n * @module health\n */\n\nimport type { Logger } from '../logger/StructuredLogger.js';\nimport type { PersistenceBackend } from '../persistence/PersistenceBackend.js';\n\n/**\n * Health status of an individual component.\n */\nexport interface HealthComponent {\n\tname: string;\n\thealthy: boolean;\n\tdetails?: string;\n\tlatencyMs?: number;\n}\n\n/**\n * Aggregate health check result.\n */\nexport interface HealthCheckResult {\n\tstatus: 'ok' | 'degraded' | 'unhealthy';\n\ttimestamp: string;\n\tcomponents: Record<string, HealthComponent>;\n}\n\n/**\n * Options for constructing a HealthChecker.\n */\nexport interface HealthCheckerOptions {\n\tpersistence?: PersistenceBackend | null;\n\tlogger?: Logger;\n}\n\n/**\n * No-op logger used when none is provided.\n */\nclass NoopLogger implements Pick<Logger, 'info' | 'warn' | 'error' | 'debug'> {\n\tinfo(): void {}\n\twarn(): void {}\n\terror(): void {}\n\tdebug(): void {}\n}\n\n/**\n * Aggregates component health into liveness and readiness checks.\n *\n * - `checkLiveness()` always returns 'ok' if the process is running.\n * - `checkReadiness()` checks all registered backends and returns an aggregate status.\n *\n * @example\n * ```typescript\n * const checker = new HealthChecker({ persistence: myBackend });\n * const readiness = await checker.checkReadiness();\n * // { status: 'ok', timestamp: '...', components: { persistence: { ... } } }\n * ```\n */\nexport class HealthChecker {\n\tprivate _persistence: PersistenceBackend | null;\n\tprivate _logger: Pick<Logger, 'info' | 'warn' | 'error' | 'debug'>;\n\n\tconstructor(options: HealthCheckerOptions = {}) {\n\t\tthis._persistence = options.persistence ?? null;\n\t\tthis._logger = options.logger ?? new NoopLogger();\n\t}\n\n\t/**\n\t * Liveness check — returns 'ok' if the process is alive.\n\t *\n\t * This is a synchronous check that always succeeds; if this code\n\t * can execute, the process is alive.\n\t */\n\tcheckLiveness(): HealthCheckResult {\n\t\treturn {\n\t\t\tstatus: 'ok',\n\t\t\ttimestamp: new Date().toISOString(),\n\t\t\tcomponents: {},\n\t\t};\n\t}\n\n\t/**\n\t * Readiness check — aggregates health of all registered backends.\n\t *\n\t * Checks each component and returns:\n\t * - 'ok' if all components are healthy (or no components registered)\n\t * - 'degraded' if some components are unhealthy\n\t * - 'unhealthy' if all components are unhealthy\n\t */\n\tasync checkReadiness(): Promise<HealthCheckResult> {\n\t\tconst components: Record<string, HealthComponent> = {};\n\t\tlet healthyCount = 0;\n\t\tlet totalCount = 0;\n\n\t\t// Check persistence backend\n\t\tif (this._persistence) {\n\t\t\ttotalCount++;\n\t\t\tconst component = await this._checkPersistence();\n\t\t\tcomponents['persistence'] = component;\n\t\t\tif (component.healthy) {\n\t\t\t\thealthyCount++;\n\t\t\t}\n\t\t}\n\n\t\t// Determine aggregate status\n\t\tlet status: 'ok' | 'degraded' | 'unhealthy';\n\t\tif (totalCount === 0 || healthyCount === totalCount) {\n\t\t\tstatus = 'ok';\n\t\t} else if (healthyCount === 0) {\n\t\t\tstatus = 'unhealthy';\n\t\t} else {\n\t\t\tstatus = 'degraded';\n\t\t}\n\n\t\tconst result: HealthCheckResult = {\n\t\t\tstatus,\n\t\t\ttimestamp: new Date().toISOString(),\n\t\t\tcomponents,\n\t\t};\n\n\t\tif (status !== 'ok') {\n\t\t\tthis._logger.warn('Readiness check returned non-ok status', {\n\t\t\t\tstatus,\n\t\t\t\tcomponents,\n\t\t\t});\n\t\t}\n\n\t\treturn result;\n\t}\n\n\t/**\n\t * Check persistence backend health with latency measurement.\n\t */\n\tprivate async _checkPersistence(): Promise<HealthComponent> {\n\t\tconst start = Date.now();\n\t\ttry {\n\t\t\tconst healthy = await this._persistence!.healthy();\n\t\t\treturn {\n\t\t\t\tname: 'persistence',\n\t\t\t\thealthy,\n\t\t\t\tlatencyMs: Date.now() - start,\n\t\t\t\tdetails: healthy ? 'Backend is responsive' : 'Backend reported unhealthy',\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tthis._logger.error('Persistence health check failed', {\n\t\t\t\terror: error instanceof Error ? error.message : String(error),\n\t\t\t});\n\t\t\treturn {\n\t\t\t\tname: 'persistence',\n\t\t\t\thealthy: false,\n\t\t\t\tlatencyMs: Date.now() - start,\n\t\t\t\tdetails: `Health check error: ${error instanceof Error ? error.message : String(error)}`,\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["NoopLogger","HealthChecker","options","Date","components","healthyCount","totalCount","component","status","result","start","healthy","error","Error","String"],"mappings":"AA0CA,MAAMA;IACL,OAAa,CAAC;IACd,OAAa,CAAC;IACd,QAAc,CAAC;IACf,QAAc,CAAC;AAChB;AAeO,MAAMC;IACJ,aAAwC;IACxC,QAA2D;IAEnE,YAAYC,UAAgC,CAAC,CAAC,CAAE;QAC/C,IAAI,CAAC,YAAY,GAAGA,QAAQ,WAAW,IAAI;QAC3C,IAAI,CAAC,OAAO,GAAGA,QAAQ,MAAM,IAAI,IAAIF;IACtC;IAQA,gBAAmC;QAClC,OAAO;YACN,QAAQ;YACR,WAAW,IAAIG,OAAO,WAAW;YACjC,YAAY,CAAC;QACd;IACD;IAUA,MAAM,iBAA6C;QAClD,MAAMC,aAA8C,CAAC;QACrD,IAAIC,eAAe;QACnB,IAAIC,aAAa;QAGjB,IAAI,IAAI,CAAC,YAAY,EAAE;YACtBA;YACA,MAAMC,YAAY,MAAM,IAAI,CAAC,iBAAiB;YAC9CH,UAAU,CAAC,cAAc,GAAGG;YAC5B,IAAIA,UAAU,OAAO,EACpBF;QAEF;QAGA,IAAIG;QAEHA,SADGF,AAAe,MAAfA,cAAoBD,iBAAiBC,aAC/B,OACCD,AAAiB,MAAjBA,eACD,cAEA;QAGV,MAAMI,SAA4B;YACjCD;YACA,WAAW,IAAIL,OAAO,WAAW;YACjCC;QACD;QAEA,IAAII,AAAW,SAAXA,QACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,0CAA0C;YAC3DA;YACAJ;QACD;QAGD,OAAOK;IACR;IAKA,MAAc,oBAA8C;QAC3D,MAAMC,QAAQP,KAAK,GAAG;QACtB,IAAI;YACH,MAAMQ,UAAU,MAAM,IAAI,CAAC,YAAY,CAAE,OAAO;YAChD,OAAO;gBACN,MAAM;gBACNA;gBACA,WAAWR,KAAK,GAAG,KAAKO;gBACxB,SAASC,UAAU,0BAA0B;YAC9C;QACD,EAAE,OAAOC,OAAO;YACf,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,mCAAmC;gBACrD,OAAOA,iBAAiBC,QAAQD,MAAM,OAAO,GAAGE,OAAOF;YACxD;YACA,OAAO;gBACN,MAAM;gBACN,SAAS;gBACT,WAAWT,KAAK,GAAG,KAAKO;gBACxB,SAAS,CAAC,oBAAoB,EAAEE,iBAAiBC,QAAQD,MAAM,OAAO,GAAGE,OAAOF,QAAQ;YACzF;QACD;IACD;AACD"}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from "./lib.js";

package/dist/lib.d.ts

@@ -0,0 +1,205 @@
+import { EventEmitter } from 'node:events';
+import * as v from 'valibot';
+import { ThoughtData } from './core/thought.js';
+import { SequentialThinkingSchema } from './schema.js';
+import { IDisposable } from './types/disposable.js';
+import type { ConfigFileOptions } from './config/ConfigLoader.js';
+import { HistoryManager } from './core/HistoryManager.js';
+import { Container } from './di/Container.js';
+import { StructuredLogger } from './logger/StructuredLogger.js';
+import { SkillRegistry } from './registry/SkillRegistry.js';
+import { ToolRegistry } from './registry/ToolRegistry.js';
+import { ServerConfig } from './ServerConfig.js';
+import type { SseTransportOptions } from './transport/SseTransport.js';
+export interface ServerOptions {
+    maxHistorySize?: number;
+    maxBranches?: number;
+    maxBranchSize?: number;
+    logger?: StructuredLogger;
+    enableWatcher?: boolean;
+    config?: ServerConfig;
+    fileConfig?: ConfigFileOptions;
+    container?: Container;
+    /**
+     * Enable automatic skill discovery on server startup
+     * @default true
+     */
+    autoDiscover?: boolean;
+    /**
+     * Enable lazy discovery (discover on first access instead of startup)
+     * @default false
+     */
+    lazyDiscovery?: boolean;
+    /**
+     * Load history from persistence on initialization
+     * @default true
+     */
+    loadFromPersistence?: boolean;
+    /**
+     * Transport type to use
+     * @default 'stdio'
+     */
+    transport?: 'stdio' | 'sse';
+    /**
+     * SSE transport options (used when transport: 'sse')
+     */
+    sseTransportOptions?: SseTransportOptions;
+}
+/**
+ * Server error events for event-driven error handling
+ */
+interface ServerEvents {
+    persistenceError: {
+        operation: string;
+        error: Error;
+    };
+    discoveryError: {
+        directory: string;
+        error: Error;
+    };
+    transportError: {
+        transport: string;
+        error: Error;
+    };
+    thoughtProcessed: {
+        thoughtNumber: number;
+        duration: number;
+    };
+}
+export declare class ToolAwareSequentialThinkingServer extends EventEmitter implements IDisposable {
+    /**
+     * Factory method to create a new server instance with async initialization.
+     * This is the recommended way to create server instances.
+     *
+     * @param options - Server configuration options
+     * @returns A Promise that resolves to a configured server instance
+     */
+    static create(options?: ServerOptions): Promise<ToolAwareSequentialThinkingServer>;
+    emit<K extends keyof ServerEvents>(event: K, payload: ServerEvents[K]): boolean;
+    on<K extends keyof ServerEvents>(event: K, listener: (payload: ServerEvents[K]) => void): this;
+    private _container;
+    private _logger;
+    private _historyManager;
+    private _thoughtProcessor;
+    private _metrics;
+    private _skillWatcher;
+    private _toolWatcher;
+    private _config;
+    /**
+     * Direct access to the history manager
+     * @example
+     * ```typescript
+     * server.history.getHistory();
+     * server.history.clear();
+     * ```
+     */
+    readonly history: HistoryManager;
+    /**
+     * Direct access to the tool registry
+     * @example
+     * ```typescript
+     * server.tools.addTool(tool);
+     * server.tools.getTool('my-tool');
+     * ```
+     */
+    readonly tools: ToolRegistry;
+    /**
+     * Direct access to the skill registry
+     * @example
+     * ```typescript
+     * server.skills.addSkill(skill);
+     * server.skills.getSkill('my-skill');
+     * ```
+     */
+    readonly skills: SkillRegistry;
+    /**
+     * Server configuration
+     * @example
+     * ```typescript
+     * console.log(server.config.maxHistorySize);
+     * ```
+     */
+    readonly config: ServerConfig;
+    constructor(options?: ServerOptions);
+    /**
+     * Shared core logic for container creation.
+     * This method contains all common initialization logic between sync and async paths.
+     */
+    private static _createContainerCore;
+    /**
+     * Create and configure the DI container synchronously (without persistence)
+     * This is used for backward compatibility when createServer is not used.
+     */
+    private _createContainerSync;
+    /**
+     * Create and configure the DI container with async persistence initialization.
+     * This is used internally by the static create() factory.
+     */
+    private static _createContainerAsyncStatic;
+    /**
+     * Get the DI container used by this server
+     * Useful for testing and advanced customizations
+     */
+    getContainer(): Container;
+    /**
+     * Discover skills asynchronously without blocking server startup.
+     * This is the recommended method for skill discovery.
+     * @returns Promise<number> - The number of skills discovered
+     */
+    discoverSkillsAsync(): Promise<number>;
+    /**
+     * Get all branches from the history manager
+     * @returns Record<string, ThoughtData[]> - Map of branch IDs to thought arrays
+     */
+    getBranches(): Record<string, ThoughtData[]>;
+    processThought(input: v.InferInput<typeof SequentialThinkingSchema>): Promise<import("./core/ThoughtProcessor.js").CallToolResult>;
+    getMetricsSnapshot(): string;
+    /**
+     * Stop the server and clean up watchers.
+     * Closes persistence backend gracefully to ensure data is flushed.
+     */
+    stop(): Promise<void>;
+    /**
+     * Clear all server state (history, tools, skills)
+     * Useful for testing to reset state between tests
+     */
+    clear(): void;
+    /**
+     * Dispose of the server and all container services.
+     * Implements the IDisposable interface.
+     * Calls stop() for existing cleanup, then disposes the DI container.
+     */
+    dispose(): Promise<void>;
+}
+/**
+ * Factory function to create a new server instance with async initialization.
+ *
+ * This is the recommended way to create server instances, especially for testing,
+ * as it allows for proper async initialization, dependency injection, and persistence.
+ *
+ * @param options - Server configuration options
+ * @returns A Promise that resolves to a configured server instance
+ *
+ * @example
+ * ```typescript
+ * // Basic usage (with async discovery and persistence)
+ * const server = await createServer();
+ *
+ * // With custom options
+ * const server = await createServer({
+ *   autoDiscover: false,
+ *   lazyDiscovery: true,
+ *   maxHistorySize: 500,
+ *   loadFromPersistence: true
+ * });
+ *
+ * // With custom container for testing
+ * const mockContainer = new Container();
+ * mockContainer.registerInstance('Logger', mockLogger);
+ * const server = await createServer({ container: mockContainer });
+ * ```
+ */
+export declare function createServer(options?: ServerOptions): Promise<ToolAwareSequentialThinkingServer>;
+export declare function initializeServer(): Promise<ToolAwareSequentialThinkingServer>;
+export {};
+//# sourceMappingURL=lib.d.ts.map

package/dist/lib.d.ts.map

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

package/dist/lib.js

@@ -0,0 +1,219 @@
+import { EventEmitter } from "node:events";
+import { SEQUENTIAL_THINKING_TOOL } from "./schema.js";
+import { DiscoveryCache } from "./cache/DiscoveryCache.js";
+import { ConfigLoader } from "./config/ConfigLoader.js";
+import { HistoryManager } from "./core/HistoryManager.js";
+import { ThoughtEvaluator } from "./core/ThoughtEvaluator.js";
+import { ThoughtFormatter } from "./core/ThoughtFormatter.js";
+import { ThoughtProcessor } from "./core/ThoughtProcessor.js";
+import { Container } from "./di/Container.js";
+import { StructuredLogger } from "./logger/StructuredLogger.js";
+import { Metrics } from "./metrics/metrics.impl.js";
+import { createPersistenceBackend } from "./persistence/PersistenceFactory.js";
+import { SkillRegistry } from "./registry/SkillRegistry.js";
+import { ToolRegistry } from "./registry/ToolRegistry.js";
+import { ServerConfig } from "./ServerConfig.js";
+import { SkillWatcher } from "./watchers/SkillWatcher.js";
+import { ToolWatcher } from "./watchers/ToolWatcher.js";
+class ToolAwareSequentialThinkingServer extends EventEmitter {
+    static async create(options = {}) {
+        const container = await ToolAwareSequentialThinkingServer._createContainerAsyncStatic(options);
+        const server = new ToolAwareSequentialThinkingServer({
+            ...options,
+            container
+        });
+        if (false !== options.loadFromPersistence) await server.history.loadFromPersistence();
+        if (false !== options.autoDiscover) await server.discoverSkillsAsync();
+        return server;
+    }
+    emit(event, payload) {
+        return super.emit(event, payload);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    _container;
+    _logger;
+    _historyManager;
+    _thoughtProcessor;
+    _metrics;
+    _skillWatcher = null;
+    _toolWatcher = null;
+    _config;
+    history;
+    tools;
+    skills;
+    config;
+    constructor(options = {}){
+        super();
+        this._container = options.container ?? this._createContainerSync(options);
+        this._logger = this._container.resolve('Logger');
+        this._historyManager = this._container.resolve('HistoryManager');
+        this._thoughtProcessor = this._container.resolve('ThoughtProcessor');
+        this._metrics = this._container.resolve('Metrics');
+        this._config = this._container.resolve('Config');
+        this.history = this._historyManager;
+        this._historyManager.setEventEmitter(this);
+        this.tools = this._container.resolve('ToolRegistry');
+        this.skills = this._container.resolve('SkillRegistry');
+        this.config = this._config;
+        this.tools.addTool(SEQUENTIAL_THINKING_TOOL);
+        false !== options.autoDiscover && options.lazyDiscovery;
+        if (options.enableWatcher) {
+            this._skillWatcher = new SkillWatcher(this.skills);
+            this._toolWatcher = new ToolWatcher(this.tools);
+        }
+    }
+    static _createContainerCore(options, fileConfig, persistence) {
+        const container = new Container();
+        const metrics = new Metrics({
+            prefix: 'sequentialthinking'
+        });
+        const config = new ServerConfig({
+            maxHistorySize: options.maxHistorySize ?? fileConfig?.maxHistorySize,
+            maxBranches: options.maxBranches ?? fileConfig?.maxBranches,
+            maxBranchSize: options.maxBranchSize ?? fileConfig?.maxBranchSize,
+            skillDirs: fileConfig?.skillDirs,
+            discoveryCache: fileConfig?.discoveryCache,
+            persistence: fileConfig?.persistence
+        });
+        const logger = options.logger ?? new StructuredLogger({
+            level: fileConfig?.logLevel ?? 'info',
+            context: 'SequentialThinking',
+            pretty: fileConfig?.prettyLog ?? true
+        });
+        container.registerInstance('Logger', logger);
+        container.registerInstance('Config', config);
+        container.registerInstance('FileConfig', fileConfig || {});
+        container.registerInstance('Persistence', persistence);
+        container.registerInstance('Metrics', metrics);
+        container.register('ToolRegistry', ()=>new ToolRegistry({
+                logger,
+                cache: config.discoveryCache ? new DiscoveryCache({
+                    ...config.discoveryCache,
+                    metrics
+                }) : void 0
+            }));
+        container.register('SkillRegistry', ()=>new SkillRegistry({
+                logger,
+                cache: config.discoveryCache ? new DiscoveryCache({
+                    ...config.discoveryCache,
+                    metrics
+                }) : void 0,
+                skillDirs: config.skillDirs,
+                lazyDiscovery: options.lazyDiscovery
+            }));
+        container.register('HistoryManager', ()=>{
+            const cfg = container.resolve('Config');
+            const log = container.resolve('Logger');
+            const pers = container.resolve('Persistence');
+            const componentMetrics = container.resolve('Metrics');
+            return new HistoryManager({
+                maxHistorySize: cfg.maxHistorySize,
+                maxBranches: cfg.maxBranches,
+                maxBranchSize: cfg.maxBranchSize,
+                logger: log,
+                persistence: pers,
+                metrics: componentMetrics,
+                persistenceBufferSize: cfg.persistenceBufferSize,
+                persistenceFlushInterval: cfg.persistenceFlushInterval,
+                persistenceMaxRetries: cfg.persistenceMaxRetries
+            });
+        });
+        container.registerFactory('ThoughtFormatter', ()=>new ThoughtFormatter());
+        container.registerFactory('ThoughtEvaluator', ()=>new ThoughtEvaluator());
+        container.register('ThoughtProcessor', ()=>{
+            const history = container.resolve('HistoryManager');
+            const formatter = container.resolve('ThoughtFormatter');
+            const evaluator = container.resolve('ThoughtEvaluator');
+            const log = container.resolve('Logger');
+            return new ThoughtProcessor(history, formatter, evaluator, log);
+        });
+        return container;
+    }
+    _createContainerSync(options) {
+        const configLoader = new ConfigLoader();
+        const fileConfig = configLoader.load();
+        return ToolAwareSequentialThinkingServer._createContainerCore(options, fileConfig, null);
+    }
+    static async _createContainerAsyncStatic(options) {
+        const configLoader = new ConfigLoader();
+        const fileConfig = configLoader.load();
+        const persistence = await createPersistenceBackend(fileConfig?.persistence ?? {
+            enabled: false
+        });
+        return ToolAwareSequentialThinkingServer._createContainerCore(options, fileConfig, persistence);
+    }
+    getContainer() {
+        return this._container;
+    }
+    async discoverSkillsAsync() {
+        const discovered = await this.skills.discoverAsync();
+        return discovered;
+    }
+    getBranches() {
+        return this._historyManager.getBranches();
+    }
+    async processThought(input) {
+        const startTime = Date.now();
+        const thoughtInput = input;
+        const result = await this._thoughtProcessor.process(thoughtInput);
+        const durationSeconds = (Date.now() - startTime) / 1000;
+        this._metrics.histogram('thought_processing_duration_seconds', durationSeconds, {});
+        return result;
+    }
+    getMetricsSnapshot() {
+        return this._metrics.export();
+    }
+    async stop() {
+        this._skillWatcher?.stop();
+        this._toolWatcher?.stop();
+        try {
+            await this._historyManager.shutdown();
+        } catch (error) {
+            this._logger.error('Error flushing write buffer during shutdown', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        const persistence = this._container.resolve('Persistence');
+        if (persistence) try {
+            await persistence.close();
+            this._logger.info('Persistence backend closed');
+        } catch (error) {
+            this._logger.error('Error closing persistence backend', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+        this._logger.info('Server stopped, watchers cleaned up');
+    }
+    clear() {
+        this._historyManager.clear();
+        this._logger.info('Server state cleared');
+    }
+    async dispose() {
+        await this.stop();
+        await this._container.dispose();
+        this._logger.info('Server disposed, all resources released');
+    }
+}
+async function createServer(options = {}) {
+    return ToolAwareSequentialThinkingServer.create(options);
+}
+async function initializeServer() {
+    const configLoader = new ConfigLoader();
+    const fileConfig = configLoader.load();
+    const logger = new StructuredLogger({
+        level: fileConfig?.logLevel ?? 'info',
+        context: 'SequentialThinking',
+        pretty: fileConfig?.prettyLog ?? true
+    });
+    const thinkingServer = await createServer({
+        logger,
+        enableWatcher: true
+    });
+    logger.info('Server initialized successfully');
+    return thinkingServer;
+}
+export { ToolAwareSequentialThinkingServer, createServer, initializeServer };
+
+//# sourceMappingURL=lib.js.map

package/dist/lib.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.js","sources":["../src/lib.ts"],"sourcesContent":["// Library exports for tracelattice\n// This module contains all public API exports with NO CLI side effects.\n// For the CLI entry point, see cli.ts.\n\nimport { EventEmitter } from 'node:events';\nimport * as v from 'valibot';\nimport { ThoughtData } from './core/thought.js';\nimport { SEQUENTIAL_THINKING_TOOL, SequentialThinkingSchema } from './schema.js';\nimport { IDisposable } from './types/disposable.js';\n\n// New component imports\nimport { DiscoveryCache } from './cache/DiscoveryCache.js';\nimport type { ConfigFileOptions } from './config/ConfigLoader.js';\nimport { ConfigLoader } from './config/ConfigLoader.js';\nimport { HistoryManager } from './core/HistoryManager.js';\nimport { ThoughtEvaluator } from './core/ThoughtEvaluator.js';\nimport { ThoughtFormatter } from './core/ThoughtFormatter.js';\nimport { ThoughtProcessor } from './core/ThoughtProcessor.js';\nimport { Container } from './di/Container.js';\nimport { StructuredLogger } from './logger/StructuredLogger.js';\nimport { Metrics } from './metrics/metrics.impl.js';\nimport type { PersistenceBackend } from './persistence/PersistenceBackend.js';\nimport { createPersistenceBackend } from './persistence/PersistenceFactory.js';\nimport { SkillRegistry } from './registry/SkillRegistry.js';\nimport { ToolRegistry } from './registry/ToolRegistry.js';\nimport { ServerConfig } from './ServerConfig.js';\nimport type { SseTransportOptions } from './transport/SseTransport.js';\nimport { SkillWatcher } from './watchers/SkillWatcher.js';\nimport { ToolWatcher } from './watchers/ToolWatcher.js';\n\nexport interface ServerOptions {\n\tmaxHistorySize?: number;\n\tmaxBranches?: number;\n\tmaxBranchSize?: number;\n\tlogger?: StructuredLogger;\n\tenableWatcher?: boolean;\n\tconfig?: ServerConfig;\n\tfileConfig?: ConfigFileOptions;\n\tcontainer?: Container;\n\t/**\n\t * Enable automatic skill discovery on server startup\n\t * @default true\n\t */\n\tautoDiscover?: boolean;\n\t/**\n\t * Enable lazy discovery (discover on first access instead of startup)\n\t * @default false\n\t */\n\tlazyDiscovery?: boolean;\n\t/**\n\t * Load history from persistence on initialization\n\t * @default true\n\t */\n\tloadFromPersistence?: boolean;\n\t/**\n\t * Transport type to use\n\t * @default 'stdio'\n\t */\n\ttransport?: 'stdio' | 'sse';\n\t/**\n\t * SSE transport options (used when transport: 'sse')\n\t */\n\tsseTransportOptions?: SseTransportOptions;\n}\n\n/**\n * Server error events for event-driven error handling\n */\ninterface ServerEvents {\n\tpersistenceError: { operation: string; error: Error };\n\tdiscoveryError: { directory: string; error: Error };\n\ttransportError: { transport: string; error: Error };\n\tthoughtProcessed: { thoughtNumber: number; duration: number };\n}\n\nexport class ToolAwareSequentialThinkingServer extends EventEmitter implements IDisposable {\n\t/**\n\t * Factory method to create a new server instance with async initialization.\n\t * This is the recommended way to create server instances.\n\t *\n\t * @param options - Server configuration options\n\t * @returns A Promise that resolves to a configured server instance\n\t */\n\tstatic async create(options: ServerOptions = {}): Promise<ToolAwareSequentialThinkingServer> {\n\t\t// Create the async container first\n\t\tconst container = await ToolAwareSequentialThinkingServer._createContainerAsyncStatic(options);\n\n\t\t// Create a minimal server with the container\n\t\tconst server = new ToolAwareSequentialThinkingServer({\n\t\t\t...options,\n\t\t\tcontainer,\n\t\t});\n\n\t\t// Load from persistence if enabled (default: true)\n\t\tif (options.loadFromPersistence !== false) {\n\t\t\tawait server.history.loadFromPersistence();\n\t\t}\n\n\t\t// Perform async discovery if enabled (default: true)\n\t\tif (options.autoDiscover !== false) {\n\t\t\tawait server.discoverSkillsAsync();\n\t\t}\n\n\t\treturn server;\n\t}\n\n\t// Type-safe event emission\n\toverride emit<K extends keyof ServerEvents>(event: K, payload: ServerEvents[K]): boolean {\n\t\treturn super.emit(event, payload);\n\t}\n\n\toverride on<K extends keyof ServerEvents>(\n\t\tevent: K,\n\t\tlistener: (payload: ServerEvents[K]) => void\n\t): this {\n\t\treturn super.on(event, listener);\n\t}\n\n\t// DI Container for managing dependencies\n\tprivate _container: Container;\n\n\t// Component instances (private)\n\tprivate _logger: StructuredLogger;\n\tprivate _historyManager: HistoryManager;\n\tprivate _thoughtProcessor: ThoughtProcessor;\n\tprivate _metrics: Metrics;\n\tprivate _skillWatcher: SkillWatcher | null = null;\n\tprivate _toolWatcher: ToolWatcher | null = null;\n\tprivate _config: ServerConfig;\n\n\t// Public manager properties (recommended API)\n\t/**\n\t * Direct access to the history manager\n\t * @example\n\t * ```typescript\n\t * server.history.getHistory();\n\t * server.history.clear();\n\t * ```\n\t */\n\tpublic readonly history: HistoryManager;\n\n\t/**\n\t * Direct access to the tool registry\n\t * @example\n\t * ```typescript\n\t * server.tools.addTool(tool);\n\t * server.tools.getTool('my-tool');\n\t * ```\n\t */\n\tpublic readonly tools: ToolRegistry;\n\n\t/**\n\t * Direct access to the skill registry\n\t * @example\n\t * ```typescript\n\t * server.skills.addSkill(skill);\n\t * server.skills.getSkill('my-skill');\n\t * ```\n\t */\n\tpublic readonly skills: SkillRegistry;\n\n\t/**\n\t * Server configuration\n\t * @example\n\t * ```typescript\n\t * console.log(server.config.maxHistorySize);\n\t * ```\n\t */\n\tpublic readonly config: ServerConfig;\n\n\tconstructor(options: ServerOptions = {}) {\n\t\t// Use provided container or create a new one\n\t\tsuper();\n\t\tthis._container = options.container ?? this._createContainerSync(options);\n\n\t\t// Resolve dependencies from container\n\t\tthis._logger = this._container.resolve<StructuredLogger>('Logger');\n\t\tthis._historyManager = this._container.resolve<HistoryManager>('HistoryManager');\n\t\tthis._thoughtProcessor = this._container.resolve<ThoughtProcessor>('ThoughtProcessor');\n\t\tthis._metrics = this._container.resolve<Metrics>('Metrics');\n\t\tthis._config = this._container.resolve<ServerConfig>('Config');\n\n\t\t// Expose managers as public properties (recommended API)\n\t\tthis.history = this._historyManager;\n\n\t\t// Wire up persistence error event emitter\n\t\tthis._historyManager.setEventEmitter(this);\n\t\tthis.tools = this._container.resolve<ToolRegistry>('ToolRegistry');\n\t\tthis.skills = this._container.resolve<SkillRegistry>('SkillRegistry');\n\t\tthis.config = this._config;\n\n\t\t// Always include the sequential thinking tool\n\t\tthis.tools.addTool(SEQUENTIAL_THINKING_TOOL);\n\n\t\t// Note: For async discovery, users should call discoverSkillsAsync() after construction\n\t\tif (options.autoDiscover !== false && !options.lazyDiscovery) {\n\t\t\t// Synchronous discovery has been removed - use discoverSkillsAsync() instead\n\t\t\t// TODO: Update to use await this.skills.discoverAsync() instead\n\t\t\t// For now, comment out to prevent breaking\n\t\t\t// this.skills.discover();\n\t\t}\n\n\t\t// Initialize watchers if enabled\n\t\tif (options.enableWatcher) {\n\t\t\tthis._skillWatcher = new SkillWatcher(this.skills);\n\t\t\tthis._toolWatcher = new ToolWatcher(this.tools);\n\t\t}\n\t}\n\n\t/**\n\t * Shared core logic for container creation.\n\t * This method contains all common initialization logic between sync and async paths.\n\t */\n\tprivate static _createContainerCore(\n\t\toptions: ServerOptions,\n\t\tfileConfig: ConfigFileOptions | null,\n\t\tpersistence: PersistenceBackend | null\n\t): Container {\n\t\tconst container = new Container();\n\t\tconst metrics = new Metrics({\n\t\t\tprefix: 'sequentialthinking',\n\t\t});\n\n\t\t// Initialize config with file defaults overridden by constructor options\n\t\tconst config = new ServerConfig({\n\t\t\tmaxHistorySize: options.maxHistorySize ?? fileConfig?.maxHistorySize,\n\t\t\tmaxBranches: options.maxBranches ?? fileConfig?.maxBranches,\n\t\t\tmaxBranchSize: options.maxBranchSize ?? fileConfig?.maxBranchSize,\n\t\t\tskillDirs: fileConfig?.skillDirs,\n\t\t\tdiscoveryCache: fileConfig?.discoveryCache,\n\t\t\tpersistence: fileConfig?.persistence,\n\t\t});\n\n\t\t// Initialize logger\n\t\tconst logger =\n\t\t\toptions.logger ??\n\t\t\tnew StructuredLogger({\n\t\t\t\tlevel: fileConfig?.logLevel ?? 'info',\n\t\t\t\tcontext: 'SequentialThinking',\n\t\t\t\tpretty: fileConfig?.prettyLog ?? true,\n\t\t\t});\n\n\t\t// Register all services in the container\n\t\tcontainer.registerInstance('Logger', logger);\n\t\tcontainer.registerInstance('Config', config);\n\t\tcontainer.registerInstance('FileConfig', fileConfig || {});\n\t\tcontainer.registerInstance('Persistence', persistence);\n\t\tcontainer.registerInstance('Metrics', metrics);\n\t\tcontainer.register(\n\t\t\t'ToolRegistry',\n\t\t\t() =>\n\t\t\t\tnew ToolRegistry({\n\t\t\t\t\tlogger,\n\t\t\t\t\tcache: config.discoveryCache\n\t\t\t\t\t\t? new DiscoveryCache({ ...config.discoveryCache, metrics })\n\t\t\t\t\t\t: undefined,\n\t\t\t\t})\n\t\t);\n\t\tcontainer.register(\n\t\t\t'SkillRegistry',\n\t\t\t() =>\n\t\t\t\tnew SkillRegistry({\n\t\t\t\t\tlogger,\n\t\t\t\t\tcache: config.discoveryCache\n\t\t\t\t\t\t? new DiscoveryCache({ ...config.discoveryCache, metrics })\n\t\t\t\t\t\t: undefined,\n\t\t\t\t\tskillDirs: config.skillDirs,\n\t\t\t\t\tlazyDiscovery: options.lazyDiscovery,\n\t\t\t\t})\n\t\t);\n\n\t\t// Register HistoryManager with lazy initialization\n\t\tcontainer.register('HistoryManager', () => {\n\t\t\tconst cfg = container.resolve<ServerConfig>('Config');\n\t\t\tconst log = container.resolve<StructuredLogger>('Logger');\n\t\t\tconst pers = container.resolve('Persistence') as PersistenceBackend | null;\n\t\t\tconst componentMetrics = container.resolve<Metrics>('Metrics');\n\t\t\treturn new HistoryManager({\n\t\t\t\tmaxHistorySize: cfg.maxHistorySize,\n\t\t\t\tmaxBranches: cfg.maxBranches,\n\t\t\t\tmaxBranchSize: cfg.maxBranchSize,\n\t\t\t\tlogger: log,\n\t\t\t\tpersistence: pers,\n\t\t\t\tmetrics: componentMetrics,\n\t\t\t\tpersistenceBufferSize: cfg.persistenceBufferSize,\n\t\t\t\tpersistenceFlushInterval: cfg.persistenceFlushInterval,\n\t\t\t\tpersistenceMaxRetries: cfg.persistenceMaxRetries,\n\t\t\t});\n\t\t});\n\n\t\t// Register ThoughtFormatter (can be transient)\n\t\tcontainer.registerFactory('ThoughtFormatter', () => new ThoughtFormatter());\n\n\t\t// Register ThoughtEvaluator (stateless, transient)\n\t\tcontainer.registerFactory('ThoughtEvaluator', () => new ThoughtEvaluator());\n\n\t\t// Register ThoughtProcessor\n\t\tcontainer.register('ThoughtProcessor', () => {\n\t\t\tconst history = container.resolve<HistoryManager>('HistoryManager');\n\t\t\tconst formatter = container.resolve<ThoughtFormatter>('ThoughtFormatter');\n\t\t\tconst evaluator = container.resolve<ThoughtEvaluator>('ThoughtEvaluator');\n\t\t\tconst log = container.resolve<StructuredLogger>('Logger');\n\t\t\treturn new ThoughtProcessor(history, formatter, evaluator, log);\n\t\t});\n\n\t\treturn container;\n\t}\n\n\t/**\n\t * Create and configure the DI container synchronously (without persistence)\n\t * This is used for backward compatibility when createServer is not used.\n\t */\n\tprivate _createContainerSync(options: ServerOptions): Container {\n\t\tconst configLoader = new ConfigLoader();\n\t\tconst fileConfig = configLoader.load();\n\n\t\treturn ToolAwareSequentialThinkingServer._createContainerCore(options, fileConfig, null);\n\t}\n\n\t/**\n\t * Create and configure the DI container with async persistence initialization.\n\t * This is used internally by the static create() factory.\n\t */\n\tprivate static async _createContainerAsyncStatic(options: ServerOptions): Promise<Container> {\n\t\tconst configLoader = new ConfigLoader();\n\t\tconst fileConfig = configLoader.load();\n\n\t\t// Initialize persistence backend (async)\n\t\tconst persistence = await createPersistenceBackend(\n\t\t\tfileConfig?.persistence ?? { enabled: false }\n\t\t);\n\n\t\treturn ToolAwareSequentialThinkingServer._createContainerCore(options, fileConfig, persistence);\n\t}\n\n\t/**\n\t * Get the DI container used by this server\n\t * Useful for testing and advanced customizations\n\t */\n\tpublic getContainer(): Container {\n\t\treturn this._container;\n\t}\n\n\t/**\n\t * Discover skills asynchronously without blocking server startup.\n\t * This is the recommended method for skill discovery.\n\t * @returns Promise<number> - The number of skills discovered\n\t */\n\tpublic async discoverSkillsAsync(): Promise<number> {\n\t\tconst discovered = await this.skills.discoverAsync();\n\t\treturn discovered;\n\t}\n\n\t/**\n\t * Get all branches from the history manager\n\t * @returns Record<string, ThoughtData[]> - Map of branch IDs to thought arrays\n\t */\n\tpublic getBranches(): Record<string, ThoughtData[]> {\n\t\treturn this._historyManager.getBranches();\n\t}\n\n\t// Main processing method - delegate to ThoughtProcessor\n\tpublic async processThought(input: v.InferInput<typeof SequentialThinkingSchema>) {\n\t\tconst startTime = Date.now();\n\t\tconst thoughtInput = input as ThoughtData;\n\t\tconst result = await this._thoughtProcessor.process(thoughtInput);\n\t\tconst durationSeconds = (Date.now() - startTime) / 1000;\n\t\tthis._metrics.histogram('thought_processing_duration_seconds', durationSeconds, {});\n\t\treturn result;\n\t}\n\n\tpublic getMetricsSnapshot(): string {\n\t\treturn this._metrics.export();\n\t}\n\n\t/**\n\t * Stop the server and clean up watchers.\n\t * Closes persistence backend gracefully to ensure data is flushed.\n\t */\n\tpublic async stop(): Promise<void> {\n\t\tthis._skillWatcher?.stop();\n\t\tthis._toolWatcher?.stop();\n\n\t\t// Flush any buffered writes before closing persistence\n\t\ttry {\n\t\t\tawait this._historyManager.shutdown();\n\t\t} catch (error) {\n\t\t\tthis._logger.error('Error flushing write buffer during shutdown', {\n\t\t\t\terror: error instanceof Error ? error.message : String(error),\n\t\t\t});\n\t\t}\n\n\t\t// Close persistence backend if available\n\t\tconst persistence = this._container.resolve<PersistenceBackend | null>('Persistence');\n\t\tif (persistence) {\n\t\t\ttry {\n\t\t\t\tawait persistence.close();\n\t\t\t\tthis._logger.info('Persistence backend closed');\n\t\t\t} catch (error) {\n\t\t\t\tthis._logger.error('Error closing persistence backend', {\n\t\t\t\t\terror: error instanceof Error ? error.message : String(error),\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\tthis._logger.info('Server stopped, watchers cleaned up');\n\t}\n\n\t/**\n\t * Clear all server state (history, tools, skills)\n\t * Useful for testing to reset state between tests\n\t */\n\tpublic clear(): void {\n\t\tthis._historyManager.clear();\n\t\tthis._logger.info('Server state cleared');\n\t}\n\n\t/**\n\t * Dispose of the server and all container services.\n\t * Implements the IDisposable interface.\n\t * Calls stop() for existing cleanup, then disposes the DI container.\n\t */\n\tpublic async dispose(): Promise<void> {\n\t\tawait this.stop();\n\t\tawait this._container.dispose();\n\t\tthis._logger.info('Server disposed, all resources released');\n\t}\n}\n\n/**\n * Factory function to create a new server instance with async initialization.\n *\n * This is the recommended way to create server instances, especially for testing,\n * as it allows for proper async initialization, dependency injection, and persistence.\n *\n * @param options - Server configuration options\n * @returns A Promise that resolves to a configured server instance\n *\n * @example\n * ```typescript\n * // Basic usage (with async discovery and persistence)\n * const server = await createServer();\n *\n * // With custom options\n * const server = await createServer({\n *   autoDiscover: false,\n *   lazyDiscovery: true,\n *   maxHistorySize: 500,\n *   loadFromPersistence: true\n * });\n *\n * // With custom container for testing\n * const mockContainer = new Container();\n * mockContainer.registerInstance('Logger', mockLogger);\n * const server = await createServer({ container: mockContainer });\n * ```\n */\nexport async function createServer(\n\toptions: ServerOptions = {}\n): Promise<ToolAwareSequentialThinkingServer> {\n\treturn ToolAwareSequentialThinkingServer.create(options);\n}\n\n// Initialize server\nexport async function initializeServer(): Promise<ToolAwareSequentialThinkingServer> {\n\t// Create logger for initialization\n\tconst configLoader = new ConfigLoader();\n\tconst fileConfig = configLoader.load();\n\n\tconst logger = new StructuredLogger({\n\t\tlevel: fileConfig?.logLevel ?? 'info',\n\t\tcontext: 'SequentialThinking',\n\t\tpretty: fileConfig?.prettyLog ?? true,\n\t});\n\n\t// Create server instance\n\tconst thinkingServer = await createServer({\n\t\tlogger,\n\t\tenableWatcher: true,\n\t});\n\n\tlogger.info('Server initialized successfully');\n\treturn thinkingServer;\n}\n"],"names":["ToolAwareSequentialThinkingServer","EventEmitter","options","container","server","event","payload","listener","SEQUENTIAL_THINKING_TOOL","SkillWatcher","ToolWatcher","fileConfig","persistence","Container","metrics","Metrics","config","ServerConfig","logger","StructuredLogger","ToolRegistry","DiscoveryCache","undefined","SkillRegistry","cfg","log","pers","componentMetrics","HistoryManager","ThoughtFormatter","ThoughtEvaluator","history","formatter","evaluator","ThoughtProcessor","configLoader","ConfigLoader","createPersistenceBackend","discovered","input","startTime","Date","thoughtInput","result","durationSeconds","error","Error","String","createServer","initializeServer","thinkingServer"],"mappings":"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"}