@codebolt/codeboltjs 5.0.2 → 5.0.3

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

@@ -0,0 +1,279 @@
+"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/git/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Git tools - Individual tools for each git action
+ */
+export { GitInitTool, type GitInitParams } from './init';
+export { GitStatusTool, type GitStatusParams } from './status';
+export { GitAddTool, type GitAddParams } from './add';
+export { GitCommitTool, type GitCommitParams } from './commit';
+export { GitPushTool, type GitPushParams } from './push';
+export { GitPullTool, type GitPullParams } from './pull';
+export { GitCheckoutTool, type GitCheckoutParams } from './checkout';
+export { GitBranchTool, type GitBranchParams } from './branch';
+export { GitLogsTool, type GitLogsParams } from './logs';
+export { GitDiffTool, type GitDiffParams } from './diff';
+export { GitCloneTool, type GitCloneParams } from './clone';
+import { GitInitTool } from './init';
+import { GitStatusTool } from './status';
+import { GitAddTool } from './add';
+import { GitCommitTool } from './commit';
+import { GitPushTool } from './push';
+import { GitPullTool } from './pull';
+import { GitCheckoutTool } from './checkout';
+import { GitBranchTool } from './branch';
+import { GitLogsTool } from './logs';
+import { GitDiffTool } from './diff';
+import { GitCloneTool } from './clone';
+/**
+ * All git tools
+ */
+export declare const gitTools: (GitInitTool | GitStatusTool | GitAddTool | GitCommitTool | GitPushTool | GitPullTool | GitCheckoutTool | GitBranchTool | GitLogsTool | GitDiffTool | GitCloneTool)[];

package/dist/tools/git/index.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Git tools - Individual tools for each git action
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitTools = exports.GitCloneTool = exports.GitDiffTool = exports.GitLogsTool = exports.GitBranchTool = exports.GitCheckoutTool = exports.GitPullTool = exports.GitPushTool = exports.GitCommitTool = exports.GitAddTool = exports.GitStatusTool = exports.GitInitTool = void 0;
+// Individual git tools
+var init_1 = require("./init");
+Object.defineProperty(exports, "GitInitTool", { enumerable: true, get: function () { return init_1.GitInitTool; } });
+var status_1 = require("./status");
+Object.defineProperty(exports, "GitStatusTool", { enumerable: true, get: function () { return status_1.GitStatusTool; } });
+var add_1 = require("./add");
+Object.defineProperty(exports, "GitAddTool", { enumerable: true, get: function () { return add_1.GitAddTool; } });
+var commit_1 = require("./commit");
+Object.defineProperty(exports, "GitCommitTool", { enumerable: true, get: function () { return commit_1.GitCommitTool; } });
+var push_1 = require("./push");
+Object.defineProperty(exports, "GitPushTool", { enumerable: true, get: function () { return push_1.GitPushTool; } });
+var pull_1 = require("./pull");
+Object.defineProperty(exports, "GitPullTool", { enumerable: true, get: function () { return pull_1.GitPullTool; } });
+var checkout_1 = require("./checkout");
+Object.defineProperty(exports, "GitCheckoutTool", { enumerable: true, get: function () { return checkout_1.GitCheckoutTool; } });
+var branch_1 = require("./branch");
+Object.defineProperty(exports, "GitBranchTool", { enumerable: true, get: function () { return branch_1.GitBranchTool; } });
+var logs_1 = require("./logs");
+Object.defineProperty(exports, "GitLogsTool", { enumerable: true, get: function () { return logs_1.GitLogsTool; } });
+var diff_1 = require("./diff");
+Object.defineProperty(exports, "GitDiffTool", { enumerable: true, get: function () { return diff_1.GitDiffTool; } });
+var clone_1 = require("./clone");
+Object.defineProperty(exports, "GitCloneTool", { enumerable: true, get: function () { return clone_1.GitCloneTool; } });
+// Create instances for convenience
+const init_2 = require("./init");
+const status_2 = require("./status");
+const add_2 = require("./add");
+const commit_2 = require("./commit");
+const push_2 = require("./push");
+const pull_2 = require("./pull");
+const checkout_2 = require("./checkout");
+const branch_2 = require("./branch");
+const logs_2 = require("./logs");
+const diff_2 = require("./diff");
+const clone_2 = require("./clone");
+/**
+ * All git tools
+ */
+exports.gitTools = [
+    new init_2.GitInitTool(),
+    new status_2.GitStatusTool(),
+    new add_2.GitAddTool(),
+    new commit_2.GitCommitTool(),
+    new push_2.GitPushTool(),
+    new pull_2.GitPullTool(),
+    new checkout_2.GitCheckoutTool(),
+    new branch_2.GitBranchTool(),
+    new logs_2.GitLogsTool(),
+    new diff_2.GitDiffTool(),
+    new clone_2.GitCloneTool(),
+];

package/dist/tools/git/init.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Git Init Tool - Initializes a new Git repository
+ * Wraps the SDK's gitService.init() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface GitInitParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** Path where to initialize the Git repository */
+    path: string;
+}
+export declare class GitInitTool extends BaseDeclarativeTool<GitInitParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: GitInitParams): string | null;
+    protected createInvocation(params: GitInitParams): ToolInvocation<GitInitParams, ToolResult>;
+}

package/dist/tools/git/init.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Git Init Tool - Initializes a new Git repository
+ * Wraps the SDK's gitService.init() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitInitTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const git_1 = __importDefault(require("../../modules/git"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class GitInitInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const response = await git_1.default.init(this.params.path);
+            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 init failed';
+                return {
+                    llmContent: `Git init failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.GIT_EXECUTION_ERROR,
+                    },
+                };
+            }
+            let output = `Initialized Git repository at ${this.params.path}`;
+            if (response.message) {
+                output += '\n\n' + response.message;
+            }
+            return {
+                llmContent: output,
+                returnDisplay: `Initialized Git repository at ${this.params.path}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error initializing Git repository: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+class GitInitTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(GitInitTool.Name, 'GitInit', 'Initializes a new Git repository at the specified path.', types_1.Kind.Execute, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                path: {
+                    description: 'The file system path where the Git repository should be initialized.',
+                    type: 'string',
+                },
+            },
+            required: ['path'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.path || params.path.trim() === '') {
+            return "'path' is required for git init";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new GitInitInvocation(params);
+    }
+}
+exports.GitInitTool = GitInitTool;
+GitInitTool.Name = 'git_init';

package/dist/tools/git/logs.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Git Logs Tool - Gets commit logs
+ * Wraps the SDK's gitService.logs() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface GitLogsParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+    /** Path to get logs for */
+    path: string;
+}
+export declare class GitLogsTool extends BaseDeclarativeTool<GitLogsParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected validateToolParamValues(params: GitLogsParams): string | null;
+    protected createInvocation(params: GitLogsParams): ToolInvocation<GitLogsParams, ToolResult>;
+}

package/dist/tools/git/logs.js

@@ -0,0 +1,104 @@
+"use strict";
+/**
+ * Git Logs Tool - Gets commit logs
+ * Wraps the SDK's gitService.logs() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLogsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const git_1 = __importDefault(require("../../modules/git"));
+const chat_1 = __importDefault(require("../../modules/chat"));
+class GitLogsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        var _a;
+        try {
+            if (this.params.explanation) {
+                chat_1.default.sendMessage(this.params.explanation);
+            }
+            const response = await git_1.default.logs(this.params.path);
+            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 logs failed';
+                return {
+                    llmContent: `Git logs failed: ${errorMsg}`,
+                    returnDisplay: `Error: ${errorMsg}`,
+                    error: {
+                        message: errorMsg,
+                        type: types_1.ToolErrorType.GIT_EXECUTION_ERROR,
+                    },
+                };
+            }
+            let output = 'Git logs retrieved';
+            const resp = response;
+            if (resp.logs) {
+                output += '\n\n' + this.formatLogs(resp.logs);
+            }
+            else if (resp.result) {
+                output += '\n\n' + (typeof resp.result === 'string' ? resp.result : JSON.stringify(resp.result, null, 2));
+            }
+            return {
+                llmContent: output,
+                returnDisplay: 'Git logs retrieved',
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error getting Git logs: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+    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');
+    }
+}
+class GitLogsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(GitLogsTool.Name, 'GitLogs', 'Retrieves the commit logs for the Git repository.', types_1.Kind.Read, {
+            properties: {
+                explanation: {
+                    description: "One sentence explanation as to why this tool is being used, and how it contributes to the goal.",
+                    type: 'string',
+                },
+                path: {
+                    description: 'The file system path to get logs for.',
+                    type: 'string',
+                },
+            },
+            required: ['path'],
+            type: 'object',
+        });
+    }
+    validateToolParamValues(params) {
+        if (!params.path || params.path.trim() === '') {
+            return "'path' is required for git logs";
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new GitLogsInvocation(params);
+    }
+}
+exports.GitLogsTool = GitLogsTool;
+GitLogsTool.Name = 'git_logs';

package/dist/tools/git/pull.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Git Pull Tool - Pulls changes from remote
+ * Wraps the SDK's gitService.pull() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface GitPullParams {
+    /** One sentence explanation of why this tool is being used */
+    explanation?: string;
+}
+export declare class GitPullTool extends BaseDeclarativeTool<GitPullParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: GitPullParams): ToolInvocation<GitPullParams, ToolResult>;
+}