@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/eventLog/eventlog-update-instance.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventLogUpdateInstanceTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const eventLog_1 = __importDefault(require("../../modules/eventLog"));
+class EventLogUpdateInstanceInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const { instanceId, ...updates } = this.params;
+            const response = await eventLog_1.default.updateInstance(instanceId, updates);
+            if (!response.success || !response.data) {
+                return {
+                    llmContent: `Error: ${response.error || response.message || 'Failed to update event log instance'}`,
+                    returnDisplay: `Error: ${response.error || response.message || 'Failed to update event log instance'}`,
+                    error: { message: response.error || response.message || 'Failed to update event log instance', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const instance = response.data.instance;
+            return {
+                llmContent: `Event log instance "${instance.name}" updated successfully`,
+                returnDisplay: `Updated event log instance: ${instance.name} (ID: ${instance.id})`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class EventLogUpdateInstanceTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('eventlog_update_instance', 'Update Event Log Instance', 'Update an event log instance', types_1.Kind.Other, {
+            type: 'object',
+            properties: {
+                instanceId: { type: 'string', description: 'ID of the event log instance' },
+                name: { type: 'string', description: 'New name for the instance' },
+                description: { type: 'string', description: 'New description for the instance' },
+            },
+            required: ['instanceId'],
+        });
+    }
+    createInvocation(params) {
+        return new EventLogUpdateInstanceInvocation(params);
+    }
+}
+exports.EventLogUpdateInstanceTool = EventLogUpdateInstanceTool;

package/dist/tools/eventLog/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Event Log Tools
+ *
+ * Tools for managing event log instances and events.
+ */
+export { EventLogCreateInstanceTool } from './eventlog-create-instance';
+export { EventLogGetInstanceTool } from './eventlog-get-instance';
+export { EventLogListInstancesTool } from './eventlog-list-instances';
+export { EventLogUpdateInstanceTool } from './eventlog-update-instance';
+export { EventLogDeleteInstanceTool } from './eventlog-delete-instance';
+export { EventLogAppendEventTool } from './eventlog-append-event';
+export { EventLogAppendEventsTool } from './eventlog-append-events';
+export { EventLogQueryEventsTool } from './eventlog-query-events';
+export { EventLogGetInstanceStatsTool } from './eventlog-get-instance-stats';
+import { EventLogCreateInstanceTool } from './eventlog-create-instance';
+import { EventLogGetInstanceTool } from './eventlog-get-instance';
+import { EventLogListInstancesTool } from './eventlog-list-instances';
+import { EventLogUpdateInstanceTool } from './eventlog-update-instance';
+import { EventLogDeleteInstanceTool } from './eventlog-delete-instance';
+import { EventLogAppendEventTool } from './eventlog-append-event';
+import { EventLogAppendEventsTool } from './eventlog-append-events';
+import { EventLogQueryEventsTool } from './eventlog-query-events';
+import { EventLogGetInstanceStatsTool } from './eventlog-get-instance-stats';
+/**
+ * Array of all event log tools
+ */
+export declare const eventLogTools: (EventLogCreateInstanceTool | EventLogGetInstanceTool | EventLogListInstancesTool | EventLogUpdateInstanceTool | EventLogDeleteInstanceTool | EventLogAppendEventTool | EventLogAppendEventsTool | EventLogQueryEventsTool | EventLogGetInstanceStatsTool)[];

package/dist/tools/eventLog/index.js

@@ -0,0 +1,49 @@
+"use strict";
+/**
+ * Event Log Tools
+ *
+ * Tools for managing event log instances and events.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eventLogTools = exports.EventLogGetInstanceStatsTool = exports.EventLogQueryEventsTool = exports.EventLogAppendEventsTool = exports.EventLogAppendEventTool = exports.EventLogDeleteInstanceTool = exports.EventLogUpdateInstanceTool = exports.EventLogListInstancesTool = exports.EventLogGetInstanceTool = exports.EventLogCreateInstanceTool = void 0;
+var eventlog_create_instance_1 = require("./eventlog-create-instance");
+Object.defineProperty(exports, "EventLogCreateInstanceTool", { enumerable: true, get: function () { return eventlog_create_instance_1.EventLogCreateInstanceTool; } });
+var eventlog_get_instance_1 = require("./eventlog-get-instance");
+Object.defineProperty(exports, "EventLogGetInstanceTool", { enumerable: true, get: function () { return eventlog_get_instance_1.EventLogGetInstanceTool; } });
+var eventlog_list_instances_1 = require("./eventlog-list-instances");
+Object.defineProperty(exports, "EventLogListInstancesTool", { enumerable: true, get: function () { return eventlog_list_instances_1.EventLogListInstancesTool; } });
+var eventlog_update_instance_1 = require("./eventlog-update-instance");
+Object.defineProperty(exports, "EventLogUpdateInstanceTool", { enumerable: true, get: function () { return eventlog_update_instance_1.EventLogUpdateInstanceTool; } });
+var eventlog_delete_instance_1 = require("./eventlog-delete-instance");
+Object.defineProperty(exports, "EventLogDeleteInstanceTool", { enumerable: true, get: function () { return eventlog_delete_instance_1.EventLogDeleteInstanceTool; } });
+var eventlog_append_event_1 = require("./eventlog-append-event");
+Object.defineProperty(exports, "EventLogAppendEventTool", { enumerable: true, get: function () { return eventlog_append_event_1.EventLogAppendEventTool; } });
+var eventlog_append_events_1 = require("./eventlog-append-events");
+Object.defineProperty(exports, "EventLogAppendEventsTool", { enumerable: true, get: function () { return eventlog_append_events_1.EventLogAppendEventsTool; } });
+var eventlog_query_events_1 = require("./eventlog-query-events");
+Object.defineProperty(exports, "EventLogQueryEventsTool", { enumerable: true, get: function () { return eventlog_query_events_1.EventLogQueryEventsTool; } });
+var eventlog_get_instance_stats_1 = require("./eventlog-get-instance-stats");
+Object.defineProperty(exports, "EventLogGetInstanceStatsTool", { enumerable: true, get: function () { return eventlog_get_instance_stats_1.EventLogGetInstanceStatsTool; } });
+const eventlog_create_instance_2 = require("./eventlog-create-instance");
+const eventlog_get_instance_2 = require("./eventlog-get-instance");
+const eventlog_list_instances_2 = require("./eventlog-list-instances");
+const eventlog_update_instance_2 = require("./eventlog-update-instance");
+const eventlog_delete_instance_2 = require("./eventlog-delete-instance");
+const eventlog_append_event_2 = require("./eventlog-append-event");
+const eventlog_append_events_2 = require("./eventlog-append-events");
+const eventlog_query_events_2 = require("./eventlog-query-events");
+const eventlog_get_instance_stats_2 = require("./eventlog-get-instance-stats");
+/**
+ * Array of all event log tools
+ */
+exports.eventLogTools = [
+    new eventlog_create_instance_2.EventLogCreateInstanceTool(),
+    new eventlog_get_instance_2.EventLogGetInstanceTool(),
+    new eventlog_list_instances_2.EventLogListInstancesTool(),
+    new eventlog_update_instance_2.EventLogUpdateInstanceTool(),
+    new eventlog_delete_instance_2.EventLogDeleteInstanceTool(),
+    new eventlog_append_event_2.EventLogAppendEventTool(),
+    new eventlog_append_events_2.EventLogAppendEventsTool(),
+    new eventlog_query_events_2.EventLogQueryEventsTool(),
+    new eventlog_get_instance_stats_2.EventLogGetInstanceStatsTool(),
+];

package/dist/tools/file/edit.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Edit Tool - Edits file content using text replacement
+ * Wraps the SDK's cbfs.editFileWithDiff() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the Edit tool
+ */
+export interface EditToolParams {
+    /**
+     * One sentence explanation of why this tool is being used
+     */
+    explanation?: string;
+    /**
+     * The absolute path to the file to edit
+     */
+    absolute_path: string;
+    /**
+     * The original text to find and replace
+     */
+    old_string: string;
+    /**
+     * The new text to replace with
+     */
+    new_string: string;
+    /**
+     * Optional: Expected number of occurrences to replace
+     */
+    expected_occurrences?: number;
+}
+/**
+ * Implementation of the Edit tool logic
+ */
+export declare class EditTool extends BaseDeclarativeTool<EditToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: EditToolParams): string | null;
+    protected createInvocation(params: EditToolParams): ToolInvocation<EditToolParams, ToolResult>;
+}

package/dist/tools/file/edit.js

@@ -0,0 +1,251 @@
+"use strict";
+/**
+ * Edit Tool - Edits file content using text replacement
+ * Wraps the SDK's cbfs.editFileWithDiff() method
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EditTool = void 0;
+const path = __importStar(require("path"));
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class EditToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    toolLocations() {
+        return [{ path: this.params.absolute_path }];
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const filePath = this.params.absolute_path;
+            const oldString = this.params.old_string;
+            const newString = this.params.new_string;
+            // First read the file to get original content
+            const readResponse = await fs_1.default.readFile(filePath);
+            if (!readResponse.success) {
+                const errorMsg = typeof readResponse.error === 'string'
+                    ? readResponse.error
+                    : ((_a = readResponse.error) === null || _a === void 0 ? void 0 : _a.message) || 'File not found';
+                return {
+                    llmContent: `Error: Could not read file: ${errorMsg}`,
+                    returnDisplay: `Error reading file`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.FILE_NOT_FOUND,
+                    },
+                };
+            }
+            const originalContent = readResponse.content || '';
+            // Count occurrences
+            const occurrences = originalContent.split(oldString).length - 1;
+            if (occurrences === 0) {
+                return {
+                    llmContent: `Error: The specified text was not found in the file.\nSearched for: "${this.truncateForDisplay(oldString)}"`,
+                    returnDisplay: `Error: Text not found in file`,
+                    error: {
+                        message: 'Text to replace was not found in the file',
+                        type: types_1.ToolErrorType.EDIT_NO_OCCURRENCE_FOUND,
+                    },
+                };
+            }
+            // Check expected occurrences if specified
+            if (this.params.expected_occurrences !== undefined &&
+                occurrences !== this.params.expected_occurrences) {
+                return {
+                    llmContent: `Error: Expected ${this.params.expected_occurrences} occurrence(s), but found ${occurrences}.\nThis might indicate the old_string is not unique enough. Please provide more context in old_string.`,
+                    returnDisplay: `Error: Occurrence count mismatch`,
+                    error: {
+                        message: `Expected ${this.params.expected_occurrences} occurrences, found ${occurrences}`,
+                        type: types_1.ToolErrorType.EDIT_EXPECTED_OCCURRENCE_MISMATCH,
+                    },
+                };
+            }
+            // Perform the replacement
+            const newContent = originalContent.replace(new RegExp(this.escapeRegExp(oldString), 'g'), newString);
+            // Check if anything changed
+            if (originalContent === newContent) {
+                return {
+                    llmContent: 'Error: No changes were made to the file.',
+                    returnDisplay: 'No changes made',
+                    error: {
+                        message: 'Edit resulted in no changes',
+                        type: types_1.ToolErrorType.EDIT_NO_CHANGE,
+                    },
+                };
+            }
+            // Write the updated content
+            const fileName = path.basename(filePath);
+            const updateResponse = await fs_1.default.updateFile(fileName, filePath, newContent);
+            if (!updateResponse.success) {
+                const errorMsg = typeof updateResponse.error === 'string'
+                    ? updateResponse.error
+                    : ((_b = updateResponse.error) === null || _b === void 0 ? void 0 : _b.message) || 'Unknown error';
+                return {
+                    llmContent: `Error writing file: ${errorMsg}`,
+                    returnDisplay: `Error writing file`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.FILE_WRITE_FAILURE,
+                    },
+                };
+            }
+            // Generate a simple diff for display
+            const diff = this.generateSimpleDiff(originalContent, newContent, filePath);
+            const fileDiff = {
+                fileDiff: diff,
+                fileName: fileName,
+                originalContent: originalContent,
+                newContent: newContent,
+            };
+            return {
+                llmContent: `Successfully edited ${filePath}\nReplaced ${occurrences} occurrence(s) of the specified text.`,
+                returnDisplay: fileDiff,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error editing file: ${errorMessage}`,
+                returnDisplay: `Error editing file: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+    escapeRegExp(string) {
+        return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    truncateForDisplay(str, maxLength = 100) {
+        if (str.length <= maxLength)
+            return str;
+        return str.substring(0, maxLength) + '...';
+    }
+    generateSimpleDiff(original, updated, filePath) {
+        const originalLines = original.split('\n');
+        const updatedLines = updated.split('\n');
+        let diff = `--- a/${path.basename(filePath)}\n`;
+        diff += `+++ b/${path.basename(filePath)}\n`;
+        // Simple line-by-line diff
+        const maxLines = Math.max(originalLines.length, updatedLines.length);
+        let changesFound = false;
+        let contextStart = -1;
+        for (let i = 0; i < maxLines; i++) {
+            const origLine = originalLines[i];
+            const newLine = updatedLines[i];
+            if (origLine !== newLine) {
+                if (!changesFound) {
+                    diff += `@@ -${Math.max(1, i - 2)},${originalLines.length} +${Math.max(1, i - 2)},${updatedLines.length} @@\n`;
+                    changesFound = true;
+                }
+                if (origLine !== undefined) {
+                    diff += `-${origLine}\n`;
+                }
+                if (newLine !== undefined) {
+                    diff += `+${newLine}\n`;
+                }
+            }
+        }
+        return diff;
+    }
+}
+/**
+ * Implementation of the Edit tool logic
+ */
+class EditTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(EditTool.Name, 'Edit', `Edits a file by replacing specified text with new text. The tool finds all occurrences of 'old_string' in the file and replaces them with 'new_string'. Use this for precise, targeted edits to existing files.`, types_1.Kind.Edit, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                absolute_path: {
+                    description: "The absolute path to the file to edit (e.g., '/home/user/project/file.txt').",
+                    type: 'string',
+                },
+                old_string: {
+                    description: 'The exact text to find in the file. Must be unique enough to identify the correct location. Include surrounding context if needed for uniqueness.',
+                    type: 'string',
+                },
+                new_string: {
+                    description: 'The text to replace old_string with. Can be empty to delete the old text.',
+                    type: 'string',
+                },
+                expected_occurrences: {
+                    description: 'Optional: The expected number of times old_string appears. If specified and the actual count differs, the edit will fail. Use this to ensure you are editing exactly what you intend.',
+                    type: 'number',
+                },
+            },
+            required: ['absolute_path', 'old_string', 'new_string'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        const filePath = params.absolute_path;
+        if (params.absolute_path.trim() === '') {
+            return "The 'absolute_path' parameter must be non-empty.";
+        }
+        if (!path.isAbsolute(filePath)) {
+            return `File path must be absolute, but was relative: ${filePath}.`;
+        }
+        if (params.old_string === undefined || params.old_string === '') {
+            return "The 'old_string' parameter must be non-empty.";
+        }
+        if (params.old_string === params.new_string) {
+            return 'old_string and new_string are identical. No edit would be made.';
+        }
+        if (params.expected_occurrences !== undefined && params.expected_occurrences < 1) {
+            return 'expected_occurrences must be at least 1';
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new EditToolInvocation(params);
+    }
+}
+exports.EditTool = EditTool;
+EditTool.Name = 'edit';

package/dist/tools/file/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * File operations tools
+ */
+export { ReadFileTool, type ReadFileToolParams } from './read-file';
+export { WriteFileTool, type WriteFileToolParams } from './write-file';
+export { EditTool, type EditToolParams } from './edit';
+export { ListDirectoryTool, type ListDirectoryToolParams } from './list-directory';
+export { ReadManyFilesTool, type ReadManyFilesToolParams } from './read-many-files';
+import { ReadFileTool } from './read-file';
+import { WriteFileTool } from './write-file';
+import { EditTool } from './edit';
+import { ListDirectoryTool } from './list-directory';
+import { ReadManyFilesTool } from './read-many-files';
+/**
+ * All file operation tools
+ */
+export declare const fileTools: (ReadFileTool | WriteFileTool | EditTool | ListDirectoryTool | ReadManyFilesTool)[];

package/dist/tools/file/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * File operations tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileTools = exports.ReadManyFilesTool = exports.ListDirectoryTool = exports.EditTool = exports.WriteFileTool = exports.ReadFileTool = void 0;
+var read_file_1 = require("./read-file");
+Object.defineProperty(exports, "ReadFileTool", { enumerable: true, get: function () { return read_file_1.ReadFileTool; } });
+var write_file_1 = require("./write-file");
+Object.defineProperty(exports, "WriteFileTool", { enumerable: true, get: function () { return write_file_1.WriteFileTool; } });
+var edit_1 = require("./edit");
+Object.defineProperty(exports, "EditTool", { enumerable: true, get: function () { return edit_1.EditTool; } });
+var list_directory_1 = require("./list-directory");
+Object.defineProperty(exports, "ListDirectoryTool", { enumerable: true, get: function () { return list_directory_1.ListDirectoryTool; } });
+var read_many_files_1 = require("./read-many-files");
+Object.defineProperty(exports, "ReadManyFilesTool", { enumerable: true, get: function () { return read_many_files_1.ReadManyFilesTool; } });
+// Create instances for convenience
+const read_file_2 = require("./read-file");
+const write_file_2 = require("./write-file");
+const edit_2 = require("./edit");
+const list_directory_2 = require("./list-directory");
+const read_many_files_2 = require("./read-many-files");
+/**
+ * All file operation tools
+ */
+exports.fileTools = [
+    new read_file_2.ReadFileTool(),
+    new write_file_2.WriteFileTool(),
+    new edit_2.EditTool(),
+    new list_directory_2.ListDirectoryTool(),
+    new read_many_files_2.ReadManyFilesTool(),
+];

package/dist/tools/file/list-directory.d.ts

@@ -0,0 +1,44 @@
+/**
+ * List Directory Tool - Lists files and directories
+ * Wraps the SDK's cbfs.listDirectory() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the ListDirectory tool
+ */
+export interface ListDirectoryToolParams {
+    /**
+     * One sentence explanation of why this tool is being used
+     */
+    explanation?: string;
+    /**
+     * The absolute path to the directory to list
+     */
+    path: string;
+    /**
+     * Optional array of glob patterns for files/directories to ignore
+     */
+    ignore?: string[];
+    /**
+     * Whether to show hidden files and directories (default: false)
+     */
+    show_hidden?: boolean;
+    /**
+     * Whether to include detailed information (size, permissions, etc.)
+     */
+    detailed?: boolean;
+    /**
+     * Maximum number of entries to return
+     */
+    limit?: number;
+}
+/**
+ * Implementation of the ListDirectory tool logic
+ */
+export declare class ListDirectoryTool extends BaseDeclarativeTool<ListDirectoryToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: ListDirectoryToolParams): string | null;
+    protected createInvocation(params: ListDirectoryToolParams): ToolInvocation<ListDirectoryToolParams, ToolResult>;
+}