@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/userMessageUtilities/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * User Message Utilities Tools
+ *
+ * Tools for accessing current user message and context using utilities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.userMessageUtilitiesTools = exports.UserUtilitiesGetSelectionTool = exports.UserUtilitiesGetCurrentFileTool = exports.UserUtilitiesGetMentionedFilesTool = exports.UserUtilitiesGetMentionedMCPsTool = exports.UserUtilitiesGetTextTool = exports.UserUtilitiesGetCurrentTool = void 0;
+var user_utilities_get_current_1 = require("./user-utilities-get-current");
+Object.defineProperty(exports, "UserUtilitiesGetCurrentTool", { enumerable: true, get: function () { return user_utilities_get_current_1.UserUtilitiesGetCurrentTool; } });
+var user_utilities_get_text_1 = require("./user-utilities-get-text");
+Object.defineProperty(exports, "UserUtilitiesGetTextTool", { enumerable: true, get: function () { return user_utilities_get_text_1.UserUtilitiesGetTextTool; } });
+var user_utilities_get_mentioned_mcps_1 = require("./user-utilities-get-mentioned-mcps");
+Object.defineProperty(exports, "UserUtilitiesGetMentionedMCPsTool", { enumerable: true, get: function () { return user_utilities_get_mentioned_mcps_1.UserUtilitiesGetMentionedMCPsTool; } });
+var user_utilities_get_mentioned_files_1 = require("./user-utilities-get-mentioned-files");
+Object.defineProperty(exports, "UserUtilitiesGetMentionedFilesTool", { enumerable: true, get: function () { return user_utilities_get_mentioned_files_1.UserUtilitiesGetMentionedFilesTool; } });
+var user_utilities_get_current_file_1 = require("./user-utilities-get-current-file");
+Object.defineProperty(exports, "UserUtilitiesGetCurrentFileTool", { enumerable: true, get: function () { return user_utilities_get_current_file_1.UserUtilitiesGetCurrentFileTool; } });
+var user_utilities_get_selection_1 = require("./user-utilities-get-selection");
+Object.defineProperty(exports, "UserUtilitiesGetSelectionTool", { enumerable: true, get: function () { return user_utilities_get_selection_1.UserUtilitiesGetSelectionTool; } });
+const user_utilities_get_current_2 = require("./user-utilities-get-current");
+const user_utilities_get_text_2 = require("./user-utilities-get-text");
+const user_utilities_get_mentioned_mcps_2 = require("./user-utilities-get-mentioned-mcps");
+const user_utilities_get_mentioned_files_2 = require("./user-utilities-get-mentioned-files");
+const user_utilities_get_current_file_2 = require("./user-utilities-get-current-file");
+const user_utilities_get_selection_2 = require("./user-utilities-get-selection");
+/**
+ * Array of all user message utilities tools
+ */
+exports.userMessageUtilitiesTools = [
+    new user_utilities_get_current_2.UserUtilitiesGetCurrentTool(),
+    new user_utilities_get_text_2.UserUtilitiesGetTextTool(),
+    new user_utilities_get_mentioned_mcps_2.UserUtilitiesGetMentionedMCPsTool(),
+    new user_utilities_get_mentioned_files_2.UserUtilitiesGetMentionedFilesTool(),
+    new user_utilities_get_current_file_2.UserUtilitiesGetCurrentFileTool(),
+    new user_utilities_get_selection_2.UserUtilitiesGetSelectionTool(),
+];

package/dist/tools/userMessageUtilities/user-utilities-get-current-file.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UserUtilitiesGetCurrentFileParams {
+}
+export declare class UserUtilitiesGetCurrentFileTool extends BaseDeclarativeTool<UserUtilitiesGetCurrentFileParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UserUtilitiesGetCurrentFileParams): ToolInvocation<UserUtilitiesGetCurrentFileParams, ToolResult>;
+}

package/dist/tools/userMessageUtilities/user-utilities-get-current-file.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtilitiesGetCurrentFileTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const user_message_utilities_1 = require("../../modules/user-message-utilities");
+class UserUtilitiesGetCurrentFileInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const currentFile = user_message_utilities_1.userMessageUtilities.getCurrentFile();
+            if (!currentFile) {
+                return {
+                    llmContent: 'No current file available',
+                    returnDisplay: 'No current file',
+                };
+            }
+            return {
+                llmContent: `Current file: ${currentFile}`,
+                returnDisplay: currentFile,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class UserUtilitiesGetCurrentFileTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('user_utilities_get_current_file', 'Get Current File', 'Get current file path from user message', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+        });
+    }
+    createInvocation(params) {
+        return new UserUtilitiesGetCurrentFileInvocation(params);
+    }
+}
+exports.UserUtilitiesGetCurrentFileTool = UserUtilitiesGetCurrentFileTool;

package/dist/tools/userMessageUtilities/user-utilities-get-current.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UserUtilitiesGetCurrentParams {
+}
+export declare class UserUtilitiesGetCurrentTool extends BaseDeclarativeTool<UserUtilitiesGetCurrentParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UserUtilitiesGetCurrentParams): ToolInvocation<UserUtilitiesGetCurrentParams, ToolResult>;
+}

package/dist/tools/userMessageUtilities/user-utilities-get-current.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtilitiesGetCurrentTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const user_message_utilities_1 = require("../../modules/user-message-utilities");
+class UserUtilitiesGetCurrentInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const message = user_message_utilities_1.userMessageUtilities.getCurrent();
+            if (!message) {
+                return {
+                    llmContent: 'No current user message available',
+                    returnDisplay: 'No current user message',
+                };
+            }
+            return {
+                llmContent: `Current user message retrieved`,
+                returnDisplay: JSON.stringify(message, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class UserUtilitiesGetCurrentTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('user_utilities_get_current', 'Get Current User Message (Utilities)', 'Get the current user message object using utilities', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+        });
+    }
+    createInvocation(params) {
+        return new UserUtilitiesGetCurrentInvocation(params);
+    }
+}
+exports.UserUtilitiesGetCurrentTool = UserUtilitiesGetCurrentTool;

package/dist/tools/userMessageUtilities/user-utilities-get-mentioned-files.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UserUtilitiesGetMentionedFilesParams {
+}
+export declare class UserUtilitiesGetMentionedFilesTool extends BaseDeclarativeTool<UserUtilitiesGetMentionedFilesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UserUtilitiesGetMentionedFilesParams): ToolInvocation<UserUtilitiesGetMentionedFilesParams, ToolResult>;
+}

package/dist/tools/userMessageUtilities/user-utilities-get-mentioned-files.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtilitiesGetMentionedFilesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const user_message_utilities_1 = require("../../modules/user-message-utilities");
+class UserUtilitiesGetMentionedFilesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const files = user_message_utilities_1.userMessageUtilities.getMentionedFiles();
+            return {
+                llmContent: `Found ${files.length} mentioned file(s)`,
+                returnDisplay: JSON.stringify(files, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class UserUtilitiesGetMentionedFilesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('user_utilities_get_mentioned_files', 'Get Mentioned Files (Utilities)', 'Get mentioned files from current user message using utilities', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+        });
+    }
+    createInvocation(params) {
+        return new UserUtilitiesGetMentionedFilesInvocation(params);
+    }
+}
+exports.UserUtilitiesGetMentionedFilesTool = UserUtilitiesGetMentionedFilesTool;

package/dist/tools/userMessageUtilities/user-utilities-get-mentioned-mcps.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UserUtilitiesGetMentionedMCPsParams {
+}
+export declare class UserUtilitiesGetMentionedMCPsTool extends BaseDeclarativeTool<UserUtilitiesGetMentionedMCPsParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UserUtilitiesGetMentionedMCPsParams): ToolInvocation<UserUtilitiesGetMentionedMCPsParams, ToolResult>;
+}

package/dist/tools/userMessageUtilities/user-utilities-get-mentioned-mcps.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtilitiesGetMentionedMCPsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const user_message_utilities_1 = require("../../modules/user-message-utilities");
+class UserUtilitiesGetMentionedMCPsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const mcps = user_message_utilities_1.userMessageUtilities.getMentionedMCPs();
+            return {
+                llmContent: `Found ${mcps.length} mentioned MCP(s)`,
+                returnDisplay: JSON.stringify(mcps, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class UserUtilitiesGetMentionedMCPsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('user_utilities_get_mentioned_mcps', 'Get Mentioned MCPs', 'Get mentioned MCPs from current user message', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+        });
+    }
+    createInvocation(params) {
+        return new UserUtilitiesGetMentionedMCPsInvocation(params);
+    }
+}
+exports.UserUtilitiesGetMentionedMCPsTool = UserUtilitiesGetMentionedMCPsTool;

package/dist/tools/userMessageUtilities/user-utilities-get-selection.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UserUtilitiesGetSelectionParams {
+}
+export declare class UserUtilitiesGetSelectionTool extends BaseDeclarativeTool<UserUtilitiesGetSelectionParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UserUtilitiesGetSelectionParams): ToolInvocation<UserUtilitiesGetSelectionParams, ToolResult>;
+}

package/dist/tools/userMessageUtilities/user-utilities-get-selection.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtilitiesGetSelectionTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const user_message_utilities_1 = require("../../modules/user-message-utilities");
+class UserUtilitiesGetSelectionInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const selection = user_message_utilities_1.userMessageUtilities.getSelection();
+            if (!selection) {
+                return {
+                    llmContent: 'No text selection available',
+                    returnDisplay: 'No text selection',
+                };
+            }
+            return {
+                llmContent: `Text selection retrieved`,
+                returnDisplay: selection,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class UserUtilitiesGetSelectionTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('user_utilities_get_selection', 'Get Text Selection', 'Get text selection from current user message', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+        });
+    }
+    createInvocation(params) {
+        return new UserUtilitiesGetSelectionInvocation(params);
+    }
+}
+exports.UserUtilitiesGetSelectionTool = UserUtilitiesGetSelectionTool;

package/dist/tools/userMessageUtilities/user-utilities-get-text.d.ts

@@ -0,0 +1,8 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UserUtilitiesGetTextParams {
+}
+export declare class UserUtilitiesGetTextTool extends BaseDeclarativeTool<UserUtilitiesGetTextParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UserUtilitiesGetTextParams): ToolInvocation<UserUtilitiesGetTextParams, ToolResult>;
+}

package/dist/tools/userMessageUtilities/user-utilities-get-text.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserUtilitiesGetTextTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const user_message_utilities_1 = require("../../modules/user-message-utilities");
+class UserUtilitiesGetTextInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const text = user_message_utilities_1.userMessageUtilities.getText();
+            return {
+                llmContent: `User message text: ${text}`,
+                returnDisplay: text,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class UserUtilitiesGetTextTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('user_utilities_get_text', 'Get User Message Text (Utilities)', 'Get the user message text content using utilities', types_1.Kind.Other, {
+            type: 'object',
+            properties: {},
+        });
+    }
+    createInvocation(params) {
+        return new UserUtilitiesGetTextInvocation(params);
+    }
+}
+exports.UserUtilitiesGetTextTool = UserUtilitiesGetTextTool;

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

@@ -0,0 +1,11 @@
+/**
+ * Utils Tools
+ *
+ * Utility tools for CodeBolt operations.
+ */
+export { UtilsEditFileAndApplyDiffTool } from './utils-edit-file-and-apply-diff';
+import { UtilsEditFileAndApplyDiffTool } from './utils-edit-file-and-apply-diff';
+/**
+ * Array of all utils tools
+ */
+export declare const utilsTools: UtilsEditFileAndApplyDiffTool[];

package/dist/tools/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Utils Tools
+ *
+ * Utility tools for CodeBolt operations.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utilsTools = exports.UtilsEditFileAndApplyDiffTool = void 0;
+var utils_edit_file_and_apply_diff_1 = require("./utils-edit-file-and-apply-diff");
+Object.defineProperty(exports, "UtilsEditFileAndApplyDiffTool", { enumerable: true, get: function () { return utils_edit_file_and_apply_diff_1.UtilsEditFileAndApplyDiffTool; } });
+const utils_edit_file_and_apply_diff_2 = require("./utils-edit-file-and-apply-diff");
+/**
+ * Array of all utils tools
+ */
+exports.utilsTools = [
+    new utils_edit_file_and_apply_diff_2.UtilsEditFileAndApplyDiffTool(),
+];

package/dist/tools/utils/paths.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Path utilities for tool operations
+ */
+/**
+ * Shortens a file path for display purposes
+ * @param filePath - The full file path
+ * @param maxLength - Maximum length of the output (default: 50)
+ * @returns Shortened path for display
+ */
+export declare function shortenPath(filePath: string, maxLength?: number): string;
+/**
+ * Makes a path relative to a base directory
+ * @param filePath - The absolute file path
+ * @param basePath - The base directory path
+ * @returns Relative path from base to file
+ */
+export declare function makeRelative(filePath: string, basePath: string): string;
+/**
+ * Ensures a path is absolute
+ * @param filePath - The file path (may be relative)
+ * @param basePath - The base directory for relative paths
+ * @returns Absolute path
+ */
+export declare function ensureAbsolute(filePath: string, basePath: string): string;
+/**
+ * Normalizes a path (resolves . and ..)
+ * @param filePath - The file path to normalize
+ * @returns Normalized path
+ */
+export declare function normalizePath(filePath: string): string;
+/**
+ * Gets the file extension without the leading dot
+ * @param filePath - The file path
+ * @returns File extension (e.g., 'ts', 'js', 'json')
+ */
+export declare function getExtension(filePath: string): string;

package/dist/tools/utils/paths.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Path utilities for tool operations
+ */
+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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shortenPath = shortenPath;
+exports.makeRelative = makeRelative;
+exports.ensureAbsolute = ensureAbsolute;
+exports.normalizePath = normalizePath;
+exports.getExtension = getExtension;
+const path = __importStar(require("path"));
+/**
+ * Shortens a file path for display purposes
+ * @param filePath - The full file path
+ * @param maxLength - Maximum length of the output (default: 50)
+ * @returns Shortened path for display
+ */
+function shortenPath(filePath, maxLength = 50) {
+    if (filePath.length <= maxLength) {
+        return filePath;
+    }
+    const fileName = path.basename(filePath);
+    const dirPath = path.dirname(filePath);
+    // If just the filename is too long, truncate it
+    if (fileName.length >= maxLength - 3) {
+        return '...' + fileName.slice(-(maxLength - 3));
+    }
+    // Split the directory path into parts
+    const parts = dirPath.split(path.sep).filter(Boolean);
+    // Start with the filename and work backwards
+    let result = fileName;
+    let currentLength = fileName.length;
+    // Add directory parts from the end until we exceed maxLength
+    for (let i = parts.length - 1; i >= 0; i--) {
+        const partWithSep = path.sep + parts[i];
+        if (currentLength + partWithSep.length + 3 <= maxLength) {
+            result = parts[i] + path.sep + result;
+            currentLength += partWithSep.length;
+        }
+        else {
+            result = '...' + path.sep + result;
+            break;
+        }
+    }
+    return result;
+}
+/**
+ * Makes a path relative to a base directory
+ * @param filePath - The absolute file path
+ * @param basePath - The base directory path
+ * @returns Relative path from base to file
+ */
+function makeRelative(filePath, basePath) {
+    return path.relative(basePath, filePath);
+}
+/**
+ * Ensures a path is absolute
+ * @param filePath - The file path (may be relative)
+ * @param basePath - The base directory for relative paths
+ * @returns Absolute path
+ */
+function ensureAbsolute(filePath, basePath) {
+    if (path.isAbsolute(filePath)) {
+        return filePath;
+    }
+    return path.resolve(basePath, filePath);
+}
+/**
+ * Normalizes a path (resolves . and ..)
+ * @param filePath - The file path to normalize
+ * @returns Normalized path
+ */
+function normalizePath(filePath) {
+    return path.normalize(filePath);
+}
+/**
+ * Gets the file extension without the leading dot
+ * @param filePath - The file path
+ * @returns File extension (e.g., 'ts', 'js', 'json')
+ */
+function getExtension(filePath) {
+    const ext = path.extname(filePath);
+    return ext.startsWith('.') ? ext.slice(1) : ext;
+}

package/dist/tools/utils/schema-validator.d.ts

@@ -0,0 +1,9 @@
+/**
+ * JSON Schema validation utilities for tool parameters
+ */
+/**
+ * Simple JSON Schema validator
+ */
+export declare class SchemaValidator {
+    static validate(schema: unknown, data: unknown): string | null;
+}

package/dist/tools/utils/schema-validator.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * JSON Schema validation utilities for tool parameters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidator = void 0;
+/**
+ * Simple JSON Schema validator
+ */
+class SchemaValidator {
+    static validate(schema, data) {
+        if (!schema || typeof schema !== 'object') {
+            return null; // No schema to validate against
+        }
+        const s = schema;
+        // Check required fields
+        if (s.required && Array.isArray(s.required)) {
+            for (const field of s.required) {
+                if (typeof field === 'string') {
+                    if (!data || typeof data !== 'object' || !(field in data)) {
+                        return `Missing required field: ${field}`;
+                    }
+                }
+            }
+        }
+        // Basic type checking
+        if (s.type && data !== null && data !== undefined) {
+            const expectedType = s.type;
+            const actualType = typeof data;
+            if (expectedType === 'object' && actualType !== 'object') {
+                return `Expected object, got ${actualType}`;
+            }
+            if (expectedType === 'string' && actualType !== 'string') {
+                return `Expected string, got ${actualType}`;
+            }
+            if (expectedType === 'number' && actualType !== 'number') {
+                return `Expected number, got ${actualType}`;
+            }
+            if (expectedType === 'boolean' && actualType !== 'boolean') {
+                return `Expected boolean, got ${actualType}`;
+            }
+            if (expectedType === 'array' && !Array.isArray(data)) {
+                return `Expected array, got ${actualType}`;
+            }
+        }
+        // Validate properties if it's an object
+        if (s.properties && data && typeof data === 'object' && !Array.isArray(data)) {
+            const properties = s.properties;
+            const dataObj = data;
+            for (const [key, propSchema] of Object.entries(properties)) {
+                if (key in dataObj) {
+                    const propError = this.validate(propSchema, dataObj[key]);
+                    if (propError) {
+                        return `Property '${key}': ${propError}`;
+                    }
+                }
+            }
+        }
+        // Validate array items
+        if (s.items && Array.isArray(data)) {
+            for (let i = 0; i < data.length; i++) {
+                const itemError = this.validate(s.items, data[i]);
+                if (itemError) {
+                    return `Array item [${i}]: ${itemError}`;
+                }
+            }
+        }
+        // Check enum values
+        if (s.enum && Array.isArray(s.enum)) {
+            if (!s.enum.includes(data)) {
+                return `Value must be one of: ${s.enum.join(', ')}`;
+            }
+        }
+        // Check minimum/maximum for numbers
+        if (typeof data === 'number') {
+            if (typeof s.minimum === 'number' && data < s.minimum) {
+                return `Value must be >= ${s.minimum}`;
+            }
+            if (typeof s.maximum === 'number' && data > s.maximum) {
+                return `Value must be <= ${s.maximum}`;
+            }
+        }
+        // Check minLength/maxLength for strings
+        if (typeof data === 'string') {
+            if (typeof s.minLength === 'number' && data.length < s.minLength) {
+                return `String length must be >= ${s.minLength}`;
+            }
+            if (typeof s.maxLength === 'number' && data.length > s.maxLength) {
+                return `String length must be <= ${s.maxLength}`;
+            }
+        }
+        return null; // Valid
+    }
+}
+exports.SchemaValidator = SchemaValidator;

package/dist/tools/utils/utils-edit-file-and-apply-diff.d.ts

@@ -0,0 +1,13 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface UtilsEditFileAndApplyDiffParams {
+    filePath: string;
+    diff: string;
+    diffIdentifier: string;
+    prompt: string;
+    applyModel?: string;
+}
+export declare class UtilsEditFileAndApplyDiffTool extends BaseDeclarativeTool<UtilsEditFileAndApplyDiffParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: UtilsEditFileAndApplyDiffParams): ToolInvocation<UtilsEditFileAndApplyDiffParams, ToolResult>;
+}