@codebolt/agent 1.0.0

package/dist/systemprompt.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+declare class SystemPrompt {
+    private filepath;
+    private key;
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath?: string, key?: string);
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText(): string;
+}
+export { SystemPrompt };

package/dist/systemprompt.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemPrompt = void 0;
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * SystemPrompt class for loading and managing system prompts from YAML files
+ */
+class SystemPrompt {
+    /**
+     * Creates a SystemPrompt instance
+     * @param {string} filepath - Path to the YAML file containing prompts
+     * @param {string} key - Key identifier for the specific prompt
+     */
+    constructor(filepath = "", key = "") {
+        this.filepath = filepath;
+        this.key = key;
+    }
+    /**
+     * Loads and returns the prompt text
+     * @returns {string} The prompt text
+     * @throws {Error} If file cannot be read or parsed
+     */
+    toPromptText() {
+        try {
+            const absolutePath = path_1.default.resolve(this.filepath);
+            const fileContents = fs_1.default.readFileSync(absolutePath, 'utf8');
+            const data = js_yaml_1.default.load(fileContents);
+            if (!data || typeof data !== 'object') {
+                throw new Error('Invalid YAML structure');
+            }
+            if (!data[this.key]) {
+                throw new Error(`Prompt not found for key: ${this.key}`);
+            }
+            const promptData = data[this.key];
+            return typeof promptData === 'string' ? promptData : promptData.prompt;
+        }
+        catch (error) {
+            console.error(`SystemPrompt Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw error; // Re-throw to allow caller handling
+        }
+    }
+}
+exports.SystemPrompt = SystemPrompt;

package/dist/taskInstruction.d.ts

@@ -0,0 +1,37 @@
+import { UserMessage } from "./usermessage";
+import type { UserMessageContent } from "./types/libFunctionTypes";
+import type { Tools, UserMessages } from "./types/InternalTypes";
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
+declare class TaskInstruction {
+    /** Available tools for the task */
+    tools: Tools;
+    /** Messages from the user for this task */
+    userMessages: UserMessageContent[];
+    /** The user message object containing input */
+    userMessage: UserMessage;
+    /** Path to the YAML file with task instructions */
+    filepath: string;
+    /** The section reference within the YAML file */
+    refsection: string;
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
+    constructor(tools: Tools | undefined, userMessage: UserMessage, filepath?: string, refsection?: string);
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
+    toPrompt(): Promise<UserMessages[]>;
+}
+export { TaskInstruction };

package/dist/taskInstruction.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskInstruction = void 0;
+/**
+ * Encapsulates task instructions and their related metadata.
+ * Handles loading and processing of task instructions from YAML files.
+ */
+const yaml = require('js-yaml');
+const fs = require('fs');
+const path = require('path');
+/**
+ * Class representing a task instruction.
+ * Handles loading task data and converting it to prompts.
+ */
+class TaskInstruction {
+    /**
+     * Creates a new TaskInstruction instance.
+     *
+     * @param tools - Tools available for this task
+     * @param userMessage - User message containing task instructions
+     * @param filepath - Path to the YAML file with task data
+     * @param refsection - Section name within the YAML file
+     */
+    constructor(tools = {}, userMessage, filepath = "", refsection = "") {
+        /** Messages from the user for this task */
+        this.userMessages = [];
+        this.tools = tools;
+        this.userMessage = userMessage;
+        this.filepath = filepath;
+        this.refsection = refsection;
+    }
+    /**
+     * Converts the task instruction to a prompt format.
+     * Loads data from YAML file and combines with user message.
+     *
+     * @returns Promise with an array of user message content blocks
+     * @throws Error if there's an issue processing the task instruction
+     */
+    async toPrompt() {
+        try {
+            this.userMessages = await this.userMessage.toPrompt();
+            const fileContents = fs.readFileSync(path.resolve(this.filepath), 'utf8');
+            const data = yaml.load(fileContents);
+            const task = data[this.refsection];
+            this.userMessages.push({
+                type: "text",
+                text: `Task Description: ${task.description}\nExpected Output: ${task.expected_output}`
+            });
+            return this.userMessages;
+        }
+        catch (error) {
+            console.error(`Error processing task instruction: ${error}`);
+            throw error;
+        }
+    }
+}
+exports.TaskInstruction = TaskInstruction;

package/dist/types/InternalTypes.d.ts

@@ -0,0 +1,499 @@
+/**
+ * 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
+ */
+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[];
+    remixPrompt?: string;
+}
+/**
+ * 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