@codebolt/codeboltjs 5.0.2 → 5.0.3

package/dist/tools/projectStructure/index.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Project Structure tools
+ * Tools for managing project structure metadata, packages, routes, dependencies, and more.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.projectStructureTools = exports.UpdateSectionTool = exports.UpdateFrontendFrameworkTool = exports.UpdateDesignGuidelinesTool = exports.UpdateGitTool = exports.DeleteDeploymentTool = exports.UpdateDeploymentTool = exports.AddDeploymentTool = exports.DeleteUiRouteTool = exports.UpdateUiRouteTool = exports.AddUiRouteTool = exports.DeleteCommandTool = exports.UpdateCommandTool = exports.AddCommandTool = exports.DeleteDependencyTool = exports.UpdateDependencyTool = exports.AddDependencyTool = exports.DeleteTableTool = exports.UpdateTableTool = exports.AddTableTool = exports.DeleteRouteTool = exports.UpdateRouteTool = exports.AddRouteTool = exports.DeletePackageTool = exports.UpdatePackageTool = exports.CreatePackageTool = exports.GetPackageTool = exports.GetPackagesTool = exports.UpdateMetadataTool = exports.GetMetadataTool = void 0;
+// Metadata tools
+var ps_get_metadata_1 = require("./ps-get-metadata");
+Object.defineProperty(exports, "GetMetadataTool", { enumerable: true, get: function () { return ps_get_metadata_1.GetMetadataTool; } });
+var ps_update_metadata_1 = require("./ps-update-metadata");
+Object.defineProperty(exports, "UpdateMetadataTool", { enumerable: true, get: function () { return ps_update_metadata_1.UpdateMetadataTool; } });
+// Package tools
+var ps_get_packages_1 = require("./ps-get-packages");
+Object.defineProperty(exports, "GetPackagesTool", { enumerable: true, get: function () { return ps_get_packages_1.GetPackagesTool; } });
+var ps_get_package_1 = require("./ps-get-package");
+Object.defineProperty(exports, "GetPackageTool", { enumerable: true, get: function () { return ps_get_package_1.GetPackageTool; } });
+var ps_create_package_1 = require("./ps-create-package");
+Object.defineProperty(exports, "CreatePackageTool", { enumerable: true, get: function () { return ps_create_package_1.CreatePackageTool; } });
+var ps_update_package_1 = require("./ps-update-package");
+Object.defineProperty(exports, "UpdatePackageTool", { enumerable: true, get: function () { return ps_update_package_1.UpdatePackageTool; } });
+var ps_delete_package_1 = require("./ps-delete-package");
+Object.defineProperty(exports, "DeletePackageTool", { enumerable: true, get: function () { return ps_delete_package_1.DeletePackageTool; } });
+// API Route tools
+var ps_add_route_1 = require("./ps-add-route");
+Object.defineProperty(exports, "AddRouteTool", { enumerable: true, get: function () { return ps_add_route_1.AddRouteTool; } });
+var ps_update_route_1 = require("./ps-update-route");
+Object.defineProperty(exports, "UpdateRouteTool", { enumerable: true, get: function () { return ps_update_route_1.UpdateRouteTool; } });
+var ps_delete_route_1 = require("./ps-delete-route");
+Object.defineProperty(exports, "DeleteRouteTool", { enumerable: true, get: function () { return ps_delete_route_1.DeleteRouteTool; } });
+// Database Table tools
+var ps_add_table_1 = require("./ps-add-table");
+Object.defineProperty(exports, "AddTableTool", { enumerable: true, get: function () { return ps_add_table_1.AddTableTool; } });
+var ps_update_table_1 = require("./ps-update-table");
+Object.defineProperty(exports, "UpdateTableTool", { enumerable: true, get: function () { return ps_update_table_1.UpdateTableTool; } });
+var ps_delete_table_1 = require("./ps-delete-table");
+Object.defineProperty(exports, "DeleteTableTool", { enumerable: true, get: function () { return ps_delete_table_1.DeleteTableTool; } });
+// Dependency tools
+var ps_add_dependency_1 = require("./ps-add-dependency");
+Object.defineProperty(exports, "AddDependencyTool", { enumerable: true, get: function () { return ps_add_dependency_1.AddDependencyTool; } });
+var ps_update_dependency_1 = require("./ps-update-dependency");
+Object.defineProperty(exports, "UpdateDependencyTool", { enumerable: true, get: function () { return ps_update_dependency_1.UpdateDependencyTool; } });
+var ps_delete_dependency_1 = require("./ps-delete-dependency");
+Object.defineProperty(exports, "DeleteDependencyTool", { enumerable: true, get: function () { return ps_delete_dependency_1.DeleteDependencyTool; } });
+// Command tools
+var ps_add_command_1 = require("./ps-add-command");
+Object.defineProperty(exports, "AddCommandTool", { enumerable: true, get: function () { return ps_add_command_1.AddCommandTool; } });
+var ps_update_command_1 = require("./ps-update-command");
+Object.defineProperty(exports, "UpdateCommandTool", { enumerable: true, get: function () { return ps_update_command_1.UpdateCommandTool; } });
+var ps_delete_command_1 = require("./ps-delete-command");
+Object.defineProperty(exports, "DeleteCommandTool", { enumerable: true, get: function () { return ps_delete_command_1.DeleteCommandTool; } });
+// UI Route tools
+var ps_add_ui_route_1 = require("./ps-add-ui-route");
+Object.defineProperty(exports, "AddUiRouteTool", { enumerable: true, get: function () { return ps_add_ui_route_1.AddUiRouteTool; } });
+var ps_update_ui_route_1 = require("./ps-update-ui-route");
+Object.defineProperty(exports, "UpdateUiRouteTool", { enumerable: true, get: function () { return ps_update_ui_route_1.UpdateUiRouteTool; } });
+var ps_delete_ui_route_1 = require("./ps-delete-ui-route");
+Object.defineProperty(exports, "DeleteUiRouteTool", { enumerable: true, get: function () { return ps_delete_ui_route_1.DeleteUiRouteTool; } });
+// Deployment tools
+var ps_add_deployment_1 = require("./ps-add-deployment");
+Object.defineProperty(exports, "AddDeploymentTool", { enumerable: true, get: function () { return ps_add_deployment_1.AddDeploymentTool; } });
+var ps_update_deployment_1 = require("./ps-update-deployment");
+Object.defineProperty(exports, "UpdateDeploymentTool", { enumerable: true, get: function () { return ps_update_deployment_1.UpdateDeploymentTool; } });
+var ps_delete_deployment_1 = require("./ps-delete-deployment");
+Object.defineProperty(exports, "DeleteDeploymentTool", { enumerable: true, get: function () { return ps_delete_deployment_1.DeleteDeploymentTool; } });
+// Configuration tools
+var ps_update_git_1 = require("./ps-update-git");
+Object.defineProperty(exports, "UpdateGitTool", { enumerable: true, get: function () { return ps_update_git_1.UpdateGitTool; } });
+var ps_update_design_guidelines_1 = require("./ps-update-design-guidelines");
+Object.defineProperty(exports, "UpdateDesignGuidelinesTool", { enumerable: true, get: function () { return ps_update_design_guidelines_1.UpdateDesignGuidelinesTool; } });
+var ps_update_frontend_framework_1 = require("./ps-update-frontend-framework");
+Object.defineProperty(exports, "UpdateFrontendFrameworkTool", { enumerable: true, get: function () { return ps_update_frontend_framework_1.UpdateFrontendFrameworkTool; } });
+var ps_update_section_1 = require("./ps-update-section");
+Object.defineProperty(exports, "UpdateSectionTool", { enumerable: true, get: function () { return ps_update_section_1.UpdateSectionTool; } });
+// Create instances for convenience
+const ps_get_metadata_2 = require("./ps-get-metadata");
+const ps_update_metadata_2 = require("./ps-update-metadata");
+const ps_get_packages_2 = require("./ps-get-packages");
+const ps_get_package_2 = require("./ps-get-package");
+const ps_create_package_2 = require("./ps-create-package");
+const ps_update_package_2 = require("./ps-update-package");
+const ps_delete_package_2 = require("./ps-delete-package");
+const ps_add_route_2 = require("./ps-add-route");
+const ps_update_route_2 = require("./ps-update-route");
+const ps_delete_route_2 = require("./ps-delete-route");
+const ps_add_table_2 = require("./ps-add-table");
+const ps_update_table_2 = require("./ps-update-table");
+const ps_delete_table_2 = require("./ps-delete-table");
+const ps_add_dependency_2 = require("./ps-add-dependency");
+const ps_update_dependency_2 = require("./ps-update-dependency");
+const ps_delete_dependency_2 = require("./ps-delete-dependency");
+const ps_add_command_2 = require("./ps-add-command");
+const ps_update_command_2 = require("./ps-update-command");
+const ps_delete_command_2 = require("./ps-delete-command");
+const ps_add_ui_route_2 = require("./ps-add-ui-route");
+const ps_update_ui_route_2 = require("./ps-update-ui-route");
+const ps_delete_ui_route_2 = require("./ps-delete-ui-route");
+const ps_add_deployment_2 = require("./ps-add-deployment");
+const ps_update_deployment_2 = require("./ps-update-deployment");
+const ps_delete_deployment_2 = require("./ps-delete-deployment");
+const ps_update_git_2 = require("./ps-update-git");
+const ps_update_design_guidelines_2 = require("./ps-update-design-guidelines");
+const ps_update_frontend_framework_2 = require("./ps-update-frontend-framework");
+const ps_update_section_2 = require("./ps-update-section");
+/**
+ * All project structure tools
+ */
+exports.projectStructureTools = [
+    // Metadata
+    new ps_get_metadata_2.GetMetadataTool(),
+    new ps_update_metadata_2.UpdateMetadataTool(),
+    // Packages
+    new ps_get_packages_2.GetPackagesTool(),
+    new ps_get_package_2.GetPackageTool(),
+    new ps_create_package_2.CreatePackageTool(),
+    new ps_update_package_2.UpdatePackageTool(),
+    new ps_delete_package_2.DeletePackageTool(),
+    // API Routes
+    new ps_add_route_2.AddRouteTool(),
+    new ps_update_route_2.UpdateRouteTool(),
+    new ps_delete_route_2.DeleteRouteTool(),
+    // Database Tables
+    new ps_add_table_2.AddTableTool(),
+    new ps_update_table_2.UpdateTableTool(),
+    new ps_delete_table_2.DeleteTableTool(),
+    // Dependencies
+    new ps_add_dependency_2.AddDependencyTool(),
+    new ps_update_dependency_2.UpdateDependencyTool(),
+    new ps_delete_dependency_2.DeleteDependencyTool(),
+    // Commands
+    new ps_add_command_2.AddCommandTool(),
+    new ps_update_command_2.UpdateCommandTool(),
+    new ps_delete_command_2.DeleteCommandTool(),
+    // UI Routes
+    new ps_add_ui_route_2.AddUiRouteTool(),
+    new ps_update_ui_route_2.UpdateUiRouteTool(),
+    new ps_delete_ui_route_2.DeleteUiRouteTool(),
+    // Deployments
+    new ps_add_deployment_2.AddDeploymentTool(),
+    new ps_update_deployment_2.UpdateDeploymentTool(),
+    new ps_delete_deployment_2.DeleteDeploymentTool(),
+    // Configuration
+    new ps_update_git_2.UpdateGitTool(),
+    new ps_update_design_guidelines_2.UpdateDesignGuidelinesTool(),
+    new ps_update_frontend_framework_2.UpdateFrontendFrameworkTool(),
+    new ps_update_section_2.UpdateSectionTool(),
+];

package/dist/tools/projectStructure/ps-add-command.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Project Structure Add Command Tool - Adds a run command to a package
+ * Wraps the SDK's projectStructure.addCommand() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the AddCommand tool
+ */
+export interface AddCommandToolParams {
+    /** ID of the package to add the command to */
+    packageId: string;
+    /** Name of the command */
+    name: string;
+    /** Command string to execute */
+    command: string;
+    /** Optional description */
+    description?: string;
+    /** Optional working directory */
+    cwd?: string;
+    /** Optional workspace path */
+    workspacePath?: string;
+}
+/**
+ * Tool to add a run command to a package
+ */
+export declare class AddCommandTool extends BaseDeclarativeTool<AddCommandToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: AddCommandToolParams): ToolInvocation<AddCommandToolParams, ToolResult>;
+}

package/dist/tools/projectStructure/ps-add-command.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Project Structure Add Command Tool - Adds a run command to a package
+ * Wraps the SDK's projectStructure.addCommand() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddCommandTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const projectStructure_1 = __importDefault(require("../../modules/projectStructure"));
+class AddCommandToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const { packageId, workspacePath, ...command } = this.params;
+            const response = await projectStructure_1.default.addCommand(packageId, command, workspacePath);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: `Successfully added command: ${this.params.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding command: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool to add a run command to a package
+ */
+class AddCommandTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(AddCommandTool.Name, 'AddCommand', 'Adds a run command to a package with name and command string.', types_1.Kind.Edit, {
+            type: 'object',
+            properties: {
+                packageId: {
+                    type: 'string',
+                    description: 'ID of the package to add the command to',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Name of the command',
+                },
+                command: {
+                    type: 'string',
+                    description: 'Command string to execute',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the command',
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Working directory for the command',
+                },
+                workspacePath: {
+                    type: 'string',
+                    description: 'Optional workspace path',
+                },
+            },
+            required: ['packageId', 'name', 'command'],
+        });
+    }
+    createInvocation(params) {
+        return new AddCommandToolInvocation(params);
+    }
+}
+exports.AddCommandTool = AddCommandTool;
+AddCommandTool.Name = 'project_structure_add_command';

package/dist/tools/projectStructure/ps-add-dependency.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Project Structure Add Dependency Tool - Adds a dependency to a package
+ * Wraps the SDK's projectStructure.addDependency() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the AddDependency tool
+ */
+export interface AddDependencyToolParams {
+    /** ID of the package to add the dependency to */
+    packageId: string;
+    /** Name of the dependency */
+    name: string;
+    /** Version of the dependency */
+    version: string;
+    /** Type of dependency */
+    type: 'runtime' | 'dev' | 'peer' | 'optional';
+    /** Optional description */
+    description?: string;
+    /** Optional workspace path */
+    workspacePath?: string;
+}
+/**
+ * Tool to add a dependency to a package
+ */
+export declare class AddDependencyTool extends BaseDeclarativeTool<AddDependencyToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: AddDependencyToolParams): ToolInvocation<AddDependencyToolParams, ToolResult>;
+}

package/dist/tools/projectStructure/ps-add-dependency.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Project Structure Add Dependency Tool - Adds a dependency to a package
+ * Wraps the SDK's projectStructure.addDependency() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddDependencyTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const projectStructure_1 = __importDefault(require("../../modules/projectStructure"));
+class AddDependencyToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const { packageId, workspacePath, ...dependency } = this.params;
+            const response = await projectStructure_1.default.addDependency(packageId, dependency, workspacePath);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: `Successfully added dependency: ${this.params.name}@${this.params.version}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding dependency: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool to add a dependency to a package
+ */
+class AddDependencyTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(AddDependencyTool.Name, 'AddDependency', 'Adds a dependency to a package with name, version, and type.', types_1.Kind.Edit, {
+            type: 'object',
+            properties: {
+                packageId: {
+                    type: 'string',
+                    description: 'ID of the package to add the dependency to',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Name of the dependency',
+                },
+                version: {
+                    type: 'string',
+                    description: 'Version of the dependency',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['runtime', 'dev', 'peer', 'optional'],
+                    description: 'Type of dependency',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the dependency',
+                },
+                workspacePath: {
+                    type: 'string',
+                    description: 'Optional workspace path',
+                },
+            },
+            required: ['packageId', 'name', 'version', 'type'],
+        });
+    }
+    createInvocation(params) {
+        return new AddDependencyToolInvocation(params);
+    }
+}
+exports.AddDependencyTool = AddDependencyTool;
+AddDependencyTool.Name = 'project_structure_add_dependency';

package/dist/tools/projectStructure/ps-add-deployment.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Project Structure Add Deployment Tool - Adds a deployment config to a package
+ * Wraps the SDK's projectStructure.addDeployment() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the AddDeployment tool
+ */
+export interface AddDeploymentToolParams {
+    /** ID of the package to add the deployment to */
+    packageId: string;
+    /** Name of the deployment config */
+    name: string;
+    /** Type of deployment */
+    type: 'docker' | 'kubernetes' | 'serverless' | 'static' | 'custom';
+    /** Optional description */
+    description?: string;
+    /** Optional configuration object */
+    config?: Record<string, any>;
+    /** Optional workspace path */
+    workspacePath?: string;
+}
+/**
+ * Tool to add a deployment config to a package
+ */
+export declare class AddDeploymentTool extends BaseDeclarativeTool<AddDeploymentToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: AddDeploymentToolParams): ToolInvocation<AddDeploymentToolParams, ToolResult>;
+}

package/dist/tools/projectStructure/ps-add-deployment.js

@@ -0,0 +1,82 @@
+"use strict";
+/**
+ * Project Structure Add Deployment Tool - Adds a deployment config to a package
+ * Wraps the SDK's projectStructure.addDeployment() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddDeploymentTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const projectStructure_1 = __importDefault(require("../../modules/projectStructure"));
+class AddDeploymentToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const { packageId, workspacePath, ...deploymentConfig } = this.params;
+            const response = await projectStructure_1.default.addDeployment(packageId, deploymentConfig, workspacePath);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: `Successfully added deployment: ${this.params.name}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding deployment: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool to add a deployment config to a package
+ */
+class AddDeploymentTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(AddDeploymentTool.Name, 'AddDeployment', 'Adds a deployment configuration to a package with name, type, and optional config.', types_1.Kind.Edit, {
+            type: 'object',
+            properties: {
+                packageId: {
+                    type: 'string',
+                    description: 'ID of the package to add the deployment to',
+                },
+                name: {
+                    type: 'string',
+                    description: 'Name of the deployment configuration',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['docker', 'kubernetes', 'serverless', 'static', 'custom'],
+                    description: 'Type of deployment',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the deployment',
+                },
+                config: {
+                    type: 'object',
+                    description: 'Additional configuration object',
+                },
+                workspacePath: {
+                    type: 'string',
+                    description: 'Optional workspace path',
+                },
+            },
+            required: ['packageId', 'name', 'type'],
+        });
+    }
+    createInvocation(params) {
+        return new AddDeploymentToolInvocation(params);
+    }
+}
+exports.AddDeploymentTool = AddDeploymentTool;
+AddDeploymentTool.Name = 'project_structure_add_deployment';

package/dist/tools/projectStructure/ps-add-route.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Project Structure Add Route Tool - Adds an API route to a package
+ * Wraps the SDK's projectStructure.addRoute() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Parameters for the AddRoute tool
+ */
+export interface AddRouteToolParams {
+    /** ID of the package to add the route to */
+    packageId: string;
+    /** Path of the API route */
+    path: string;
+    /** HTTP method */
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+    /** Optional description */
+    description?: string;
+    /** Optional handler name */
+    handler?: string;
+    /** Optional file path */
+    file?: string;
+    /** Optional auth requirement */
+    auth?: boolean;
+    /** Optional tags */
+    tags?: string[];
+    /** Optional workspace path */
+    workspacePath?: string;
+}
+/**
+ * Tool to add an API route to a package
+ */
+export declare class AddRouteTool extends BaseDeclarativeTool<AddRouteToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: AddRouteToolParams): ToolInvocation<AddRouteToolParams, ToolResult>;
+}

package/dist/tools/projectStructure/ps-add-route.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Project Structure Add Route Tool - Adds an API route to a package
+ * Wraps the SDK's projectStructure.addRoute() method
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddRouteTool = void 0;
+const types_1 = require("../types");
+const base_tool_1 = require("../base-tool");
+const projectStructure_1 = __importDefault(require("../../modules/projectStructure"));
+class AddRouteToolInvocation extends base_tool_1.BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    async execute() {
+        try {
+            const { packageId, workspacePath, ...route } = this.params;
+            const response = await projectStructure_1.default.addRoute(packageId, route, workspacePath);
+            return {
+                llmContent: JSON.stringify(response, null, 2),
+                returnDisplay: `Successfully added route: ${this.params.method} ${this.params.path}`,
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            return {
+                llmContent: `Error adding route: ${errorMessage}`,
+                returnDisplay: `Error: ${errorMessage}`,
+                error: {
+                    message: errorMessage,
+                    type: types_1.ToolErrorType.EXECUTION_FAILED,
+                },
+            };
+        }
+    }
+}
+/**
+ * Tool to add an API route to a package
+ */
+class AddRouteTool extends base_tool_1.BaseDeclarativeTool {
+    constructor() {
+        super(AddRouteTool.Name, 'AddRoute', 'Adds an API route to a package with path, method, and optional metadata.', types_1.Kind.Edit, {
+            type: 'object',
+            properties: {
+                packageId: {
+                    type: 'string',
+                    description: 'ID of the package to add the route to',
+                },
+                path: {
+                    type: 'string',
+                    description: 'Path of the API route',
+                },
+                method: {
+                    type: 'string',
+                    enum: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'],
+                    description: 'HTTP method for the route',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the route',
+                },
+                handler: {
+                    type: 'string',
+                    description: 'Handler function name',
+                },
+                file: {
+                    type: 'string',
+                    description: 'File path containing the handler',
+                },
+                auth: {
+                    type: 'boolean',
+                    description: 'Whether authentication is required',
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Tags for the route',
+                },
+                workspacePath: {
+                    type: 'string',
+                    description: 'Optional workspace path',
+                },
+            },
+            required: ['packageId', 'path', 'method'],
+        });
+    }
+    createInvocation(params) {
+        return new AddRouteToolInvocation(params);
+    }
+}
+exports.AddRouteTool = AddRouteTool;
+AddRouteTool.Name = 'project_structure_add_route';

package/dist/tools/projectStructure/ps-add-table.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Project Structure Add Table Tool - Adds a database table to a package
+ * Wraps the SDK's projectStructure.addTable() method
+ */
+import type { ToolInvocation, ToolResult } from '../types';
+import { BaseDeclarativeTool } from '../base-tool';
+/**
+ * Database column definition
+ */
+interface DatabaseColumn {
+    name: string;
+    type: string;
+    nullable?: boolean;
+    primaryKey?: boolean;
+    foreignKey?: string;
+    defaultValue?: string;
+}
+/**
+ * Parameters for the AddTable tool
+ */
+export interface AddTableToolParams {
+    /** ID of the package to add the table to */
+    packageId: string;
+    /** Name of the table */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Column definitions */
+    columns: DatabaseColumn[];
+    /** Optional indexes */
+    indexes?: string[];
+    /** Optional workspace path */
+    workspacePath?: string;
+}
+/**
+ * Tool to add a database table to a package
+ */
+export declare class AddTableTool extends BaseDeclarativeTool<AddTableToolParams, ToolResult> {
+    static readonly Name: string;
+    constructor();
+    protected createInvocation(params: AddTableToolParams): ToolInvocation<AddTableToolParams, ToolResult>;
+}
+export {};