@codebolt/codeboltjs 5.0.8 → 5.0.9

package/dist/tools/git/git-action.js

@@ -1,279 +0,0 @@
-"use strict";
-/**
- * Git Action Tool - Performs various Git operations
- * Wraps the SDK's gitService methods
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitActionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const git_1 = __importDefault(require("../../modules/git"));
-class GitActionToolInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        var _a;
-        try {
-            const action = this.params.action;
-            let response;
-            let successMessage;
-            switch (action) {
-                case 'init':
-                    if (!this.params.path) {
-                        return this.createError("'path' is required for init action");
-                    }
-                    response = await git_1.default.init(this.params.path);
-                    successMessage = `Initialized Git repository at ${this.params.path}`;
-                    break;
-                case 'status':
-                    response = await git_1.default.status();
-                    successMessage = 'Git status retrieved';
-                    break;
-                case 'add':
-                    response = await git_1.default.addAll();
-                    successMessage = 'Added all changes to staging';
-                    break;
-                case 'commit':
-                    if (!this.params.message) {
-                        return this.createError("'message' is required for commit action");
-                    }
-                    response = await git_1.default.commit(this.params.message);
-                    successMessage = `Committed with message: "${this.params.message}"`;
-                    break;
-                case 'push':
-                    response = await git_1.default.push();
-                    successMessage = 'Pushed changes to remote';
-                    break;
-                case 'pull':
-                    response = await git_1.default.pull();
-                    successMessage = 'Pulled changes from remote';
-                    break;
-                case 'checkout':
-                    if (!this.params.branch) {
-                        return this.createError("'branch' is required for checkout action");
-                    }
-                    response = await git_1.default.checkout(this.params.branch);
-                    successMessage = `Checked out branch: ${this.params.branch}`;
-                    break;
-                case 'branch':
-                    if (!this.params.branch) {
-                        return this.createError("'branch' is required for branch action");
-                    }
-                    response = await git_1.default.branch(this.params.branch);
-                    successMessage = `Created branch: ${this.params.branch}`;
-                    break;
-                case 'logs':
-                    if (!this.params.path) {
-                        return this.createError("'path' is required for logs action");
-                    }
-                    response = await git_1.default.logs(this.params.path);
-                    successMessage = 'Git logs retrieved';
-                    break;
-                case 'diff':
-                    if (!this.params.commit_hash) {
-                        return this.createError("'commit_hash' is required for diff action");
-                    }
-                    response = await git_1.default.diff(this.params.commit_hash);
-                    successMessage = `Diff for commit: ${this.params.commit_hash}`;
-                    break;
-                case 'clone':
-                    if (!this.params.url) {
-                        return this.createError("'url' is required for clone action");
-                    }
-                    response = await git_1.default.clone(this.params.url, this.params.path);
-                    successMessage = `Cloned repository from ${this.params.url}`;
-                    break;
-                default:
-                    return this.createError(`Unknown action: ${action}`);
-            }
-            // Check for errors
-            if (!response.success && response.success !== undefined) {
-                const errorMsg = typeof response.error === 'string'
-                    ? response.error
-                    : ((_a = response.error) === null || _a === void 0 ? void 0 : _a.message) || 'Git operation failed';
-                return {
-                    llmContent: `Git ${action} failed: ${errorMsg}`,
-                    returnDisplay: `Error: ${errorMsg}`,
-                    error: {
-                        message: errorMsg,
-                        type: types_1.ToolErrorType.GIT_EXECUTION_ERROR,
-                    },
-                };
-            }
-            // Format output based on action
-            let output = successMessage;
-            if (action === 'status' && response.status) {
-                output += '\n\n' + this.formatStatus(response.status);
-            }
-            else if (action === 'logs' && response.logs) {
-                output += '\n\n' + this.formatLogs(response.logs);
-            }
-            else if (action === 'diff' && response.diff) {
-                output += '\n\n' + response.diff;
-            }
-            else if (response.message) {
-                output += '\n\n' + response.message;
-            }
-            else if (response.result) {
-                output += '\n\n' + (typeof response.result === 'string' ? response.result : JSON.stringify(response.result, null, 2));
-            }
-            return {
-                llmContent: output,
-                returnDisplay: successMessage,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error executing git ${this.params.action}: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-    createError(message) {
-        return {
-            llmContent: `Error: ${message}`,
-            returnDisplay: `Error: ${message}`,
-            error: {
-                message,
-                type: types_1.ToolErrorType.INVALID_TOOL_PARAMS,
-            },
-        };
-    }
-    formatStatus(status) {
-        var _a, _b, _c;
-        if (typeof status === 'string')
-            return status;
-        let output = '';
-        if (status.current)
-            output += `Current branch: ${status.current}\n`;
-        if (status.tracking)
-            output += `Tracking: ${status.tracking}\n`;
-        if (status.files && status.files.length > 0) {
-            output += '\nChanges:\n';
-            for (const file of status.files) {
-                const path = file.path || file;
-                const index = file.index || '?';
-                const working_dir = file.working_dir || '?';
-                output += `  ${index}${working_dir} ${path}\n`;
-            }
-        }
-        else if (status.modified || status.created || status.deleted) {
-            if ((_a = status.modified) === null || _a === void 0 ? void 0 : _a.length) {
-                output += '\nModified:\n';
-                status.modified.forEach((f) => output += `  M ${f}\n`);
-            }
-            if ((_b = status.created) === null || _b === void 0 ? void 0 : _b.length) {
-                output += '\nNew files:\n';
-                status.created.forEach((f) => output += `  A ${f}\n`);
-            }
-            if ((_c = status.deleted) === null || _c === void 0 ? void 0 : _c.length) {
-                output += '\nDeleted:\n';
-                status.deleted.forEach((f) => output += `  D ${f}\n`);
-            }
-        }
-        else {
-            output += '\nNo changes detected.';
-        }
-        return output;
-    }
-    formatLogs(logs) {
-        if (!Array.isArray(logs))
-            return String(logs);
-        return logs.slice(0, 10).map(log => {
-            const hash = (log.hash || log.commit || '').substring(0, 7);
-            const message = log.message || log.subject || '';
-            const author = log.author_name || log.author || '';
-            const date = log.date || '';
-            return `${hash} - ${message} (${author}, ${date})`;
-        }).join('\n');
-    }
-}
-/**
- * Implementation of the GitAction tool logic
- */
-class GitActionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(GitActionTool.Name, 'GitAction', `Performs Git operations like init, status, add, commit, push, pull, checkout, branch, logs, diff, and clone. Use this for version control operations.`, types_1.Kind.Execute, {
-            properties: {
-                action: {
-                    description: "The Git action to perform: 'init', 'status', 'add', 'commit', 'push', 'pull', 'checkout', 'branch', 'logs', 'diff', or 'clone'.",
-                    type: 'string',
-                    enum: ['init', 'status', 'add', 'commit', 'push', 'pull', 'checkout', 'branch', 'logs', 'diff', 'clone'],
-                },
-                path: {
-                    description: "Path for init/logs/clone operations.",
-                    type: 'string',
-                },
-                message: {
-                    description: "Commit message (required for 'commit' action).",
-                    type: 'string',
-                },
-                branch: {
-                    description: "Branch name (required for 'checkout' and 'branch' actions).",
-                    type: 'string',
-                },
-                commit_hash: {
-                    description: "Commit hash (required for 'diff' action).",
-                    type: 'string',
-                },
-                url: {
-                    description: "Repository URL (required for 'clone' action).",
-                    type: 'string',
-                },
-            },
-            required: ['action'],
-            type: 'object',
-        });
-    }
-    validateToolParamValues(params) {
-        const validActions = ['init', 'status', 'add', 'commit', 'push', 'pull', 'checkout', 'branch', 'logs', 'diff', 'clone'];
-        if (!validActions.includes(params.action)) {
-            return `Invalid action: ${params.action}. Must be one of: ${validActions.join(', ')}`;
-        }
-        // Action-specific validation
-        switch (params.action) {
-            case 'init':
-            case 'logs':
-                if (!params.path) {
-                    return `'path' is required for ${params.action} action`;
-                }
-                break;
-            case 'commit':
-                if (!params.message) {
-                    return "'message' is required for commit action";
-                }
-                break;
-            case 'checkout':
-            case 'branch':
-                if (!params.branch) {
-                    return `'branch' is required for ${params.action} action`;
-                }
-                break;
-            case 'diff':
-                if (!params.commit_hash) {
-                    return "'commit_hash' is required for diff action";
-                }
-                break;
-            case 'clone':
-                if (!params.url) {
-                    return "'url' is required for clone action";
-                }
-                break;
-        }
-        return null;
-    }
-    createInvocation(params) {
-        return new GitActionToolInvocation(params);
-    }
-}
-exports.GitActionTool = GitActionTool;
-GitActionTool.Name = 'git_action';

package/dist/tools/kvStore/kv-store-create-instance.d.ts

@@ -1,26 +0,0 @@
-/**
- * Create KV Store Instance Tool - Creates a new key-value store instance
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the CreateKVInstance tool
- */
-export interface CreateKVInstanceParams {
-    /**
-     * Instance name
-     */
-    name: string;
-    /**
-     * Optional description
-     */
-    description?: string;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class CreateKVInstanceTool extends BaseDeclarativeTool<CreateKVInstanceParams, ToolResult> {
-    constructor();
-    createInvocation(params: CreateKVInstanceParams, invocationId: string): ToolInvocation;
-}

package/dist/tools/kvStore/kv-store-create-instance.js

@@ -1,79 +0,0 @@
-"use strict";
-/**
- * Create KV Store Instance Tool - Creates a new key-value store instance
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateKVInstanceTool = void 0;
-const base_tool_1 = require("../base-tool");
-const kvStore_1 = __importDefault(require("../../modules/kvStore"));
-class CreateKVInstanceInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await kvStore_1.default.createInstance(this.params.name, this.params.description);
-            if (!response.success || !response.instance) {
-                return {
-                    llmContent: `Error creating KV store instance: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error creating KV store instance: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const instance = response.instance;
-            const content = `KV store instance created successfully:\n` +
-                `ID: ${instance.id}\n` +
-                `Name: ${instance.name}\n` +
-                `Description: ${instance.description || 'N/A'}`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error creating KV store instance: ${error}`,
-                returnDisplay: `Error creating KV store instance: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class CreateKVInstanceTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('kvStore_createInstance', 'Create a new key-value store instance for agent state persistence', {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Instance name',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Optional description',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['name'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new CreateKVInstanceInvocation(params);
-    }
-}
-exports.CreateKVInstanceTool = CreateKVInstanceTool;

package/dist/tools/kvStore/kv-store-get.d.ts

@@ -1,30 +0,0 @@
-/**
- * KV Store Get Tool - Gets a value from the key-value store
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the KVGet tool
- */
-export interface KVGetParams {
-    /**
-     * Instance ID
-     */
-    instanceId: string;
-    /**
-     * Key to retrieve
-     */
-    key: string;
-    /**
-     * Optional namespace
-     */
-    namespace?: string;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class KVGetTool extends BaseDeclarativeTool<KVGetParams, ToolResult> {
-    constructor();
-    createInvocation(params: KVGetParams, invocationId: string): ToolInvocation;
-}

package/dist/tools/kvStore/kv-store-get.js

@@ -1,80 +0,0 @@
-"use strict";
-/**
- * KV Store Get Tool - Gets a value from the key-value store
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KVGetTool = void 0;
-const base_tool_1 = require("../base-tool");
-const kvStore_1 = __importDefault(require("../../modules/kvStore"));
-class KVGetInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await kvStore_1.default.get(this.params.instanceId, this.params.key, this.params.namespace);
-            if (!response.success) {
-                return {
-                    llmContent: `Error getting value from KV store: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error getting value from KV store: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const value = response.value !== undefined ? JSON.stringify(response.value, null, 2) : 'undefined';
-            const content = `Retrieved value for key "${this.params.key}":\n${value}`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error getting value from KV store: ${error}`,
-                returnDisplay: `Error getting value from KV store: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class KVGetTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('kvStore_get', 'Get a value from the key-value store by key', {
-            type: 'object',
-            properties: {
-                instanceId: {
-                    type: 'string',
-                    description: 'Instance ID',
-                },
-                key: {
-                    type: 'string',
-                    description: 'Key to retrieve',
-                },
-                namespace: {
-                    type: 'string',
-                    description: 'Optional namespace',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['instanceId', 'key'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new KVGetInvocation(params);
-    }
-}
-exports.KVGetTool = KVGetTool;

package/dist/tools/kvStore/kv-store-set.d.ts

@@ -1,38 +0,0 @@
-/**
- * KV Store Set Tool - Sets a value in the key-value store
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the KVSet tool
- */
-export interface KVSetParams {
-    /**
-     * Instance ID
-     */
-    instanceId: string;
-    /**
-     * Key to set
-     */
-    key: string;
-    /**
-     * Value to set (will be JSON stringified)
-     */
-    value: any;
-    /**
-     * Optional namespace
-     */
-    namespace?: string;
-    /**
-     * Optional TTL in seconds
-     */
-    ttl?: number;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class KVSetTool extends BaseDeclarativeTool<KVSetParams, ToolResult> {
-    constructor();
-    createInvocation(params: KVSetParams, invocationId: string): ToolInvocation;
-}

package/dist/tools/kvStore/kv-store-set.js

@@ -1,86 +0,0 @@
-"use strict";
-/**
- * KV Store Set Tool - Sets a value in the key-value store
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KVSetTool = void 0;
-const base_tool_1 = require("../base-tool");
-const kvStore_1 = __importDefault(require("../../modules/kvStore"));
-class KVSetInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    toolLocations() {
-        return [];
-    }
-    async execute() {
-        try {
-            const response = await kvStore_1.default.set(this.params.instanceId, this.params.key, this.params.value, this.params.namespace, this.params.ttl);
-            if (!response.success) {
-                return {
-                    llmContent: `Error setting value in KV store: ${response.error || 'Unknown error'}`,
-                    returnDisplay: `Error setting value in KV store: ${response.error || 'Unknown error'}`,
-                    error: {
-                        message: response.error || 'Unknown error',
-                        type: 'unknown',
-                    },
-                };
-            }
-            const content = `Value set successfully for key "${this.params.key}" in instance "${this.params.instanceId}"`;
-            return {
-                llmContent: content,
-                returnDisplay: content,
-            };
-        }
-        catch (error) {
-            return {
-                llmContent: `Error setting value in KV store: ${error}`,
-                returnDisplay: `Error setting value in KV store: ${error}`,
-                error: {
-                    message: String(error),
-                    type: 'unknown',
-                },
-            };
-        }
-    }
-}
-class KVSetTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super('kvStore_set', 'Set a value in the key-value store by key', {
-            type: 'object',
-            properties: {
-                instanceId: {
-                    type: 'string',
-                    description: 'Instance ID',
-                },
-                key: {
-                    type: 'string',
-                    description: 'Key to set',
-                },
-                value: {
-                    description: 'Value to set (will be JSON stringified)',
-                },
-                namespace: {
-                    type: 'string',
-                    description: 'Optional namespace',
-                },
-                ttl: {
-                    type: 'number',
-                    description: 'Optional TTL in seconds',
-                },
-                explanation: {
-                    type: 'string',
-                    description: 'One sentence explanation of why this tool is being used',
-                },
-            },
-            required: ['instanceId', 'key', 'value'],
-        });
-    }
-    createInvocation(params, invocationId) {
-        return new KVSetInvocation(params);
-    }
-}
-exports.KVSetTool = KVSetTool;

package/dist/tools/memoryIngestion/mi-create-pipeline.d.ts

@@ -1,44 +0,0 @@
-/**
- * Create Memory Ingestion Pipeline Tool - Creates a new memory ingestion pipeline
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the CreateMemoryIngestionPipeline tool
- */
-export interface CreateMemoryIngestionPipelineParams {
-    /**
-     * Pipeline ID
-     */
-    pipelineId: string;
-    /**
-     * Pipeline label/name
-     */
-    label: string;
-    /**
-     * Pipeline description
-     */
-    description?: string;
-    /**
-     * Source configuration
-     */
-    source: {
-        type: string;
-        [key: string]: any;
-    };
-    /**
-     * Processors configuration
-     */
-    processors: Array<{
-        type: string;
-        [key: string]: any;
-    }>;
-    /**
-     * One sentence explanation of why this tool is being used
-     */
-    explanation?: string;
-}
-export declare class CreateMemoryIngestionPipelineTool extends BaseDeclarativeTool<CreateMemoryIngestionPipelineParams, ToolResult> {
-    constructor();
-    createInvocation(params: CreateMemoryIngestionPipelineParams, invocationId: string): ToolInvocation;
-}