@codebolt/codeboltjs 5.0.2 → 5.0.4

package/dist/tools/fs/fs-list-code-definitions.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsListCodeDefinitionsTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsListCodeDefinitionsInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.listCodeDefinitionNames(this.params.path);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to list code definitions'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to list code definitions'}`,
+                    error: { message: response.message || 'Failed to list code definitions', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const definitions = response.definitions || [];
+            return {
+                llmContent: `Found ${definitions.length} code definition(s) in ${this.params.path}`,
+                returnDisplay: JSON.stringify(definitions, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class FsListCodeDefinitionsTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_list_code_definitions', 'List Code Definitions', 'List all code definition names in a given path', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to search for code definitions' },
+            },
+            required: ['path'],
+        });
+    }
+    createInvocation(params) {
+        return new FsListCodeDefinitionsInvocation(params);
+    }
+}
+exports.FsListCodeDefinitionsTool = FsListCodeDefinitionsTool;

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

@@ -0,0 +1,14 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FsListDirectoryParams {
+    path: string;
+    ignore?: string[];
+    show_hidden?: boolean;
+    detailed?: boolean;
+    limit?: number;
+    notifyUser?: boolean;
+}
+export declare class FsListDirectoryTool extends BaseDeclarativeTool<FsListDirectoryParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: FsListDirectoryParams): ToolInvocation<FsListDirectoryParams, ToolResult>;
+}

package/dist/tools/fs/fs-list-directory.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsListDirectoryTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsListDirectoryInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.listDirectory(this.params);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to list directory'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to list directory'}`,
+                    error: { message: response.message || 'Failed to list directory', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const entries = response.entries || [];
+            return {
+                llmContent: `Found ${entries.length} entr${entries.length === 1 ? 'y' : 'ies'} in ${this.params.path}`,
+                returnDisplay: JSON.stringify(entries, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class FsListDirectoryTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_list_directory', 'List Directory', 'List directory contents using advanced directory listing', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to the directory to list' },
+                ignore: { type: 'array', items: { type: 'string' }, description: 'Array of glob patterns for files/directories to ignore' },
+                show_hidden: { type: 'boolean', description: 'Whether to show hidden files and directories' },
+                detailed: { type: 'boolean', description: 'Whether to include detailed information' },
+                limit: { type: 'number', description: 'Maximum number of entries to return' },
+                notifyUser: { type: 'boolean', description: 'Whether to notify the user about the operation' },
+            },
+            required: ['path'],
+        });
+    }
+    createInvocation(params) {
+        return new FsListDirectoryInvocation(params);
+    }
+}
+exports.FsListDirectoryTool = FsListDirectoryTool;

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

@@ -0,0 +1,10 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FsListFileParams {
+    folderPath: string;
+    isRecursive?: boolean;
+}
+export declare class FsListFileTool extends BaseDeclarativeTool<FsListFileParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: FsListFileParams): ToolInvocation<FsListFileParams, ToolResult>;
+}

package/dist/tools/fs/fs-list-file.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsListFileTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsListFileInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.listFile(this.params.folderPath, this.params.isRecursive || false);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to list files'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to list files'}`,
+                    error: { message: response.message || 'Failed to list files', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const files = response.files || [];
+            return {
+                llmContent: `Found ${files.length} file(s) in ${this.params.folderPath}`,
+                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 FsListFileTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_list_file', 'List Files', 'List files in a directory', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                folderPath: { type: 'string', description: 'Path to list files from' },
+                isRecursive: { type: 'boolean', description: 'Whether to list files recursively' },
+            },
+            required: ['folderPath'],
+        });
+    }
+    createInvocation(params) {
+        return new FsListFileInvocation(params);
+    }
+}
+exports.FsListFileTool = FsListFileTool;

package/dist/tools/fs/fs-read-file.d.ts

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

package/dist/tools/fs/fs-read-file.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsReadFileTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsReadFileInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.readFile(this.params.filePath);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to read file'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to read file'}`,
+                    error: { message: response.message || 'Failed to read file', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `File read successfully`,
+                returnDisplay: response.content || '',
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class FsReadFileTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_read_file', 'Read File', 'Read the content of a file', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Path of the file to read' },
+            },
+            required: ['filePath'],
+        });
+    }
+    createInvocation(params) {
+        return new FsReadFileInvocation(params);
+    }
+}
+exports.FsReadFileTool = FsReadFileTool;

package/dist/tools/fs/fs-read-many-files.d.ts

@@ -0,0 +1,18 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FsReadManyFilesParams {
+    paths: string[];
+    include?: string[];
+    exclude?: string[];
+    recursive?: boolean;
+    use_default_excludes?: boolean;
+    max_files?: number;
+    max_total_size?: number;
+    include_metadata?: boolean;
+    separator_format?: string;
+    notifyUser?: boolean;
+}
+export declare class FsReadManyFilesTool extends BaseDeclarativeTool<FsReadManyFilesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: FsReadManyFilesParams): ToolInvocation<FsReadManyFilesParams, ToolResult>;
+}

package/dist/tools/fs/fs-read-many-files.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsReadManyFilesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsReadManyFilesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.readManyFiles(this.params);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to read files'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to read files'}`,
+                    error: { message: response.message || 'Failed to read files', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const results = response.results || [];
+            const filesRead = results.length;
+            const content = results.map(r => `--- ${r.path} ---\n${r.content || r.error || ''}`).join('\n\n');
+            return {
+                llmContent: `Successfully read ${filesRead} file(s)`,
+                returnDisplay: content,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class FsReadManyFilesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_read_many_files', 'Read Many Files', 'Read multiple files based on paths, patterns, or glob expressions', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                paths: { type: 'array', items: { type: 'string' }, description: 'Array of file paths, directory paths, or glob patterns' },
+                include: { type: 'array', items: { type: 'string' }, description: 'Glob patterns for files to include' },
+                exclude: { type: 'array', items: { type: 'string' }, description: 'Glob patterns for files/directories to exclude' },
+                recursive: { type: 'boolean', description: 'Whether to search recursively through subdirectories' },
+                use_default_excludes: { type: 'boolean', description: 'Whether to use default exclusion patterns' },
+                max_files: { type: 'number', description: 'Maximum number of files to read' },
+                max_total_size: { type: 'number', description: 'Maximum total size of content to read (in bytes)' },
+                include_metadata: { type: 'boolean', description: 'Whether to include file metadata in output' },
+                separator_format: { type: 'string', description: 'Custom separator format for file content' },
+                notifyUser: { type: 'boolean', description: 'Whether to notify the user about the operation' },
+            },
+            required: ['paths'],
+        });
+    }
+    createInvocation(params) {
+        return new FsReadManyFilesInvocation(params);
+    }
+}
+exports.FsReadManyFilesTool = FsReadManyFilesTool;

package/dist/tools/fs/fs-search-files.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FsSearchFilesParams {
+    path: string;
+    regex: string;
+    filePattern: string;
+}
+export declare class FsSearchFilesTool extends BaseDeclarativeTool<FsSearchFilesParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: FsSearchFilesParams): ToolInvocation<FsSearchFilesParams, ToolResult>;
+}

package/dist/tools/fs/fs-search-files.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsSearchFilesTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsSearchFilesInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.searchFiles(this.params.path, this.params.regex, this.params.filePattern);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to search files'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to search files'}`,
+                    error: { message: response.message || 'Failed to search files', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            const results = response.results || [];
+            const totalMatches = results.reduce((sum, r) => { var _a; return sum + (((_a = r.matches) === null || _a === void 0 ? void 0 : _a.length) || 0); }, 0);
+            return {
+                llmContent: `Found ${totalMatches} match(es) in ${results.length} file(s)`,
+                returnDisplay: JSON.stringify(results, null, 2),
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class FsSearchFilesTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_search_files', 'Search Files', 'Search files using regex pattern', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Path to search within' },
+                regex: { type: 'string', description: 'Regex pattern to search for' },
+                filePattern: { type: 'string', description: 'File pattern to match files' },
+            },
+            required: ['path', 'regex', 'filePattern'],
+        });
+    }
+    createInvocation(params) {
+        return new FsSearchFilesInvocation(params);
+    }
+}
+exports.FsSearchFilesTool = FsSearchFilesTool;

package/dist/tools/fs/fs-update-file.d.ts

@@ -0,0 +1,11 @@
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+export interface FsUpdateFileParams {
+    filename: string;
+    filePath: string;
+    newContent: string;
+}
+export declare class FsUpdateFileTool extends BaseDeclarativeTool<FsUpdateFileParams, ToolResult> {
+    constructor();
+    protected createInvocation(params: FsUpdateFileParams): ToolInvocation<FsUpdateFileParams, ToolResult>;
+}

package/dist/tools/fs/fs-update-file.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsUpdateFileTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const fs_1 = __importDefault(require("../../modules/fs"));
+class FsUpdateFileInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute(_signal) {
+        try {
+            const response = await fs_1.default.updateFile(this.params.filename, this.params.filePath, this.params.newContent);
+            if (!response.success) {
+                return {
+                    llmContent: `Error: ${response.message || 'Failed to update file'}`,
+                    returnDisplay: `Error: ${response.message || 'Failed to update file'}`,
+                    error: { message: response.message || 'Failed to update file', type: types_1.ToolErrorType.EXECUTION_FAILED },
+                };
+            }
+            return {
+                llmContent: `File "${this.params.filename}" updated successfully`,
+                returnDisplay: `Updated file: ${this.params.filename}`,
+            };
+        }
+        catch (error) {
+            return {
+                llmContent: `Error: ${error}`,
+                returnDisplay: `Error: ${error}`,
+                error: { message: String(error), type: types_1.ToolErrorType.EXECUTION_FAILED },
+            };
+        }
+    }
+}
+class FsUpdateFileTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super('fs_update_file', 'Update File', 'Update the content of a file', types_1.Kind.FileSystem, {
+            type: 'object',
+            properties: {
+                filename: { type: 'string', description: 'Name of the file to update' },
+                filePath: { type: 'string', description: 'Path of the file to update' },
+                newContent: { type: 'string', description: 'New content to write into the file' },
+            },
+            required: ['filename', 'filePath', 'newContent'],
+        });
+    }
+    createInvocation(params) {
+        return new FsUpdateFileInvocation(params);
+    }
+}
+exports.FsUpdateFileTool = FsUpdateFileTool;

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

@@ -0,0 +1,35 @@
+/**
+ * File System Tools
+ *
+ * Tools for file system operations including file/folder management, search, and listing.
+ */
+export { FsCreateFileTool } from './fs-create-file';
+export { FsCreateFolderTool } from './fs-create-folder';
+export { FsReadFileTool } from './fs-read-file';
+export { FsUpdateFileTool } from './fs-update-file';
+export { FsDeleteFileTool } from './fs-delete-file';
+export { FsDeleteFolderTool } from './fs-delete-folder';
+export { FsListFileTool } from './fs-list-file';
+export { FsGrepSearchTool } from './fs-grep-search';
+export { FsFileSearchTool } from './fs-file-search';
+export { FsSearchFilesTool } from './fs-search-files';
+export { FsReadManyFilesTool } from './fs-read-many-files';
+export { FsListDirectoryTool } from './fs-list-directory';
+export { FsListCodeDefinitionsTool } from './fs-list-code-definitions';
+import { FsCreateFileTool } from './fs-create-file';
+import { FsCreateFolderTool } from './fs-create-folder';
+import { FsReadFileTool } from './fs-read-file';
+import { FsUpdateFileTool } from './fs-update-file';
+import { FsDeleteFileTool } from './fs-delete-file';
+import { FsDeleteFolderTool } from './fs-delete-folder';
+import { FsListFileTool } from './fs-list-file';
+import { FsGrepSearchTool } from './fs-grep-search';
+import { FsFileSearchTool } from './fs-file-search';
+import { FsSearchFilesTool } from './fs-search-files';
+import { FsReadManyFilesTool } from './fs-read-many-files';
+import { FsListDirectoryTool } from './fs-list-directory';
+import { FsListCodeDefinitionsTool } from './fs-list-code-definitions';
+/**
+ * Array of all file system tools
+ */
+export declare const fsTools: (FsCreateFileTool | FsCreateFolderTool | FsReadFileTool | FsUpdateFileTool | FsDeleteFileTool | FsDeleteFolderTool | FsListFileTool | FsGrepSearchTool | FsFileSearchTool | FsSearchFilesTool | FsReadManyFilesTool | FsListDirectoryTool | FsListCodeDefinitionsTool)[];

package/dist/tools/fs/index.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * File System Tools
+ *
+ * Tools for file system operations including file/folder management, search, and listing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsTools = exports.FsListCodeDefinitionsTool = exports.FsListDirectoryTool = exports.FsReadManyFilesTool = exports.FsSearchFilesTool = exports.FsFileSearchTool = exports.FsGrepSearchTool = exports.FsListFileTool = exports.FsDeleteFolderTool = exports.FsDeleteFileTool = exports.FsUpdateFileTool = exports.FsReadFileTool = exports.FsCreateFolderTool = exports.FsCreateFileTool = void 0;
+var fs_create_file_1 = require("./fs-create-file");
+Object.defineProperty(exports, "FsCreateFileTool", { enumerable: true, get: function () { return fs_create_file_1.FsCreateFileTool; } });
+var fs_create_folder_1 = require("./fs-create-folder");
+Object.defineProperty(exports, "FsCreateFolderTool", { enumerable: true, get: function () { return fs_create_folder_1.FsCreateFolderTool; } });
+var fs_read_file_1 = require("./fs-read-file");
+Object.defineProperty(exports, "FsReadFileTool", { enumerable: true, get: function () { return fs_read_file_1.FsReadFileTool; } });
+var fs_update_file_1 = require("./fs-update-file");
+Object.defineProperty(exports, "FsUpdateFileTool", { enumerable: true, get: function () { return fs_update_file_1.FsUpdateFileTool; } });
+var fs_delete_file_1 = require("./fs-delete-file");
+Object.defineProperty(exports, "FsDeleteFileTool", { enumerable: true, get: function () { return fs_delete_file_1.FsDeleteFileTool; } });
+var fs_delete_folder_1 = require("./fs-delete-folder");
+Object.defineProperty(exports, "FsDeleteFolderTool", { enumerable: true, get: function () { return fs_delete_folder_1.FsDeleteFolderTool; } });
+var fs_list_file_1 = require("./fs-list-file");
+Object.defineProperty(exports, "FsListFileTool", { enumerable: true, get: function () { return fs_list_file_1.FsListFileTool; } });
+var fs_grep_search_1 = require("./fs-grep-search");
+Object.defineProperty(exports, "FsGrepSearchTool", { enumerable: true, get: function () { return fs_grep_search_1.FsGrepSearchTool; } });
+var fs_file_search_1 = require("./fs-file-search");
+Object.defineProperty(exports, "FsFileSearchTool", { enumerable: true, get: function () { return fs_file_search_1.FsFileSearchTool; } });
+var fs_search_files_1 = require("./fs-search-files");
+Object.defineProperty(exports, "FsSearchFilesTool", { enumerable: true, get: function () { return fs_search_files_1.FsSearchFilesTool; } });
+var fs_read_many_files_1 = require("./fs-read-many-files");
+Object.defineProperty(exports, "FsReadManyFilesTool", { enumerable: true, get: function () { return fs_read_many_files_1.FsReadManyFilesTool; } });
+var fs_list_directory_1 = require("./fs-list-directory");
+Object.defineProperty(exports, "FsListDirectoryTool", { enumerable: true, get: function () { return fs_list_directory_1.FsListDirectoryTool; } });
+var fs_list_code_definitions_1 = require("./fs-list-code-definitions");
+Object.defineProperty(exports, "FsListCodeDefinitionsTool", { enumerable: true, get: function () { return fs_list_code_definitions_1.FsListCodeDefinitionsTool; } });
+const fs_create_file_2 = require("./fs-create-file");
+const fs_create_folder_2 = require("./fs-create-folder");
+const fs_read_file_2 = require("./fs-read-file");
+const fs_update_file_2 = require("./fs-update-file");
+const fs_delete_file_2 = require("./fs-delete-file");
+const fs_delete_folder_2 = require("./fs-delete-folder");
+const fs_list_file_2 = require("./fs-list-file");
+const fs_grep_search_2 = require("./fs-grep-search");
+const fs_file_search_2 = require("./fs-file-search");
+const fs_search_files_2 = require("./fs-search-files");
+const fs_read_many_files_2 = require("./fs-read-many-files");
+const fs_list_directory_2 = require("./fs-list-directory");
+const fs_list_code_definitions_2 = require("./fs-list-code-definitions");
+/**
+ * Array of all file system tools
+ */
+exports.fsTools = [
+    new fs_create_file_2.FsCreateFileTool(),
+    new fs_create_folder_2.FsCreateFolderTool(),
+    new fs_read_file_2.FsReadFileTool(),
+    new fs_update_file_2.FsUpdateFileTool(),
+    new fs_delete_file_2.FsDeleteFileTool(),
+    new fs_delete_folder_2.FsDeleteFolderTool(),
+    new fs_list_file_2.FsListFileTool(),
+    new fs_grep_search_2.FsGrepSearchTool(),
+    new fs_file_search_2.FsFileSearchTool(),
+    new fs_search_files_2.FsSearchFilesTool(),
+    new fs_read_many_files_2.FsReadManyFilesTool(),
+    new fs_list_directory_2.FsListDirectoryTool(),
+    new fs_list_code_definitions_2.FsListCodeDefinitionsTool(),
+];

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

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