@codebolt/codeboltjs 2.0.12 → 2.0.15

package/dist/notificationfunctions/search.js

@@ -0,0 +1,146 @@
+"use strict";
+/**
+ * Search Notification Functions
+ *
+ * This module provides functions for sending search-related notifications,
+ * including search initialization and query operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchNotifications = exports.GetFirstLinkResultNotify = exports.GetFirstLinkRequestNotify = exports.SearchResultNotify = exports.SearchRequestNotify = exports.SearchInitResultNotify = exports.SearchInitRequestNotify = void 0;
+const utils_1 = require("./utils");
+// ===== SEARCH INIT FUNCTIONS =====
+/**
+ * Sends a search init request notification
+ * @param engine - Optional search engine to initialize
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function SearchInitRequestNotify(engine, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "searchnotify",
+        action: "searchInitRequest",
+        data: {
+            engine: engine
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'search-init');
+}
+exports.SearchInitRequestNotify = SearchInitRequestNotify;
+/**
+ * Sends a search init result notification
+ * @param content - The result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function SearchInitResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[SearchNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "searchnotify",
+        action: "searchInitResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'search-init-result');
+}
+exports.SearchInitResultNotify = SearchInitResultNotify;
+// ===== SEARCH REQUEST FUNCTIONS =====
+/**
+ * Sends a search request notification
+ * @param query - The search query string
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function SearchRequestNotify(query, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ query }, ['query'], 'search-request')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "searchnotify",
+        action: "searchRequest",
+        data: {
+            query: query
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'search-request');
+}
+exports.SearchRequestNotify = SearchRequestNotify;
+/**
+ * Sends a search result notification
+ * @param content - The search result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function SearchResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[SearchNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "searchnotify",
+        action: "searchResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'search-result');
+}
+exports.SearchResultNotify = SearchResultNotify;
+// ===== GET FIRST LINK FUNCTIONS =====
+/**
+ * Sends a get first link request notification
+ * @param query - The search query to get the first link for
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function GetFirstLinkRequestNotify(query, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ query }, ['query'], 'get-first-link')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "searchnotify",
+        action: "getFirstLinkRequest",
+        data: {
+            query: query
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'search-get-first-link');
+}
+exports.GetFirstLinkRequestNotify = GetFirstLinkRequestNotify;
+/**
+ * Sends a get first link result notification
+ * @param content - The first link result content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function GetFirstLinkResultNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[SearchNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "searchnotify",
+        action: "getFirstLinkResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'search-get-first-link-result');
+}
+exports.GetFirstLinkResultNotify = GetFirstLinkResultNotify;
+/**
+ * Search notification functions object
+ */
+exports.searchNotifications = {
+    SearchInitRequestNotify,
+    SearchInitResultNotify,
+    SearchRequestNotify,
+    SearchResultNotify,
+    GetFirstLinkRequestNotify,
+    GetFirstLinkResultNotify
+};

package/dist/notificationfunctions/system.d.ts

@@ -0,0 +1,25 @@
+/**
+ * System Notification Functions
+ *
+ * This module provides functions for sending system-related notifications,
+ * including agent initialization and completion states.
+ */
+import { SystemNotifications } from '../types/notificationFunctions/system';
+/**
+ * Sends an agent init notification
+ * @param onStopClicked - Optional flag indicating if stop was clicked
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function AgentInitNotify(onStopClicked?: boolean, toolUseId?: string): void;
+/**
+ * Sends an agent completion notification
+ * @param resultString - The result string from the agent
+ * @param sessionId - Optional session ID
+ * @param duration - Optional duration string
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function AgentCompletionNotify(resultString: string, sessionId?: string, duration?: string, toolUseId?: string): void;
+/**
+ * System notification functions object
+ */
+export declare const systemNotifications: SystemNotifications;

package/dist/notificationfunctions/system.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * System Notification Functions
+ *
+ * This module provides functions for sending system-related notifications,
+ * including agent initialization and completion states.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemNotifications = exports.AgentCompletionNotify = exports.AgentInitNotify = void 0;
+const utils_1 = require("./utils");
+// ===== AGENT INIT FUNCTIONS =====
+/**
+ * Sends an agent init notification
+ * @param onStopClicked - Optional flag indicating if stop was clicked
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function AgentInitNotify(onStopClicked, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "processStartedRequest",
+        data: {
+            onStopClicked: onStopClicked
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'agent-init');
+}
+exports.AgentInitNotify = AgentInitNotify;
+// ===== AGENT COMPLETION FUNCTIONS =====
+/**
+ * Sends an agent completion notification
+ * @param resultString - The result string from the agent
+ * @param sessionId - Optional session ID
+ * @param duration - Optional duration string
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function AgentCompletionNotify(resultString, sessionId, duration, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "chatnotify",
+        action: "processStoppedRequest",
+        data: {
+            sessionId: sessionId,
+            duration: duration || "0ms",
+            result: {
+                resultString: resultString
+            }
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'agent-completion');
+}
+exports.AgentCompletionNotify = AgentCompletionNotify;
+/**
+ * System notification functions object
+ */
+exports.systemNotifications = {
+    AgentInitNotify,
+    AgentCompletionNotify
+};

package/dist/notificationfunctions/terminal.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Terminal Notification Functions
+ *
+ * This module provides functions for sending terminal-related notifications,
+ * including command execution operations.
+ */
+import { TerminalNotifications } from '../types/notificationFunctions/terminal';
+/**
+ * Sends a command execution request notification
+ * @param command - The command to execute
+ * @param returnEmptyStringOnSuccess - Optional flag to return empty string on success
+ * @param executeInMain - Optional flag to execute in main terminal
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function CommandExecutionRequestNotify(command: string, returnEmptyStringOnSuccess?: boolean, executeInMain?: boolean, toolUseId?: string): void;
+/**
+ * Sends a command execution response notification
+ * @param content - The command execution result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function CommandExecutionResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Terminal notification functions object
+ */
+export declare const terminalNotifications: TerminalNotifications;

package/dist/notificationfunctions/terminal.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Terminal Notification Functions
+ *
+ * This module provides functions for sending terminal-related notifications,
+ * including command execution operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.terminalNotifications = exports.CommandExecutionResponseNotify = exports.CommandExecutionRequestNotify = void 0;
+const utils_1 = require("./utils");
+// ===== COMMAND EXECUTION FUNCTIONS =====
+/**
+ * Sends a command execution request notification
+ * @param command - The command to execute
+ * @param returnEmptyStringOnSuccess - Optional flag to return empty string on success
+ * @param executeInMain - Optional flag to execute in main terminal
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function CommandExecutionRequestNotify(command, returnEmptyStringOnSuccess, executeInMain, toolUseId) {
+    // Validate required fields
+    if (!(0, utils_1.validateRequiredFields)({ command }, ['command'], 'terminal-command-execution')) {
+        return;
+    }
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "terminalnotify",
+        action: "executeCommandRequest",
+        data: {
+            command: command,
+            returnEmptyStringOnSuccess: returnEmptyStringOnSuccess,
+            executeInMain: executeInMain
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'terminal-command-execution');
+}
+exports.CommandExecutionRequestNotify = CommandExecutionRequestNotify;
+/**
+ * Sends a command execution response notification
+ * @param content - The command execution result or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function CommandExecutionResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[TerminalNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "terminalnotify",
+        action: "executeCommandResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'terminal-command-execution-response');
+}
+exports.CommandExecutionResponseNotify = CommandExecutionResponseNotify;
+/**
+ * Terminal notification functions object
+ */
+exports.terminalNotifications = {
+    CommandExecutionRequestNotify,
+    CommandExecutionResponseNotify
+};

package/dist/notificationfunctions/todo.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Todo Notification Functions
+ *
+ * This module provides functions for sending todo/task-related notifications,
+ * including task operations and lifecycle management.
+ */
+import { TodoNotifications } from '../types/notificationFunctions/todo';
+/**
+ * Sends an add todo request notification
+ * @param title - Optional task title
+ * @param agentId - Optional agent ID
+ * @param description - Optional task description
+ * @param phase - Optional task phase
+ * @param category - Optional task category
+ * @param priority - Optional task priority
+ * @param tags - Optional array of tags
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function AddTodoRequestNotify(title?: string, agentId?: string, description?: string, phase?: string, category?: string, priority?: string, tags?: string[], toolUseId?: string): void;
+/**
+ * Sends an add todo response notification
+ * @param content - The response content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function AddTodoResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends a get todo request notification
+ * @param filters - Optional filters for the todo request
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function GetTodoRequestNotify(filters?: any, toolUseId?: string): void;
+/**
+ * Sends a get todo response notification
+ * @param content - The response content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function GetTodoResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Sends an edit todo task request notification
+ * @param taskId - Optional task ID to edit
+ * @param title - Optional new task title
+ * @param description - Optional new task description
+ * @param phase - Optional new task phase
+ * @param category - Optional new task category
+ * @param priority - Optional new task priority
+ * @param tags - Optional new array of tags
+ * @param status - Optional new task status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+export declare function EditTodoTaskRequestNotify(taskId?: string, title?: string, description?: string, phase?: string, category?: string, priority?: string, tags?: string[], status?: string, toolUseId?: string): void;
+/**
+ * Sends an edit todo task response notification
+ * @param content - The response content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+export declare function EditTodoTaskResponseNotify(content: string | any, isError?: boolean, toolUseId?: string): void;
+/**
+ * Todo notification functions object
+ */
+export declare const todoNotifications: TodoNotifications;

package/dist/notificationfunctions/todo.js

@@ -0,0 +1,164 @@
+"use strict";
+/**
+ * Todo Notification Functions
+ *
+ * This module provides functions for sending todo/task-related notifications,
+ * including task operations and lifecycle management.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.todoNotifications = exports.EditTodoTaskResponseNotify = exports.EditTodoTaskRequestNotify = exports.GetTodoResponseNotify = exports.GetTodoRequestNotify = exports.AddTodoResponseNotify = exports.AddTodoRequestNotify = void 0;
+const utils_1 = require("./utils");
+// ===== ADD TODO FUNCTIONS =====
+/**
+ * Sends an add todo request notification
+ * @param title - Optional task title
+ * @param agentId - Optional agent ID
+ * @param description - Optional task description
+ * @param phase - Optional task phase
+ * @param category - Optional task category
+ * @param priority - Optional task priority
+ * @param tags - Optional array of tags
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function AddTodoRequestNotify(title, agentId, description, phase, category, priority, tags, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "tasknotify",
+        action: "addTaskRequest",
+        data: {
+            title: title,
+            agentId: agentId,
+            description: description,
+            phase: phase,
+            category: category,
+            priority: priority,
+            tags: tags
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'todo-add-task');
+}
+exports.AddTodoRequestNotify = AddTodoRequestNotify;
+/**
+ * Sends an add todo response notification
+ * @param content - The response content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function AddTodoResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[TodoNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "tasknotify",
+        action: "addTaskResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'todo-add-task-response');
+}
+exports.AddTodoResponseNotify = AddTodoResponseNotify;
+// ===== GET TODO FUNCTIONS =====
+/**
+ * Sends a get todo request notification
+ * @param filters - Optional filters for the todo request
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function GetTodoRequestNotify(filters, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "tasknotify",
+        action: "getTasksRequest",
+        data: {
+            filters: filters
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'todo-get-tasks');
+}
+exports.GetTodoRequestNotify = GetTodoRequestNotify;
+/**
+ * Sends a get todo response notification
+ * @param content - The response content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function GetTodoResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[TodoNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "tasknotify",
+        action: "getTasksResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'todo-get-tasks-response');
+}
+exports.GetTodoResponseNotify = GetTodoResponseNotify;
+// ===== EDIT TODO TASK FUNCTIONS =====
+/**
+ * Sends an edit todo task request notification
+ * @param taskId - Optional task ID to edit
+ * @param title - Optional new task title
+ * @param description - Optional new task description
+ * @param phase - Optional new task phase
+ * @param category - Optional new task category
+ * @param priority - Optional new task priority
+ * @param tags - Optional new array of tags
+ * @param status - Optional new task status
+ * @param toolUseId - Optional custom toolUseId, will be generated if not provided
+ */
+function EditTodoTaskRequestNotify(taskId, title, description, phase, category, priority, tags, status, toolUseId) {
+    const notification = {
+        toolUseId: toolUseId || (0, utils_1.generateToolUseId)(),
+        type: "tasknotify",
+        action: "updateTaskRequest",
+        data: {
+            taskId: taskId,
+            title: title,
+            description: description,
+            phase: phase,
+            category: category,
+            priority: priority,
+            tags: tags,
+            status: status
+        }
+    };
+    (0, utils_1.sendNotification)(notification, 'todo-edit-task');
+}
+exports.EditTodoTaskRequestNotify = EditTodoTaskRequestNotify;
+/**
+ * Sends an edit todo task response notification
+ * @param content - The response content or error details
+ * @param isError - Whether this is an error response
+ * @param toolUseId - The toolUseId from the original request
+ */
+function EditTodoTaskResponseNotify(content, isError = false, toolUseId) {
+    if (!toolUseId) {
+        console.error('[TodoNotifications] toolUseId is required for response notifications');
+        return;
+    }
+    const notification = {
+        toolUseId,
+        type: "tasknotify",
+        action: "updateTaskResult",
+        content,
+        isError
+    };
+    (0, utils_1.sendNotification)(notification, 'todo-edit-task-response');
+}
+exports.EditTodoTaskResponseNotify = EditTodoTaskResponseNotify;
+/**
+ * Todo notification functions object
+ */
+exports.todoNotifications = {
+    AddTodoRequestNotify,
+    AddTodoResponseNotify,
+    GetTodoRequestNotify,
+    GetTodoResponseNotify,
+    EditTodoTaskRequestNotify,
+    EditTodoTaskResponseNotify
+};

package/dist/notificationfunctions/utils.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Error class for notification-related errors
+ */
+export declare class NotificationError extends Error {
+    code: string;
+    category: string;
+    originalError?: Error | undefined;
+    constructor(message: string, code: string, category: string, originalError?: Error | undefined);
+}
+/**
+ * Error codes for notification operations
+ */
+export declare enum NotificationErrorCodes {
+    CONNECTION_NOT_READY = "CONNECTION_NOT_READY",
+    INVALID_DATA = "INVALID_DATA",
+    TIMEOUT = "TIMEOUT",
+    WEBSOCKET_ERROR = "WEBSOCKET_ERROR",
+    VALIDATION_FAILED = "VALIDATION_FAILED"
+}
+/**
+ * Base interface for all notifications
+ */
+export interface BaseNotification {
+    toolUseId: string;
+    type: string;
+    action: string;
+    data?: any;
+    content?: string | any;
+    isError?: boolean;
+}
+/**
+ * Generates a unique toolUseId for notifications
+ * @returns {string} A unique identifier in the format 'tool_timestamp_randomstring'
+ */
+export declare function generateToolUseId(): string;
+/**
+ * Validates the basic structure of a notification
+ * @param notification The notification to validate
+ * @returns {boolean} True if the notification has required fields
+ */
+export declare function validateNotificationStructure<T extends BaseNotification>(notification: T): boolean;
+/**
+ * Sends a notification through the WebSocket connection
+ * This is a fire-and-forget operation that handles errors gracefully
+ * @param notification The notification to send
+ * @param category The category of notification for error reporting
+ */
+export declare function sendNotification<T extends BaseNotification>(notification: T, category?: string): void;
+/**
+ * Validates that required data fields are present and not empty
+ * @param data The data object to validate
+ * @param requiredFields Array of field names that must be present
+ * @param category The category for error reporting
+ * @returns {boolean} True if all required fields are present
+ */
+export declare function validateRequiredFields(data: any, requiredFields: string[], category?: string): boolean;
+/**
+ * Creates a standardized error response notification
+ * @param toolUseId The toolUseId to use for the response
+ * @param type The notification type
+ * @param action The response action
+ * @param error The error that occurred
+ * @returns A standardized error response notification
+ */
+export declare function createErrorResponse(toolUseId: string, type: string, action: string, error: Error | string): BaseNotification;
+/**
+ * Creates a standardized success response notification
+ * @param toolUseId The toolUseId to use for the response
+ * @param type The notification type
+ * @param action The response action
+ * @param content The success content
+ * @returns A standardized success response notification
+ */
+export declare function createSuccessResponse(toolUseId: string, type: string, action: string, content: string | any): BaseNotification;
+/**
+ * Utility function to safely stringify objects for logging
+ * @param obj The object to stringify
+ * @param maxLength Maximum length of the resulting string
+ * @returns A safe string representation
+ */
+export declare function safeStringify(obj: any, maxLength?: number): string;