@iworkforces/tracelattice 2.0.3

package/dist/errors.d.ts

@@ -0,0 +1,663 @@
+/**
+ * Custom error types for the TraceLattice server.
+ *
+ * This module defines a hierarchy of error classes for handling various
+ * error conditions that can occur in the sequential thinking server.
+ * All errors extend the base `SequentialThinkingError` class with
+ * specific error codes for programmatic handling.
+ *
+ * @example
+ * ```typescript
+ * import { ToolNotFoundError, SkillDiscoveryError } from './errors.js';
+ *
+ * // Throw a tool not found error
+ * throw new ToolNotFoundError('my-tool');
+ *
+ * // Catch and handle specific errors
+ * try {
+ *   await discoverSkills(dir);
+ * } catch (error) {
+ *   if (error instanceof SkillDiscoveryError) {
+ *     console.error(`Failed to discover skills: ${error.message}`);
+ *     console.error(`Error code: ${error.code}`);
+ *   }
+ * }
+ * ```
+ * @module errors
+ */
+/**
+ * All known error codes as a const object for exhaustive switching.
+ */
+export declare const ERROR_CODES: {
+    readonly CONFIGURATION_ERROR: "CONFIGURATION_ERROR";
+    readonly TOOL_NOT_FOUND: "TOOL_NOT_FOUND";
+    readonly SKILL_NOT_FOUND: "SKILL_NOT_FOUND";
+    readonly INVALID_THOUGHT: "INVALID_THOUGHT";
+    readonly SKILL_DISCOVERY_FAILED: "SKILL_DISCOVERY_FAILED";
+    readonly HISTORY_LIMIT_EXCEEDED: "HISTORY_LIMIT_EXCEEDED";
+    readonly DUPLICATE_SKILL: "DUPLICATE_SKILL";
+    readonly INVALID_SKILL: "INVALID_SKILL";
+    readonly DUPLICATE_TOOL: "DUPLICATE_TOOL";
+    readonly INVALID_TOOL: "INVALID_TOOL";
+    readonly SESSION_NOT_ACTIVE: "SESSION_NOT_ACTIVE";
+    readonly SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
+    readonly MAX_SESSIONS_REACHED: "MAX_SESSIONS_REACHED";
+    readonly POOL_TERMINATED: "POOL_TERMINATED";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+    readonly INVALID_EDGE: "INVALID_EDGE";
+    readonly CYCLE_DETECTED: "CYCLE_DETECTED";
+    readonly SUSPENSION_NOT_FOUND: "SUSPENSION_NOT_FOUND";
+    readonly SUSPENSION_EXPIRED: "SUSPENSION_EXPIRED";
+    readonly INVALID_TOOL_CALL: "INVALID_TOOL_CALL";
+    readonly INVALID_BACKTRACK: "INVALID_BACKTRACK";
+    readonly DUPLICATE_SUMMARY: "DUPLICATE_SUMMARY";
+    readonly UNKNOWN_TOOL: "UNKNOWN_TOOL";
+    readonly LOCK_TIMEOUT: "LOCK_TIMEOUT";
+    readonly CLI_SHUTDOWN_TIMEOUT: "CLI_SHUTDOWN_TIMEOUT";
+    readonly SESSION_ACCESS_DENIED: "SESSION_ACCESS_DENIED";
+    readonly SESSION_LIFECYCLE_CLOSED: "SESSION_LIFECYCLE_CLOSED";
+    readonly PERSISTENCE_OWNERSHIP: "PERSISTENCE_OWNERSHIP";
+    readonly PERSISTENCE_CORRUPTION: "PERSISTENCE_CORRUPTION";
+    readonly PERSISTENCE_PUBLICATION: "PERSISTENCE_PUBLICATION";
+    readonly PERSISTENCE_CLOSED: "PERSISTENCE_CLOSED";
+    readonly PERSISTENCE_DRAIN: "PERSISTENCE_DRAIN";
+    readonly PERSISTENCE_SESSION_ADMISSION_CLOSED: "PERSISTENCE_SESSION_ADMISSION_CLOSED";
+    readonly PERSISTENCE_SESSION_BARRIER_REENTRANCY: "PERSISTENCE_SESSION_BARRIER_REENTRANCY";
+    readonly ASYNC_RESET_REQUIRED: "ASYNC_RESET_REQUIRED";
+    readonly PERSISTENCE_CAPABILITY_UNSUPPORTED: "PERSISTENCE_CAPABILITY_UNSUPPORTED";
+    readonly PERSISTENCE_SCOPE_MISMATCH: "PERSISTENCE_SCOPE_MISMATCH";
+    readonly PERSISTENCE_UNAVAILABLE: "PERSISTENCE_UNAVAILABLE";
+    readonly PERSISTENCE_COMPATIBILITY: "PERSISTENCE_COMPATIBILITY";
+    readonly PERSISTENCE_IMPORT_REQUIRED: "PERSISTENCE_IMPORT_REQUIRED";
+    readonly PERSISTENCE_LEGACY_AMBIGUITY: "PERSISTENCE_LEGACY_AMBIGUITY";
+};
+export type ErrorCode = (typeof ERROR_CODES)[keyof typeof ERROR_CODES];
+/**
+ * All known warning codes as a const object.
+ * Warnings are non-fatal advisory signals returned alongside successful results.
+ */
+export declare const WARNING_CODES: {
+    readonly TOTAL_THOUGHTS_ADJUSTED: "TOTAL_THOUGHTS_ADJUSTED";
+};
+export type WarningCode = (typeof WARNING_CODES)[keyof typeof WARNING_CODES];
+/**
+ * Base error class for all Sequential Thinking server errors.
+ *
+ * This error extends the native `Error` class and adds a `code` property
+ * for programmatic error identification and handling. All specific error
+ * types in the system extend this base class.
+ *
+ * @remarks
+ * **Error Codes:**
+ * - `TOOL_NOT_FOUND` - A requested tool was not found
+ * - `SKILL_NOT_FOUND` - A requested skill was not found
+ * - `INVALID_THOUGHT` - Thought validation failed
+ * - `SKILL_DISCOVERY_FAILED` - Skill discovery operation failed
+ * - `HISTORY_LIMIT_EXCEEDED` - History size limit was exceeded
+ * - `INVALID_EDGE` - An invalid edge operation was attempted
+ *
+ * @example
+ * ```typescript
+ * // Throw a custom sequential thinking error
+ * throw new SequentialThinkingError('Custom error message', 'CUSTOM_CODE');
+ *
+ * // Check if an error is a SequentialThinkingError
+ * if (error instanceof SequentialThinkingError) {
+ *   console.error(`Error [${error.code}]: ${error.message}`);
+ * }
+ * ```
+ */
+export declare class SequentialThinkingError extends Error {
+    /** The error code for programmatic identification. */
+    readonly code: ErrorCode;
+    /**
+     * Creates a new SequentialThinkingError.
+     *
+     * @param message - Human-readable error message
+     * @param code - Error code for programmatic handling
+     *
+     * @example
+     * ```typescript
+     * const error = new SequentialThinkingError(
+     *   'Something went wrong',
+     *   'CUSTOM_ERROR'
+     * );
+     * console.log(error.code); // 'CUSTOM_ERROR'
+     * ```
+     */
+    constructor(message: string, code: ErrorCode);
+}
+export declare class ConfigurationError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a requested tool is not found in the registry.
+ *
+ * This error is thrown when attempting to retrieve, update, or delete
+ * a tool that doesn't exist in the tool registry.
+ *
+ * @example
+ * ```typescript
+ * const tool = registry.getTool('non-existent-tool');
+ * if (!tool) {
+ *   throw new ToolNotFoundError('non-existent-tool');
+ * }
+ * ```
+ */
+export declare class ToolNotFoundError extends SequentialThinkingError {
+    /**
+     * Creates a new ToolNotFoundError.
+     *
+     * @param toolName - The name of the tool that was not found
+     * @param action - Optional action being performed (e.g., 'remove', 'update')
+     *
+     * @example
+     * ```typescript
+     * throw new ToolNotFoundError('my-custom-tool');
+     * // Error: tool 'my-custom-tool' not found
+     *
+     * throw new ToolNotFoundError('my-custom-tool', 'remove');
+     * // Error: tool 'my-custom-tool' not found, cannot remove
+     * // Code: TOOL_NOT_FOUND
+     * ```
+     */
+    constructor(toolName: string, action?: string);
+}
+/**
+ * Error thrown when a requested skill is not found in the registry.
+ *
+ * This error is thrown when attempting to retrieve, update, or delete
+ * a skill that doesn't exist in the skill registry.
+ *
+ * @example
+ * ```typescript
+ * const skill = registry.getSkill('non-existent-skill');
+ * if (!skill) {
+ *   throw new SkillNotFoundError('non-existent-skill');
+ * }
+ * ```
+ */
+export declare class SkillNotFoundError extends SequentialThinkingError {
+    /**
+     * Creates a new SkillNotFoundError.
+     *
+     * @param skillName - The name of the skill that was not found
+     * @param action - Optional action being performed (e.g., 'remove', 'update')
+     *
+     * @example
+     * ```typescript
+     * throw new SkillNotFoundError('my-custom-skill');
+     * // Error: skill 'my-custom-skill' not found
+     *
+     * throw new SkillNotFoundError('my-custom-skill', 'remove');
+     * // Error: skill 'my-custom-skill' not found, cannot remove
+     * // Code: SKILL_NOT_FOUND
+     * ```
+     */
+    constructor(skillName: string, action?: string);
+}
+/**
+ * Error thrown when thought validation fails.
+ *
+ * This error is thrown when a thought fails validation, typically due to
+ * invalid values, missing required fields, or constraint violations.
+ *
+ * @example
+ * ```typescript
+ * // Validate thought number
+ * if (thought.thought_number < 1) {
+ *   throw new InvalidThoughtError(thought.thought_number, 'thought_number must be >= 1');
+ * }
+ * ```
+ */
+export declare class InvalidThoughtError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidThoughtError.
+     *
+     * @param thoughtNumber - The thought number that failed validation
+     * @param reason - Human-readable explanation of why validation failed
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidThoughtError(5, 'thought_number exceeds total_thoughts');
+     * // Error: Invalid thought 5: thought_number exceeds total_thoughts
+     * // Code: INVALID_THOUGHT
+     * ```
+     */
+    constructor(thoughtNumber: number, reason: string);
+}
+/**
+ * Error thrown when skill discovery fails.
+ *
+ * This error is thrown when the skill discovery process encounters an issue,
+ * such as filesystem errors, invalid skill files, or parsing failures.
+ *
+ * @remarks
+ * The original error that caused the discovery failure is preserved in the
+ * `cause` property for debugging purposes.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await discoverSkills('./skills');
+ * } catch (error) {
+ *   throw new SkillDiscoveryError('./skills', error as Error);
+ * }
+ * ```
+ */
+export declare class SkillDiscoveryError extends SequentialThinkingError {
+    /** The underlying error that caused the discovery failure. */
+    readonly cause: Error;
+    /**
+     * Creates a new SkillDiscoveryError.
+     *
+     * @param directory - The directory where discovery failed
+     * @param cause - The underlying error that caused the failure
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const skills = await loadSkills('./invalid-directory');
+     * } catch (error) {
+     *   throw new SkillDiscoveryError('./invalid-directory', error as Error);
+     * }
+     * ```
+     */
+    constructor(directory: string, cause: Error);
+}
+/**
+ * Error thrown when history size exceeds the configured limit.
+ *
+ * This error is thrown when an operation would cause the history size
+ * to exceed the maximum configured size limit.
+ *
+ * @example
+ * ```typescript
+ * if (history.length >= maxSize) {
+ *   throw new HistoryLimitExceededError(history.length, maxSize);
+ * }
+ * ```
+ */
+export declare class HistoryLimitExceededError extends SequentialThinkingError {
+    /**
+     * Creates a new HistoryLimitExceededError.
+     *
+     * @param currentSize - The current history size
+     * @param maxSize - The maximum allowed size
+     *
+     * @example
+     * ```typescript
+     * throw new HistoryLimitExceededError(1500, 1000);
+     * // Error: History size 1500 exceeds limit 1000
+     * // Code: HISTORY_LIMIT_EXCEEDED
+     * ```
+     */
+    constructor(currentSize: number, maxSize: number);
+}
+/**
+ * Error thrown when attempting to add a skill that already exists.
+ *
+ * This error is thrown when trying to register a skill with a name that
+ * is already present in the skill registry.
+ *
+ * @example
+ * ```typescript
+ * if (registry.hasSkill(skill.name)) {
+ *   throw new DuplicateSkillError(skill.name);
+ * }
+ * ```
+ */
+export declare class DuplicateSkillError extends SequentialThinkingError {
+    /**
+     * Creates a new DuplicateSkillError.
+     *
+     * @param skillName - The name of the duplicate skill
+     *
+     * @example
+     * ```typescript
+     * throw new DuplicateSkillError('my-skill');
+     * // Error: skill 'my-skill' already exists
+     * // Code: DUPLICATE_SKILL
+     * ```
+     */
+    constructor(skillName: string);
+}
+/**
+ * Error thrown when a skill has invalid data.
+ *
+ * This error is thrown when a skill fails validation, typically due to
+ * missing required fields or invalid values.
+ *
+ * @example
+ * ```typescript
+ * if (!skill.name) {
+ *   throw new InvalidSkillError('Skill must have a valid name');
+ * }
+ * ```
+ */
+export declare class InvalidSkillError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidSkillError.
+     *
+     * @param reason - The reason for the validation failure
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidSkillError('Skill must have a valid name');
+     * // Error: Invalid skill: Skill must have a valid name
+     * // Code: INVALID_SKILL
+     * ```
+     */
+    constructor(reason: string);
+}
+/**
+ * Error thrown when attempting to add a tool that already exists.
+ *
+ * This error is thrown when trying to register a tool with a name that
+ * is already present in the tool registry.
+ *
+ * @example
+ * ```typescript
+ * if (registry.hasTool(tool.name)) {
+ *   throw new DuplicateToolError(tool.name);
+ * }
+ * ```
+ */
+export declare class DuplicateToolError extends SequentialThinkingError {
+    /**
+     * Creates a new DuplicateToolError.
+     *
+     * @param toolName - The name of the duplicate tool
+     *
+     * @example
+     * ```typescript
+     * throw new DuplicateToolError('my-tool');
+     * // Error: tool 'my-tool' already exists
+     * // Code: DUPLICATE_TOOL
+     * ```
+     */
+    constructor(toolName: string);
+}
+/**
+ * Error thrown when a tool has invalid data.
+ *
+ * This error is thrown when a tool fails validation, typically due to
+ * missing required fields or invalid values.
+ *
+ * @example
+ * ```typescript
+ * if (!tool.name) {
+ *   throw new InvalidToolError('Tool must have a valid name');
+ * }
+ * ```
+ */
+export declare class InvalidToolError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidToolError.
+     *
+     * @param reason - The reason for the validation failure
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidToolError('Tool must have a valid name');
+     * // Error: Invalid tool: Tool must have a valid name
+     * // Code: INVALID_TOOL
+     * ```
+     */
+    constructor(reason: string);
+}
+/**
+ * Error thrown when the maximum number of sessions has been reached.
+ *
+ * This error is thrown when trying to create a new session when the
+ * pool has reached its configured maximum session limit.
+ *
+ * @example
+ * ```typescript
+ * if (pool.sessionCount >= pool.maxSessions) {
+ *   throw new MaxSessionsReachedError(pool.maxSessions);
+ * }
+ * ```
+ */
+export declare class MaxSessionsReachedError extends SequentialThinkingError {
+    /**
+     * Creates a new MaxSessionsReachedError.
+     *
+     * @param maxSessions - The maximum number of sessions allowed
+     *
+     * @example
+     * ```typescript
+     * throw new MaxSessionsReachedError(100);
+     * // Error: Max sessions (100) reached. Wait for a session to close or increase maxSessions.
+     * // Code: MAX_SESSIONS_REACHED
+     * ```
+     */
+    constructor(maxSessions: number);
+}
+/**
+ * Error thrown when attempting to use a terminated connection pool.
+ *
+ * This error is thrown when trying to create sessions or process requests
+ * after the connection pool has been terminated.
+ *
+ * @example
+ * ```typescript
+ * if (pool.isTerminated) {
+ *   throw new PoolTerminatedError();
+ * }
+ * ```
+ */
+export declare class PoolTerminatedError extends SequentialThinkingError {
+    /**
+     * Creates a new PoolTerminatedError.
+     *
+     * @example
+     * ```typescript
+     * throw new PoolTerminatedError();
+     * // Error: ConnectionPool has been terminated
+     * // Code: POOL_TERMINATED
+     * ```
+     */
+    constructor();
+}
+/**
+ * Error thrown when input validation fails due to invalid or malicious data.
+ *
+ * This error is thrown when user input fails security or format validation,
+ * such as path traversal attempts or invalid identifier formats.
+ *
+ * @example
+ * ```typescript
+ * if (!BRANCH_ID_PATTERN.test(branchId)) {
+ *   throw new ValidationError('branchId', 'Invalid format');
+ * }
+ * ```
+ */
+export declare class ValidationError extends SequentialThinkingError {
+    /** The field that failed validation. */
+    readonly field: string;
+    constructor(field: string, reason: string);
+}
+/**
+ * Error thrown when an invalid edge operation is attempted.
+ *
+ * This error is thrown when attempting to add an edge that violates
+ * structural invariants of the thought DAG, such as a self-edge
+ * (where `from` and `to` reference the same thought).
+ *
+ * @example
+ * ```typescript
+ * if (edge.from === edge.to) {
+ *   throw new InvalidEdgeError(
+ *     `Self-edge not allowed: from and to are the same (${edge.from})`
+ *   );
+ * }
+ * ```
+ */
+export declare class InvalidEdgeError extends SequentialThinkingError {
+    /**
+     * Creates a new InvalidEdgeError.
+     *
+     * @param message - Human-readable explanation of the invalid edge
+     *
+     * @example
+     * ```typescript
+     * throw new InvalidEdgeError('Self-edge not allowed: from and to are the same (t1)');
+     * // Code: INVALID_EDGE
+     * ```
+     */
+    constructor(message: string);
+}
+/**
+ * Error thrown when a cycle is detected during graph traversal.
+ *
+ * This error is thrown by graph algorithms (such as topological sort)
+ * when the thought DAG contains a cycle, violating the acyclic invariant.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const order = graphView.topological(sessionId);
+ * } catch (error) {
+ *   if (error instanceof CycleDetectedError) {
+ *     console.error('Cycle in thought graph:', error.message);
+ *   }
+ * }
+ * ```
+ */
+export declare class CycleDetectedError extends SequentialThinkingError {
+    /**
+     * Creates a new CycleDetectedError.
+     *
+     * @param message - Human-readable explanation of the cycle
+     *
+     * @example
+     * ```typescript
+     * throw new CycleDetectedError('Cycle detected in session s1');
+     * // Code: CYCLE_DETECTED
+     * ```
+     */
+    constructor(message: string);
+}
+/**
+ * Error thrown when a suspension record is not found.
+ *
+ * This error is thrown when attempting to resume a tool interleave
+ * suspension that does not exist in the suspension store.
+ */
+export declare class SuspensionNotFoundError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a suspension record has expired.
+ *
+ * This error is thrown when attempting to resume a tool interleave
+ * suspension whose TTL has elapsed.
+ */
+export declare class SuspensionExpiredError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a tool call payload is invalid.
+ *
+ * This error is thrown when a tool interleave invocation has malformed
+ * arguments, missing identifiers, or otherwise fails validation.
+ */
+export declare class InvalidToolCallError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a backtrack operation is invalid.
+ *
+ * This error is thrown when an attempt to backtrack the reasoning
+ * chain references an unreachable thought or violates DAG invariants.
+ */
+export declare class InvalidBacktrackError extends SequentialThinkingError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a tool_call references a tool not registered with the server.
+ *
+ * Acts as an allowlist gate: only tools registered in the ToolRegistry may be
+ * invoked through tool interleave. Prevents arbitrary tool name injection.
+ */
+export declare class UnknownToolError extends SequentialThinkingError {
+    readonly toolName: string;
+    constructor(toolName: string, message?: string);
+}
+/** Error thrown when the CLI's complete shutdown exceeds its outer deadline. */
+export declare class CliShutdownTimeoutError extends SequentialThinkingError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number);
+}
+export declare class PersistenceOwnershipError extends SequentialThinkingError {
+    readonly canonicalDataDir: string;
+    readonly lockPath: string;
+    readonly cause: unknown;
+    constructor(canonicalDataDir: string, lockPath: string, cause: unknown);
+}
+export declare class PersistenceCorruptionError extends SequentialThinkingError {
+    readonly path: string;
+    readonly cause: unknown;
+    constructor(path: string, cause: unknown);
+}
+/** Error raised when startup cannot read from an unhealthy persistence backend. */
+export declare class PersistenceUnavailableError extends SequentialThinkingError {
+    constructor();
+}
+export type PersistencePublicationStage = 'temporary-write' | 'atomic-replacement' | 'cleanup';
+export declare class PersistencePublicationError extends SequentialThinkingError {
+    readonly path: string;
+    readonly stage: PersistencePublicationStage;
+    readonly cause: unknown;
+    constructor(path: string, stage: PersistencePublicationStage, cause: unknown);
+}
+export declare class PersistenceClosedError extends SequentialThinkingError {
+    readonly dataDir: string;
+    constructor(dataDir: string);
+}
+/** Error raised for well-formed but unsupported or drifted persisted data. */
+export declare class PersistenceCompatibilityError extends SequentialThinkingError {
+    readonly sourcePath: string;
+    readonly detail: string;
+    readonly cause: unknown;
+    constructor(sourcePath: string, detail: string, cause?: unknown);
+}
+/** Error raised when legacy files require an explicit one-way import. */
+export declare class PersistenceImportRequiredError extends SequentialThinkingError {
+    readonly sourcePath: string;
+    readonly legacyArtifacts: readonly string[];
+    constructor(sourcePath: string, legacyArtifacts: readonly string[]);
+}
+/** Error raised when legacy bytes do not identify one durable namespace. */
+export declare class PersistenceLegacyAmbiguityError extends SequentialThinkingError {
+    readonly sourcePath: string;
+    readonly detail: string;
+    constructor(sourcePath: string, detail: string);
+}
+/**
+ * Type guard to check if an error has a specific error code.
+ */
+export declare function isErrorCode<C extends ErrorCode>(err: unknown, code: C): err is SequentialThinkingError & {
+    readonly code: C;
+};
+/**
+ * Extract a human-readable message from an unknown error value.
+ *
+ * Standardizes the common `error instanceof Error ? error.message : String(error)`
+ * pattern used in catch blocks across the codebase.
+ *
+ * @param error - The unknown error value to extract a message from
+ * @returns The error message string
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await doSomething();
+ * } catch (error) {
+ *   logger.error('Failed', { error: getErrorMessage(error) });
+ * }
+ * ```
+ */
+export declare function getErrorMessage(error: unknown): string;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

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