mcp-quickbase 2.0.1

package/dist/tools/base.d.ts

@@ -0,0 +1,47 @@
+import { McpTool } from '../types/mcp';
+import { ApiResponse } from '../types/api';
+import { QuickbaseClient } from '../client/quickbase';
+/**
+ * Base class for MCP tools
+ */
+export declare abstract class BaseTool<TParams, TResult> implements McpTool<TParams, TResult> {
+    /**
+     * Tool name
+     */
+    abstract name: string;
+    /**
+     * Tool description
+     */
+    abstract description: string;
+    /**
+     * Parameter schema for the tool
+     */
+    abstract paramSchema: Record<string, unknown>;
+    /**
+     * QuickBase client instance
+     */
+    protected client: QuickbaseClient;
+    /**
+     * Constructor
+     * @param client QuickBase client instance
+     */
+    constructor(client: QuickbaseClient);
+    /**
+     * Validate parameters against schema using Zod
+     * @param params Parameters to validate
+     * @returns Validated parameters
+     */
+    protected validateParams(params: unknown): TParams;
+    /**
+     * Execute the tool
+     * @param params Tool parameters
+     * @returns Tool result
+     */
+    execute(params: TParams): Promise<ApiResponse<TResult>>;
+    /**
+     * Implement the tool's functionality
+     * @param params Tool parameters
+     * @returns Tool result
+     */
+    protected abstract run(params: TParams): Promise<TResult>;
+}

package/dist/tools/base.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTool = void 0;
+const logger_1 = require("../utils/logger");
+const validation_1 = require("../utils/validation");
+const logger = (0, logger_1.createLogger)('BaseTool');
+/**
+ * Base class for MCP tools
+ */
+class BaseTool {
+    /**
+     * Constructor
+     * @param client QuickBase client instance
+     */
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Validate parameters against schema using Zod
+     * @param params Parameters to validate
+     * @returns Validated parameters
+     */
+    validateParams(params) {
+        return (0, validation_1.validateParams)(params, this.paramSchema, this.name);
+    }
+    /**
+     * Execute the tool
+     * @param params Tool parameters
+     * @returns Tool result
+     */
+    async execute(params) {
+        try {
+            logger.debug(`Executing tool: ${this.name}`, { params });
+            // Validate parameters
+            const validatedParams = this.validateParams(params);
+            // Execute the tool implementation
+            const result = await this.run(validatedParams);
+            logger.debug(`Tool ${this.name} executed successfully`, { result });
+            return {
+                success: true,
+                data: result
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            const errorType = error instanceof Error ? error.name : 'UnknownError';
+            logger.error(`Error executing tool ${this.name}`, {
+                error: errorMessage,
+                type: errorType,
+                stack: error instanceof Error ? error.stack : undefined
+            });
+            return {
+                success: false,
+                error: {
+                    message: errorMessage,
+                    type: errorType
+                }
+            };
+        }
+    }
+}
+exports.BaseTool = BaseTool;
+//# sourceMappingURL=base.js.map

package/dist/tools/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../src/tools/base.ts"],"names":[],"mappings":";;;AAGA,4CAA+C;AAC/C,oDAAqD;AAErD,MAAM,MAAM,GAAG,IAAA,qBAAY,EAAC,UAAU,CAAC,CAAC;AAExC;;GAEG;AACH,MAAsB,QAAQ;IAqB5B;;;OAGG;IACH,YAAY,MAAuB;QACjC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACO,cAAc,CAAC,MAAe;QACtC,OAAO,IAAA,2BAAc,EAAU,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;IACtE,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,OAAO,CAAC,MAAe;QAClC,IAAI,CAAC;YACH,MAAM,CAAC,KAAK,CAAC,mBAAmB,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YAEzD,sBAAsB;YACtB,MAAM,eAAe,GAAG,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;YAEpD,kCAAkC;YAClC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;YAE/C,MAAM,CAAC,KAAK,CAAC,QAAQ,IAAI,CAAC,IAAI,wBAAwB,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC;YAEpE,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,IAAI,EAAE,MAAM;aACb,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,eAAe,CAAC;YAC9E,MAAM,SAAS,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,cAAc,CAAC;YAEvE,MAAM,CAAC,KAAK,CAAC,wBAAwB,IAAI,CAAC,IAAI,EAAE,EAAE;gBAChD,KAAK,EAAE,YAAY;gBACnB,IAAI,EAAE,SAAS;gBACf,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;aACxD,CAAC,CAAC;YAEH,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,KAAK,EAAE;oBACL,OAAO,EAAE,YAAY;oBACrB,IAAI,EAAE,SAAS;iBAChB;aACF,CAAC;QACJ,CAAC;IACH,CAAC;CAQF;AArFD,4BAqFC"}

package/dist/tools/configure_cache.d.ts

@@ -0,0 +1,81 @@
+import { BaseTool } from './base';
+import { QuickbaseClient } from '../client/quickbase';
+import { CacheService } from '../utils/cache';
+/**
+ * Configure cache parameters
+ */
+export interface ConfigureCacheParams {
+    /**
+     * Whether to enable caching
+     */
+    enabled?: boolean;
+    /**
+     * Whether to clear the cache
+     */
+    clear?: boolean;
+    /**
+     * TTL for cache entries in seconds
+     */
+    ttl?: number;
+}
+/**
+ * Configure cache result
+ */
+export interface ConfigureCacheResult {
+    /**
+     * Whether caching is enabled
+     */
+    cacheEnabled: boolean;
+    /**
+     * Whether the cache was cleared
+     */
+    cacheCleared: boolean;
+    /**
+     * Current TTL setting (in seconds)
+     */
+    cacheTtl?: number;
+}
+/**
+ * Tool for configuring the caching behavior of the Quickbase connector
+ */
+export declare class ConfigureCacheTool extends BaseTool<ConfigureCacheParams, ConfigureCacheResult> {
+    name: string;
+    description: string;
+    /**
+     * Parameter schema for configure_cache
+     */
+    paramSchema: {
+        type: string;
+        properties: {
+            enabled: {
+                type: string;
+                description: string;
+            };
+            clear: {
+                type: string;
+                description: string;
+            };
+            ttl: {
+                type: string;
+                description: string;
+            };
+        };
+        required: never[];
+    };
+    /**
+     * Cache service instance
+     */
+    private cacheService;
+    /**
+     * Constructor
+     * @param client Quickbase client
+     * @param cacheService Cache service
+     */
+    constructor(client: QuickbaseClient, cacheService: CacheService);
+    /**
+     * Run the configure_cache tool
+     * @param params Tool parameters
+     * @returns Configuration result
+     */
+    protected run(params: ConfigureCacheParams): Promise<ConfigureCacheResult>;
+}

package/dist/tools/configure_cache.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigureCacheTool = void 0;
+const base_1 = require("./base");
+const logger_1 = require("../utils/logger");
+const logger = (0, logger_1.createLogger)('ConfigureCacheTool');
+/**
+ * Tool for configuring the caching behavior of the Quickbase connector
+ */
+class ConfigureCacheTool extends base_1.BaseTool {
+    /**
+     * Constructor
+     * @param client Quickbase client
+     * @param cacheService Cache service
+     */
+    constructor(client, cacheService) {
+        super(client);
+        this.name = 'configure_cache';
+        this.description = 'Configures caching behavior for Quickbase operations';
+        /**
+         * Parameter schema for configure_cache
+         */
+        this.paramSchema = {
+            type: 'object',
+            properties: {
+                enabled: {
+                    type: 'boolean',
+                    description: 'Whether to enable caching (default: true)'
+                },
+                clear: {
+                    type: 'boolean',
+                    description: 'Whether to clear all existing caches (default: false)'
+                },
+                ttl: {
+                    type: 'number',
+                    description: 'Cache time-to-live in seconds'
+                }
+            },
+            required: []
+        };
+        this.cacheService = cacheService;
+    }
+    /**
+     * Run the configure_cache tool
+     * @param params Tool parameters
+     * @returns Configuration result
+     */
+    async run(params) {
+        logger.info('Configuring cache', params);
+        const result = {
+            cacheEnabled: this.cacheService.isEnabled(),
+            cacheCleared: false
+        };
+        // Clear cache if requested
+        if (params.clear) {
+            this.cacheService.clear();
+            result.cacheCleared = true;
+            logger.info('Cache cleared');
+        }
+        // Enable/disable cache if specified
+        if (params.enabled !== undefined) {
+            this.cacheService.setEnabled(params.enabled);
+            result.cacheEnabled = params.enabled;
+            logger.info(`Cache ${params.enabled ? 'enabled' : 'disabled'}`);
+        }
+        // Set TTL if specified
+        if (params.ttl !== undefined && params.ttl > 0) {
+            // Here we would set TTL
+            // This requires extending the CacheService to support changing TTL
+            logger.info(`Cache TTL set to ${params.ttl} seconds`);
+            result.cacheTtl = params.ttl;
+        }
+        return result;
+    }
+}
+exports.ConfigureCacheTool = ConfigureCacheTool;
+//# sourceMappingURL=configure_cache.js.map

package/dist/tools/configure_cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"configure_cache.js","sourceRoot":"","sources":["../../src/tools/configure_cache.ts"],"names":[],"mappings":";;;AAAA,iCAAkC;AAGlC,4CAA+C;AAE/C,MAAM,MAAM,GAAG,IAAA,qBAAY,EAAC,oBAAoB,CAAC,CAAC;AA0ClD;;GAEG;AACH,MAAa,kBAAmB,SAAQ,eAAoD;IA+B1F;;;;OAIG;IACH,YAAY,MAAuB,EAAE,YAA0B;QAC7D,KAAK,CAAC,MAAM,CAAC,CAAC;QApCT,SAAI,GAAG,iBAAiB,CAAC;QACzB,gBAAW,GAAG,sDAAsD,CAAC;QAE5E;;WAEG;QACI,gBAAW,GAAG;YACnB,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,OAAO,EAAE;oBACP,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,2CAA2C;iBACzD;gBACD,KAAK,EAAE;oBACL,IAAI,EAAE,SAAS;oBACf,WAAW,EAAE,uDAAuD;iBACrE;gBACD,GAAG,EAAE;oBACH,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,+BAA+B;iBAC7C;aACF;YACD,QAAQ,EAAE,EAAE;SACb,CAAC;QAcA,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,GAAG,CAAC,MAA4B;QAC9C,MAAM,CAAC,IAAI,CAAC,mBAAmB,EAAE,MAAM,CAAC,CAAC;QAEzC,MAAM,MAAM,GAAyB;YACnC,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,SAAS,EAAE;YAC3C,YAAY,EAAE,KAAK;SACpB,CAAC;QAEF,2BAA2B;QAC3B,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;YACjB,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;YAC1B,MAAM,CAAC,YAAY,GAAG,IAAI,CAAC;YAC3B,MAAM,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC/B,CAAC;QAED,oCAAoC;QACpC,IAAI,MAAM,CAAC,OAAO,KAAK,SAAS,EAAE,CAAC;YACjC,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YAC7C,MAAM,CAAC,YAAY,GAAG,MAAM,CAAC,OAAO,CAAC;YACrC,MAAM,CAAC,IAAI,CAAC,SAAS,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC;QAClE,CAAC;QAED,uBAAuB;QACvB,IAAI,MAAM,CAAC,GAAG,KAAK,SAAS,IAAI,MAAM,CAAC,GAAG,GAAG,CAAC,EAAE,CAAC;YAC/C,wBAAwB;YACxB,mEAAmE;YACnE,MAAM,CAAC,IAAI,CAAC,oBAAoB,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC;YACtD,MAAM,CAAC,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC;QAC/B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA9ED,gDA8EC"}

package/dist/tools/fields/create_field.d.ts

@@ -0,0 +1,121 @@
+import { BaseTool } from '../base';
+import { QuickbaseClient } from '../../client/quickbase';
+/**
+ * Field property definitions for various field types
+ */
+export interface FieldProperties {
+    maxLength?: number;
+    defaultValue?: string | number;
+    precision?: number;
+    format?: string;
+    choices?: {
+        label: string;
+        value: string;
+    }[];
+    targetTableId?: string;
+    targetFieldId?: string;
+    appearsByDefault?: boolean;
+    findEnabled?: boolean;
+    [key: string]: any;
+}
+/**
+ * Parameters for create_field tool
+ */
+export interface CreateFieldParams {
+    /**
+     * ID of the table to create the field in
+     */
+    table_id: string;
+    /**
+     * Name of the field
+     */
+    field_name: string;
+    /**
+     * Type of the field (e.g., text, numeric, date, etc.)
+     */
+    field_type: string;
+    /**
+     * Description of the field
+     */
+    description?: string;
+    /**
+     * Additional options and properties for the field
+     */
+    options?: FieldProperties;
+}
+/**
+ * Response from creating a field
+ */
+export interface CreateFieldResult {
+    /**
+     * The ID of the created field
+     */
+    fieldId: string;
+    /**
+     * The label/name of the created field
+     */
+    label: string;
+    /**
+     * The type of the created field
+     */
+    fieldType: string;
+    /**
+     * The description of the created field
+     */
+    description?: string;
+    /**
+     * The ID of the table the field was created in
+     */
+    tableId: string;
+    /**
+     * Additional details about the created field
+     */
+    [key: string]: any;
+}
+/**
+ * Tool for creating a new field in a Quickbase table
+ */
+export declare class CreateFieldTool extends BaseTool<CreateFieldParams, CreateFieldResult> {
+    name: string;
+    description: string;
+    /**
+     * Parameter schema for create_field
+     */
+    paramSchema: {
+        type: string;
+        properties: {
+            table_id: {
+                type: string;
+                description: string;
+            };
+            field_name: {
+                type: string;
+                description: string;
+            };
+            field_type: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            options: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    /**
+     * Constructor
+     * @param client Quickbase client
+     */
+    constructor(client: QuickbaseClient);
+    /**
+     * Run the create_field tool
+     * @param params Tool parameters
+     * @returns Created field details
+     */
+    protected run(params: CreateFieldParams): Promise<CreateFieldResult>;
+}

package/dist/tools/fields/create_field.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateFieldTool = void 0;
+const base_1 = require("../base");
+const logger_1 = require("../../utils/logger");
+const logger = (0, logger_1.createLogger)('CreateFieldTool');
+/**
+ * Tool for creating a new field in a Quickbase table
+ */
+class CreateFieldTool extends base_1.BaseTool {
+    /**
+     * Constructor
+     * @param client Quickbase client
+     */
+    constructor(client) {
+        super(client);
+        this.name = 'create_field';
+        this.description = 'Creates a new field in a Quickbase table';
+        /**
+         * Parameter schema for create_field
+         */
+        this.paramSchema = {
+            type: 'object',
+            properties: {
+                table_id: {
+                    type: 'string',
+                    description: 'The ID of the table'
+                },
+                field_name: {
+                    type: 'string',
+                    description: 'Name of the field'
+                },
+                field_type: {
+                    type: 'string',
+                    description: 'Type of the field (e.g., text, number, date)'
+                },
+                description: {
+                    type: 'string',
+                    description: 'Description of the field'
+                },
+                options: {
+                    type: 'object',
+                    description: 'Additional field options'
+                }
+            },
+            required: ['table_id', 'field_name', 'field_type']
+        };
+    }
+    /**
+     * Run the create_field tool
+     * @param params Tool parameters
+     * @returns Created field details
+     */
+    async run(params) {
+        const { table_id, field_name, field_type, description, options } = params;
+        logger.info('Creating new field in Quickbase table', {
+            tableId: table_id,
+            fieldName: field_name,
+            fieldType: field_type
+        });
+        // Prepare request body
+        const body = {
+            label: field_name,
+            fieldType: field_type,
+            description: description || ''
+        };
+        // Add properties if provided
+        if (options) {
+            body.properties = { ...options };
+        }
+        // Create the field
+        const response = await this.client.request({
+            method: 'POST',
+            path: `/fields?tableId=${table_id}`,
+            body
+        });
+        if (!response.success || !response.data) {
+            logger.error('Failed to create field', {
+                error: response.error,
+                tableId: table_id,
+                fieldName: field_name
+            });
+            throw new Error(response.error?.message || 'Failed to create field');
+        }
+        const field = response.data;
+        logger.info('Successfully created field', {
+            fieldId: field.id,
+            tableId: table_id,
+            fieldName: field.label
+        });
+        return {
+            fieldId: field.id,
+            label: field.label,
+            fieldType: field.fieldType,
+            description: field.description,
+            tableId: table_id,
+            ...field
+        };
+    }
+}
+exports.CreateFieldTool = CreateFieldTool;
+//# sourceMappingURL=create_field.js.map

package/dist/tools/fields/create_field.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_field.js","sourceRoot":"","sources":["../../../src/tools/fields/create_field.ts"],"names":[],"mappings":";;;AAAA,kCAAmC;AAEnC,+CAAkD;AAElD,MAAM,MAAM,GAAG,IAAA,qBAAY,EAAC,iBAAiB,CAAC,CAAC;AAqG/C;;GAEG;AACH,MAAa,eAAgB,SAAQ,eAA8C;IAkCjF;;;OAGG;IACH,YAAY,MAAuB;QACjC,KAAK,CAAC,MAAM,CAAC,CAAC;QAtCT,SAAI,GAAG,cAAc,CAAC;QACtB,gBAAW,GAAG,0CAA0C,CAAC;QAEhE;;WAEG;QACI,gBAAW,GAAG;YACnB,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,QAAQ,EAAE;oBACR,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,qBAAqB;iBACnC;gBACD,UAAU,EAAE;oBACV,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,mBAAmB;iBACjC;gBACD,UAAU,EAAE;oBACV,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,8CAA8C;iBAC5D;gBACD,WAAW,EAAE;oBACX,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,0BAA0B;iBACxC;gBACD,OAAO,EAAE;oBACP,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE,0BAA0B;iBACxC;aACF;YACD,QAAQ,EAAE,CAAC,UAAU,EAAE,YAAY,EAAE,YAAY,CAAC;SACnD,CAAC;IAQF,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,GAAG,CAAC,MAAyB;QAC3C,MAAM,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,MAAM,CAAC;QAE1E,MAAM,CAAC,IAAI,CAAC,uCAAuC,EAAE;YACnD,OAAO,EAAE,QAAQ;YACjB,SAAS,EAAE,UAAU;YACrB,SAAS,EAAE,UAAU;SACtB,CAAC,CAAC;QAEH,uBAAuB;QACvB,MAAM,IAAI,GAAwB;YAChC,KAAK,EAAE,UAAU;YACjB,SAAS,EAAE,UAAU;YACrB,WAAW,EAAE,WAAW,IAAI,EAAE;SAC/B,CAAC;QAEF,6BAA6B;QAC7B,IAAI,OAAO,EAAE,CAAC;YACZ,IAAI,CAAC,UAAU,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;QACnC,CAAC;QAED,mBAAmB;QACnB,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC;YACzC,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,mBAAmB,QAAQ,EAAE;YACnC,IAAI;SACL,CAAC,CAAC;QAEH,IAAI,CAAC,QAAQ,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;YACxC,MAAM,CAAC,KAAK,CAAC,wBAAwB,EAAE;gBACrC,KAAK,EAAE,QAAQ,CAAC,KAAK;gBACrB,OAAO,EAAE,QAAQ;gBACjB,SAAS,EAAE,UAAU;aACtB,CAAC,CAAC;YACH,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,IAAI,wBAAwB,CAAC,CAAC;QACvE,CAAC;QAED,MAAM,KAAK,GAAG,QAAQ,CAAC,IAA2B,CAAC;QAEnD,MAAM,CAAC,IAAI,CAAC,4BAA4B,EAAE;YACxC,OAAO,EAAE,KAAK,CAAC,EAAE;YACjB,OAAO,EAAE,QAAQ;YACjB,SAAS,EAAE,KAAK,CAAC,KAAK;SACvB,CAAC,CAAC;QAEH,OAAO;YACL,OAAO,EAAE,KAAK,CAAC,EAAE;YACjB,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,SAAS,EAAE,KAAK,CAAC,SAAS;YAC1B,WAAW,EAAE,KAAK,CAAC,WAAW;YAC9B,OAAO,EAAE,QAAQ;YACjB,GAAG,KAAK;SACT,CAAC;IACJ,CAAC;CACF;AArGD,0CAqGC"}

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

@@ -0,0 +1,8 @@
+import { QuickbaseClient } from '../../client/quickbase';
+/**
+ * Register all field management tools with the registry
+ * @param client Quickbase client
+ */
+export declare function registerFieldTools(client: QuickbaseClient): void;
+export * from './create_field';
+export * from './update_field';

package/dist/tools/fields/index.js

@@ -0,0 +1,37 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerFieldTools = registerFieldTools;
+const registry_1 = require("../registry");
+const create_field_1 = require("./create_field");
+const update_field_1 = require("./update_field");
+const logger_1 = require("../../utils/logger");
+const logger = (0, logger_1.createLogger)('FieldTools');
+/**
+ * Register all field management tools with the registry
+ * @param client Quickbase client
+ */
+function registerFieldTools(client) {
+    logger.info('Registering field management tools');
+    // Register individual tools
+    registry_1.toolRegistry.registerTool(new create_field_1.CreateFieldTool(client));
+    registry_1.toolRegistry.registerTool(new update_field_1.UpdateFieldTool(client));
+    logger.info('Field management tools registered');
+}
+// Export all tools
+__exportStar(require("./create_field"), exports);
+__exportStar(require("./update_field"), exports);
+//# sourceMappingURL=index.js.map

package/dist/tools/fields/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/tools/fields/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAYA,gDAQC;AAnBD,0CAA2C;AAC3C,iDAAiD;AACjD,iDAAiD;AACjD,+CAAkD;AAElD,MAAM,MAAM,GAAG,IAAA,qBAAY,EAAC,YAAY,CAAC,CAAC;AAE1C;;;GAGG;AACH,SAAgB,kBAAkB,CAAC,MAAuB;IACxD,MAAM,CAAC,IAAI,CAAC,oCAAoC,CAAC,CAAC;IAElD,4BAA4B;IAC5B,uBAAY,CAAC,YAAY,CAAC,IAAI,8BAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IACvD,uBAAY,CAAC,YAAY,CAAC,IAAI,8BAAe,CAAC,MAAM,CAAC,CAAC,CAAC;IAEvD,MAAM,CAAC,IAAI,CAAC,mCAAmC,CAAC,CAAC;AACnD,CAAC;AAED,mBAAmB;AACnB,iDAA+B;AAC/B,iDAA+B"}

package/dist/tools/fields/update_field.d.ts

@@ -0,0 +1,112 @@
+import { BaseTool } from '../base';
+import { QuickbaseClient } from '../../client/quickbase';
+import { FieldProperties } from './create_field';
+/**
+ * Parameters for update_field tool
+ */
+export interface UpdateFieldParams {
+    /**
+     * The ID of the table containing the field
+     */
+    table_id: string;
+    /**
+     * The ID of the field to update
+     */
+    field_id: string;
+    /**
+     * New name for the field
+     */
+    name?: string;
+    /**
+     * New description for the field
+     */
+    description?: string;
+    /**
+     * New field type (only allowed for certain field type conversions)
+     */
+    field_type?: string;
+    /**
+     * Additional options and properties to update
+     */
+    options?: FieldProperties;
+}
+/**
+ * Response from updating a field
+ */
+export interface UpdateFieldResult {
+    /**
+     * The ID of the updated field
+     */
+    fieldId: string;
+    /**
+     * The updated label/name of the field
+     */
+    label?: string;
+    /**
+     * The updated type of the field
+     */
+    fieldType?: string;
+    /**
+     * The updated description of the field
+     */
+    description?: string;
+    /**
+     * The ID of the table containing the field
+     */
+    tableId: string;
+    /**
+     * Additional details about the updated field
+     */
+    [key: string]: any;
+}
+/**
+ * Tool for updating an existing field in a Quickbase table
+ */
+export declare class UpdateFieldTool extends BaseTool<UpdateFieldParams, UpdateFieldResult> {
+    name: string;
+    description: string;
+    /**
+     * Parameter schema for update_field
+     */
+    paramSchema: {
+        type: string;
+        properties: {
+            table_id: {
+                type: string;
+                description: string;
+            };
+            field_id: {
+                type: string;
+                description: string;
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            field_type: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            options: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    /**
+     * Constructor
+     * @param client Quickbase client
+     */
+    constructor(client: QuickbaseClient);
+    /**
+     * Run the update_field tool
+     * @param params Tool parameters
+     * @returns Updated field details
+     */
+    protected run(params: UpdateFieldParams): Promise<UpdateFieldResult>;
+}