@codebolt/codeboltjs 2.0.7 → 2.0.12

package/dist/types/InternalTypes.d.ts

@@ -0,0 +1,501 @@
+/**
+ * Internal TypeScript types for the codeboltjs library implementation
+ *
+ * This file contains types that are used internally by the library:
+ * - Internal class structures
+ * - Implementation-specific interfaces
+ * - Private API types
+ * - Module-specific types
+ * - WebSocket management types
+ */
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+import type { PendingRequest } from './commonTypes';
+export interface WebSocketManager {
+    websocket: WebSocket | null;
+    isConnected: boolean;
+    reconnectAttempts: number;
+    maxReconnectAttempts: number;
+    reconnectInterval: number;
+    messageQueue: any[];
+    pendingRequests: Map<string, PendingRequest>;
+}
+export interface WebSocketConfig {
+    url: string;
+    timeout: number;
+    reconnectInterval: number;
+    maxReconnectAttempts: number;
+    autoReconnect: boolean;
+}
+export interface MessageManagerConfig {
+    timeout: number;
+    retryAttempts: number;
+    retryDelay: number;
+}
+export interface MessageQueueItem {
+    message: any;
+    timestamp: number;
+    priority: number;
+    retryCount: number;
+    maxRetries: number;
+}
+export interface ModuleManager {
+    fs: any;
+    git: any;
+    llm: any;
+    browser: any;
+    chat: any;
+    terminal: any;
+    codeutils: any;
+    crawler: any;
+    search: any;
+    knowledge: any;
+    rag: any;
+    codeparsers: any;
+    outputparsers: any;
+    project: any;
+    dbmemory: any;
+    cbstate: any;
+    taskplaner: any;
+    vectordb: any;
+    debug: any;
+    tokenizer: any;
+    chatSummary: any;
+    mcp: any;
+    agent: any;
+    utils: any;
+}
+export interface ASTNode {
+    /** Type of the AST node */
+    type: string;
+    /** Start position in the source code */
+    start?: number;
+    /** End position in the source code */
+    end?: number;
+    /** Line number where the node starts */
+    line?: number;
+    /** Column number where the node starts */
+    column?: number;
+    /** Child nodes */
+    children?: ASTNode[];
+    /** Node value/content */
+    value?: any;
+    /** Additional node properties */
+    [key: string]: any;
+}
+export interface ParserConfig {
+    language: string;
+    options: {
+        includeComments?: boolean;
+        includeLocations?: boolean;
+        tolerant?: boolean;
+    };
+}
+export interface JSTreeStructureItem {
+    /** Type of the item (function, class, variable, etc.) */
+    type: string;
+    /** Name of the code structure item */
+    name: string;
+    /** Start line number */
+    startLine: number;
+    /** End line number */
+    endLine: number;
+    /** Start column number */
+    startColumn: number;
+    /** End column number */
+    endColumn: number;
+    /** Node type from the AST */
+    nodeType: string;
+}
+export interface JSTreeResponse {
+    /** Event type */
+    event: string;
+    /** Response payload */
+    payload?: {
+        /** File path that was parsed */
+        filePath: string;
+        /** Parsed structure items */
+        structure: JSTreeStructureItem[];
+    };
+    /** Error message if parsing failed */
+    error?: string;
+}
+export interface LanguageParser {
+    [key: string]: {
+        parser: any;
+        query: any;
+    };
+}
+export interface CacheManager {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T, ttl?: number): void;
+    delete(key: string): boolean;
+    clear(): void;
+    size(): number;
+}
+export interface CacheEntry<T = any> {
+    value: T;
+    timestamp: number;
+    ttl: number;
+    accessCount: number;
+    lastAccessed: number;
+}
+export interface InternalState {
+    isInitialized: boolean;
+    isConnected: boolean;
+    lastHeartbeat: number;
+    sessionId: string;
+    userId?: string;
+    activeRequests: Set<string>;
+    moduleStates: Map<string, any>;
+    errorCount: number;
+    lastError?: Error;
+}
+export interface StateChangeEvent {
+    type: 'state_change';
+    property: keyof InternalState;
+    oldValue: any;
+    newValue: any;
+    timestamp: number;
+}
+export interface InternalError extends Error {
+    code: string;
+    module: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    context?: Record<string, any>;
+    timestamp: number;
+    stackTrace?: string;
+}
+export declare class InternalError extends Error {
+    code: string;
+    module: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    context?: Record<string, any> | undefined;
+    constructor(message: string, code: string, module: string, severity?: 'low' | 'medium' | 'high' | 'critical', context?: Record<string, any> | undefined);
+}
+export interface InternalEventMap {
+    'websocket:connected': () => void;
+    'websocket:disconnected': () => void;
+    'websocket:error': (error: Error) => void;
+    'websocket:message': (message: any) => void;
+    'websocket:reconnecting': (attempt: number) => void;
+    'module:loaded': (moduleName: string) => void;
+    'module:error': (moduleName: string, error: Error) => void;
+    'cache:hit': (key: string) => void;
+    'cache:miss': (key: string) => void;
+    'cache:evicted': (key: string) => void;
+    'state:changed': (event: StateChangeEvent) => void;
+    'request:started': (requestId: string) => void;
+    'request:completed': (requestId: string, duration: number) => void;
+    'request:failed': (requestId: string, error: Error) => void;
+}
+export interface InternalEventEmitter extends EventEmitter {
+    on<K extends keyof InternalEventMap>(event: K, listener: InternalEventMap[K]): this;
+    off<K extends keyof InternalEventMap>(event: K, listener: InternalEventMap[K]): this;
+    emit<K extends keyof InternalEventMap>(event: K, ...args: Parameters<InternalEventMap[K]>): boolean;
+}
+export interface RequestTracker {
+    id: string;
+    type: string;
+    module: string;
+    startTime: number;
+    endTime?: number;
+    status: 'pending' | 'success' | 'error' | 'timeout';
+    error?: Error;
+    metadata?: Record<string, any>;
+}
+export interface RequestMetrics {
+    totalRequests: number;
+    successfulRequests: number;
+    failedRequests: number;
+    averageResponseTime: number;
+    requestsByModule: Map<string, number>;
+    errorsByType: Map<string, number>;
+}
+export interface PerformanceMetrics {
+    memoryUsage: {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+    };
+    cpuUsage: {
+        user: number;
+        system: number;
+    };
+    eventLoopLag: number;
+    gcStats?: {
+        totalHeapSize: number;
+        totalHeapSizeExecutable: number;
+        totalPhysicalSize: number;
+        totalAvailableSize: number;
+        usedHeapSize: number;
+        heapSizeLimit: number;
+    };
+}
+export interface PerformanceMonitor {
+    start(): void;
+    stop(): void;
+    getMetrics(): PerformanceMetrics;
+    reset(): void;
+    isRunning(): boolean;
+}
+export interface InternalLogger {
+    debug(message: string, meta?: Record<string, any>): void;
+    info(message: string, meta?: Record<string, any>): void;
+    warn(message: string, meta?: Record<string, any>): void;
+    error(message: string, error?: Error, meta?: Record<string, any>): void;
+    setLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
+    getLevel(): string;
+}
+export interface LogEntry {
+    level: 'debug' | 'info' | 'warn' | 'error';
+    message: string;
+    timestamp: number;
+    module?: string;
+    requestId?: string;
+    meta?: Record<string, any>;
+    error?: {
+        name: string;
+        message: string;
+        stack?: string;
+    };
+}
+export interface ModuleDefinition {
+    name: string;
+    path: string;
+    dependencies: string[];
+    version: string;
+    exports: string[];
+    config?: Record<string, any>;
+}
+export interface ModuleLoader {
+    load(name: string): Promise<any>;
+    unload(name: string): Promise<void>;
+    reload(name: string): Promise<any>;
+    isLoaded(name: string): boolean;
+    getLoadedModules(): string[];
+}
+export interface ConfigurationManager {
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T): void;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+    getAll(): Record<string, any>;
+    merge(config: Record<string, any>): void;
+    validate(schema: any): boolean;
+}
+export interface ConfigurationSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        required?: boolean;
+        default?: any;
+        description?: string;
+    }>;
+    required?: string[];
+}
+export interface QueueManager<T = any> {
+    enqueue(item: T, priority?: number): void;
+    dequeue(): T | undefined;
+    peek(): T | undefined;
+    size(): number;
+    isEmpty(): boolean;
+    clear(): void;
+}
+export interface PriorityQueue<T = any> extends QueueManager<T> {
+    enqueuePriority(item: T, priority: number): void;
+    dequeuePriority(): T | undefined;
+}
+export interface ConnectionPool {
+    acquire(): Promise<WebSocket>;
+    release(connection: WebSocket): void;
+    destroy(connection: WebSocket): void;
+    size(): number;
+    available(): number;
+    pending(): number;
+    close(): Promise<void>;
+}
+export interface PoolConfiguration {
+    min: number;
+    max: number;
+    acquireTimeoutMillis: number;
+    idleTimeoutMillis: number;
+    createTimeoutMillis: number;
+    destroyTimeoutMillis: number;
+    reapIntervalMillis: number;
+}
+export interface SecurityContext {
+    userId?: string;
+    sessionId: string;
+    permissions: string[];
+    roles: string[];
+    isAuthenticated: boolean;
+    expiresAt?: number;
+}
+export interface SecurityManager {
+    authenticate(credentials: any): Promise<SecurityContext>;
+    authorize(action: string, resource?: string): boolean;
+    validateSession(sessionId: string): boolean;
+    revokeSession(sessionId: string): void;
+    hasPermission(permission: string): boolean;
+}
+export interface ValidationRule {
+    field: string;
+    type: 'required' | 'string' | 'number' | 'boolean' | 'array' | 'object' | 'custom';
+    message?: string;
+    validator?: (value: any) => boolean;
+    options?: Record<string, any>;
+}
+export interface ValidationResult {
+    isValid: boolean;
+    errors: Array<{
+        field: string;
+        message: string;
+        value?: any;
+    }>;
+}
+export interface Validator {
+    validate(data: any, rules: ValidationRule[]): ValidationResult;
+    addRule(rule: ValidationRule): void;
+    removeRule(field: string): void;
+    hasRule(field: string): boolean;
+}
+export interface Serializer<T = any> {
+    serialize(data: T): string | Buffer;
+    deserialize(data: string | Buffer): T;
+    getContentType(): string;
+}
+export interface SerializationManager {
+    register(name: string, serializer: Serializer): void;
+    unregister(name: string): void;
+    get(name: string): Serializer | undefined;
+    serialize(data: any, format?: string): string | Buffer;
+    deserialize(data: string | Buffer, format?: string): any;
+}
+export interface Plugin {
+    name: string;
+    version: string;
+    initialize(context: PluginContext): Promise<void>;
+    destroy(): Promise<void>;
+    dependencies?: string[];
+    config?: Record<string, any>;
+}
+export interface PluginContext {
+    logger: InternalLogger;
+    config: ConfigurationManager;
+    events: InternalEventEmitter;
+    state: InternalState;
+    registerHandler(type: string, handler: Function): void;
+    unregisterHandler(type: string, handler: Function): void;
+}
+export interface PluginManager {
+    load(plugin: Plugin): Promise<void>;
+    unload(name: string): Promise<void>;
+    isLoaded(name: string): boolean;
+    getLoaded(): Plugin[];
+    enable(name: string): void;
+    disable(name: string): void;
+}
+export interface HealthCheck {
+    name: string;
+    check(): Promise<HealthStatus>;
+    timeout?: number;
+    interval?: number;
+}
+export interface HealthStatus {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    message?: string;
+    timestamp: number;
+    metadata?: Record<string, any>;
+}
+export interface HealthMonitor {
+    register(check: HealthCheck): void;
+    unregister(name: string): void;
+    checkAll(): Promise<Map<string, HealthStatus>>;
+    getStatus(name: string): HealthStatus | undefined;
+    isHealthy(): boolean;
+}
+export interface CircuitBreakerConfig {
+    failureThreshold: number;
+    resetTimeout: number;
+    monitoringPeriod: number;
+    expectedErrorCodes?: string[];
+}
+export interface CircuitBreaker {
+    execute<T>(operation: () => Promise<T>): Promise<T>;
+    getState(): 'closed' | 'open' | 'half-open';
+    getFailureRate(): number;
+    reset(): void;
+    forceOpen(): void;
+    forceClose(): void;
+}
+/**
+ * Interface for tools that can be used within tasks.
+ */
+export interface Tools {
+    [key: string]: {
+        /** Description of what the tool does */
+        description: string;
+        /** How to use the tool correctly */
+        usage: string;
+        /** Optional example demonstrating tool usage */
+        example?: string;
+    };
+}
+/**
+ * Interface for task data structure as loaded from YAML.
+ */
+export interface TaskData {
+    [key: string]: {
+        /** Description of what the task should accomplish */
+        description: string;
+        /** Expected output format or content */
+        expected_output: string;
+    };
+}
+/**
+ * Interface for user message structure in tasks.
+ */
+export interface UserMessages {
+    /** The type of user message */
+    type: string;
+    /** The text content of the message */
+    text: string;
+}
+/**
+ * Interface for system prompt data loaded from YAML.
+ */
+export interface PromptData {
+    [key: string]: {
+        prompt: string;
+    };
+}
+/**
+ * Interface for user message structure in agent lib.
+ */
+export interface Message {
+    /** The actual text content of the user message */
+    userMessage: string;
+    /** Optional list of files mentioned in the message */
+    mentionedFiles?: string[];
+    /** List of MCP (Model Context Protocol) tools mentioned */
+    mentionedMCPs: {
+        toolbox: string;
+        toolName: string;
+    }[];
+    /** List of agents mentioned in the message */
+    mentionedAgents: any[];
+}
+/**
+ * Interface for file listing result.
+ */
+export interface FileListResult {
+    /** Whether the listing operation was successful */
+    success: boolean;
+    /** The result of the listing operation as a string */
+    result: string;
+}

package/dist/types/InternalTypes.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Internal TypeScript types for the codeboltjs library implementation
+ *
+ * This file contains types that are used internally by the library:
+ * - Internal class structures
+ * - Implementation-specific interfaces
+ * - Private API types
+ * - Module-specific types
+ * - WebSocket management types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternalError = void 0;
+class InternalError extends Error {
+    constructor(message, code, module, severity = 'medium', context) {
+        super(message);
+        this.code = code;
+        this.module = module;
+        this.severity = severity;
+        this.context = context;
+        this.name = 'InternalError';
+        this.timestamp = Date.now();
+        this.stackTrace = this.stack;
+    }
+}
+exports.InternalError = InternalError;
+// ================================
+// Parser Internal Types
+// ================================
+// LanguageParser interface already defined above at line 154