@codebolt/codeboltjs 5.0.7 → 5.0.9

package/dist/tools/event/event-on-completion.js

@@ -1,73 +0,0 @@
-"use strict";
-/**
- * Event On Completion Tool - Waits for background agent completion
- * Wraps the SDK's codeboltEvent.onBackgroundAgentCompletion() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventOnCompletionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventOnCompletionInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const completion = await codeboltEvent_1.default.onBackgroundAgentCompletion();
-            if (completion === null) {
-                return {
-                    llmContent: 'No background agent completion received.',
-                    returnDisplay: 'No completion',
-                };
-            }
-            const count = Array.isArray(completion) ? completion.length : 1;
-            let llmContent = `Background agent completion received.\n\n`;
-            if (Array.isArray(completion)) {
-                llmContent += `${count} agent(s) completed:\n`;
-                for (let i = 0; i < completion.length; i++) {
-                    llmContent += `\nCompletion ${i + 1}:\n`;
-                    llmContent += JSON.stringify(completion[i], null, 2) + '\n';
-                }
-            }
-            else {
-                llmContent += JSON.stringify(completion, null, 2);
-            }
-            return {
-                llmContent,
-                returnDisplay: `Received ${count} completion(s)`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error waiting for background agent completion: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for waiting for background agent completion
- */
-class EventOnCompletionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventOnCompletionTool.Name, 'Wait for Background Agent Completion', 'Wait for a background agent to complete. This is a blocking call that resolves when an agent completes.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventOnCompletionInvocation(params);
-    }
-}
-exports.EventOnCompletionTool = EventOnCompletionTool;
-EventOnCompletionTool.Name = 'event_on_completion';

package/dist/tools/event/event-on-grouped-completion.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event On Grouped Completion Tool - Waits for grouped background agent completion
- * Wraps the SDK's codeboltEvent.onBackgroundGroupedAgentCompletion() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventOnGroupedCompletion tool
- */
-export interface EventOnGroupedCompletionParams {
-}
-/**
- * Tool for waiting for grouped background agent completion
- */
-export declare class EventOnGroupedCompletionTool extends BaseDeclarativeTool<EventOnGroupedCompletionParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventOnGroupedCompletionParams): ToolInvocation<EventOnGroupedCompletionParams, ToolResult>;
-}

package/dist/tools/event/event-on-grouped-completion.js

@@ -1,63 +0,0 @@
-"use strict";
-/**
- * Event On Grouped Completion Tool - Waits for grouped background agent completion
- * Wraps the SDK's codeboltEvent.onBackgroundGroupedAgentCompletion() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventOnGroupedCompletionTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventOnGroupedCompletionInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const completion = await codeboltEvent_1.default.onBackgroundGroupedAgentCompletion();
-            if (completion === null) {
-                return {
-                    llmContent: 'No grouped background agent completion received.',
-                    returnDisplay: 'No grouped completion',
-                };
-            }
-            let llmContent = `Grouped background agent completion received.\n\n`;
-            llmContent += JSON.stringify(completion, null, 2);
-            return {
-                llmContent,
-                returnDisplay: 'Received grouped completion',
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error waiting for grouped background agent completion: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for waiting for grouped background agent completion
- */
-class EventOnGroupedCompletionTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventOnGroupedCompletionTool.Name, 'Wait for Grouped Agent Completion', 'Wait for a grouped background agent to complete. This is a blocking call that resolves when a grouped agent completes.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventOnGroupedCompletionInvocation(params);
-    }
-}
-exports.EventOnGroupedCompletionTool = EventOnGroupedCompletionTool;
-EventOnGroupedCompletionTool.Name = 'event_on_grouped_completion';

package/dist/tools/event/event-wait-any.d.ts

@@ -1,19 +0,0 @@
-/**
- * Event Wait Any Tool - Waits for any external event
- * Wraps the SDK's codeboltEvent.waitForAnyExternalEvent() method
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Parameters for the EventWaitAny tool
- */
-export interface EventWaitAnyParams {
-}
-/**
- * Tool for waiting for any external event
- */
-export declare class EventWaitAnyTool extends BaseDeclarativeTool<EventWaitAnyParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected createInvocation(params: EventWaitAnyParams): ToolInvocation<EventWaitAnyParams, ToolResult>;
-}

package/dist/tools/event/event-wait-any.js

@@ -1,66 +0,0 @@
-"use strict";
-/**
- * Event Wait Any Tool - Waits for any external event
- * Wraps the SDK's codeboltEvent.waitForAnyExternalEvent() method
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventWaitAnyTool = void 0;
-const types_1 = require("../types");
-const base_tool_1 = require("../base-tool");
-const codeboltEvent_1 = __importDefault(require("../../modules/codeboltEvent"));
-class EventWaitAnyInvocation extends base_tool_1.BaseToolInvocation {
-    constructor(params) {
-        super(params);
-    }
-    async execute() {
-        try {
-            const result = await codeboltEvent_1.default.waitForAnyExternalEvent();
-            if (!result) {
-                return {
-                    llmContent: 'No external event received.',
-                    returnDisplay: 'No event',
-                };
-            }
-            const eventType = result.type;
-            const eventData = result.data;
-            let llmContent = `External event received.\n`;
-            llmContent += `Type: ${eventType}\n\n`;
-            llmContent += `Data:\n${JSON.stringify(eventData, null, 2)}`;
-            return {
-                llmContent,
-                returnDisplay: `Received: ${eventType}`,
-            };
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
-            return {
-                llmContent: `Error waiting for external event: ${errorMessage}`,
-                returnDisplay: `Error: ${errorMessage}`,
-                error: {
-                    message: errorMessage,
-                    type: types_1.ToolErrorType.EXECUTION_FAILED,
-                },
-            };
-        }
-    }
-}
-/**
- * Tool for waiting for any external event
- */
-class EventWaitAnyTool extends base_tool_1.BaseDeclarativeTool {
-    constructor() {
-        super(EventWaitAnyTool.Name, 'Wait for Any External Event', 'Wait for any external event (Background Completion, Group Completion, or Agent Event). This is a blocking call that resolves when any of these events occur.', types_1.Kind.Other, {
-            type: 'object',
-            properties: {},
-            required: []
-        });
-    }
-    createInvocation(params) {
-        return new EventWaitAnyInvocation(params);
-    }
-}
-exports.EventWaitAnyTool = EventWaitAnyTool;
-EventWaitAnyTool.Name = 'event_wait_any';

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

@@ -1,25 +0,0 @@
-/**
- * Event tools
- */
-export { EventAddRunningAgentTool, type EventAddRunningAgentParams } from './event-add-running-agent';
-export { EventGetRunningCountTool, type EventGetRunningCountParams } from './event-get-running-count';
-export { EventCheckCompletionTool, type EventCheckCompletionParams } from './event-check-completion';
-export { EventOnCompletionTool, type EventOnCompletionParams } from './event-on-completion';
-export { EventCheckGroupedCompletionTool, type EventCheckGroupedCompletionParams } from './event-check-grouped-completion';
-export { EventOnGroupedCompletionTool, type EventOnGroupedCompletionParams } from './event-on-grouped-completion';
-export { EventCheckAgentEventTool, type EventCheckAgentEventParams } from './event-check-agent-event';
-export { EventOnAgentEventTool, type EventOnAgentEventParams } from './event-on-agent-event';
-export { EventWaitAnyTool, type EventWaitAnyParams } from './event-wait-any';
-import { EventAddRunningAgentTool } from './event-add-running-agent';
-import { EventGetRunningCountTool } from './event-get-running-count';
-import { EventCheckCompletionTool } from './event-check-completion';
-import { EventOnCompletionTool } from './event-on-completion';
-import { EventCheckGroupedCompletionTool } from './event-check-grouped-completion';
-import { EventOnGroupedCompletionTool } from './event-on-grouped-completion';
-import { EventCheckAgentEventTool } from './event-check-agent-event';
-import { EventOnAgentEventTool } from './event-on-agent-event';
-import { EventWaitAnyTool } from './event-wait-any';
-/**
- * All event tools
- */
-export declare const eventTools: (EventAddRunningAgentTool | EventCheckAgentEventTool | EventCheckCompletionTool | EventCheckGroupedCompletionTool | EventGetRunningCountTool | EventOnAgentEventTool | EventOnCompletionTool | EventOnGroupedCompletionTool | EventWaitAnyTool)[];

package/dist/tools/event/index.js

@@ -1,48 +0,0 @@
-"use strict";
-/**
- * Event tools
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.eventTools = exports.EventWaitAnyTool = exports.EventOnAgentEventTool = exports.EventCheckAgentEventTool = exports.EventOnGroupedCompletionTool = exports.EventCheckGroupedCompletionTool = exports.EventOnCompletionTool = exports.EventCheckCompletionTool = exports.EventGetRunningCountTool = exports.EventAddRunningAgentTool = void 0;
-var event_add_running_agent_1 = require("./event-add-running-agent");
-Object.defineProperty(exports, "EventAddRunningAgentTool", { enumerable: true, get: function () { return event_add_running_agent_1.EventAddRunningAgentTool; } });
-var event_get_running_count_1 = require("./event-get-running-count");
-Object.defineProperty(exports, "EventGetRunningCountTool", { enumerable: true, get: function () { return event_get_running_count_1.EventGetRunningCountTool; } });
-var event_check_completion_1 = require("./event-check-completion");
-Object.defineProperty(exports, "EventCheckCompletionTool", { enumerable: true, get: function () { return event_check_completion_1.EventCheckCompletionTool; } });
-var event_on_completion_1 = require("./event-on-completion");
-Object.defineProperty(exports, "EventOnCompletionTool", { enumerable: true, get: function () { return event_on_completion_1.EventOnCompletionTool; } });
-var event_check_grouped_completion_1 = require("./event-check-grouped-completion");
-Object.defineProperty(exports, "EventCheckGroupedCompletionTool", { enumerable: true, get: function () { return event_check_grouped_completion_1.EventCheckGroupedCompletionTool; } });
-var event_on_grouped_completion_1 = require("./event-on-grouped-completion");
-Object.defineProperty(exports, "EventOnGroupedCompletionTool", { enumerable: true, get: function () { return event_on_grouped_completion_1.EventOnGroupedCompletionTool; } });
-var event_check_agent_event_1 = require("./event-check-agent-event");
-Object.defineProperty(exports, "EventCheckAgentEventTool", { enumerable: true, get: function () { return event_check_agent_event_1.EventCheckAgentEventTool; } });
-var event_on_agent_event_1 = require("./event-on-agent-event");
-Object.defineProperty(exports, "EventOnAgentEventTool", { enumerable: true, get: function () { return event_on_agent_event_1.EventOnAgentEventTool; } });
-var event_wait_any_1 = require("./event-wait-any");
-Object.defineProperty(exports, "EventWaitAnyTool", { enumerable: true, get: function () { return event_wait_any_1.EventWaitAnyTool; } });
-// Create instances for convenience
-const event_add_running_agent_2 = require("./event-add-running-agent");
-const event_get_running_count_2 = require("./event-get-running-count");
-const event_check_completion_2 = require("./event-check-completion");
-const event_on_completion_2 = require("./event-on-completion");
-const event_check_grouped_completion_2 = require("./event-check-grouped-completion");
-const event_on_grouped_completion_2 = require("./event-on-grouped-completion");
-const event_check_agent_event_2 = require("./event-check-agent-event");
-const event_on_agent_event_2 = require("./event-on-agent-event");
-const event_wait_any_2 = require("./event-wait-any");
-/**
- * All event tools
- */
-exports.eventTools = [
-    new event_add_running_agent_2.EventAddRunningAgentTool(),
-    new event_get_running_count_2.EventGetRunningCountTool(),
-    new event_check_completion_2.EventCheckCompletionTool(),
-    new event_on_completion_2.EventOnCompletionTool(),
-    new event_check_grouped_completion_2.EventCheckGroupedCompletionTool(),
-    new event_on_grouped_completion_2.EventOnGroupedCompletionTool(),
-    new event_check_agent_event_2.EventCheckAgentEventTool(),
-    new event_on_agent_event_2.EventOnAgentEventTool(),
-    new event_wait_any_2.EventWaitAnyTool(),
-];

package/dist/tools/git/git-action.d.ts

@@ -1,48 +0,0 @@
-/**
- * Git Action Tool - Performs various Git operations
- * Wraps the SDK's gitService methods
- */
-import type { ToolInvocation, ToolResult } from '../types';
-import { BaseDeclarativeTool } from '../base-tool';
-/**
- * Supported Git actions
- */
-export type GitActionType = 'init' | 'status' | 'add' | 'commit' | 'push' | 'pull' | 'checkout' | 'branch' | 'logs' | 'diff' | 'clone';
-/**
- * Parameters for the GitAction tool
- */
-export interface GitActionToolParams {
-    /**
-     * The Git action to perform
-     */
-    action: GitActionType;
-    /**
-     * Path for init/logs/clone operations
-     */
-    path?: string;
-    /**
-     * Commit message for commit operation
-     */
-    message?: string;
-    /**
-     * Branch name for checkout/branch operations
-     */
-    branch?: string;
-    /**
-     * Commit hash for diff operation
-     */
-    commit_hash?: string;
-    /**
-     * Repository URL for clone operation
-     */
-    url?: string;
-}
-/**
- * Implementation of the GitAction tool logic
- */
-export declare class GitActionTool extends BaseDeclarativeTool<GitActionToolParams, ToolResult> {
-    static readonly Name: string;
-    constructor();
-    protected validateToolParamValues(params: GitActionToolParams): string | null;
-    protected createInvocation(params: GitActionToolParams): ToolInvocation<GitActionToolParams, ToolResult>;
-}

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;
-}