@utaba/ucm-mcp-server 6.5.0 → 6.6.0

package/dist/mcp-server/tools/memory-graph/GraphTraverseTool.js

@@ -0,0 +1,114 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphTraverseSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphTraverseTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_traverse'; }
+    get description() {
+        return 'Execute a structured graph traversal using a JSON spec. Supports start point selection, ordered hop steps with relationship/entity type filters, property filters, repeat loops, and multiple return modes (terminal, all, paths). The most powerful query tool for complex graph navigation.';
+    }
+    get schema() { return GraphTraverseSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                start: {
+                    type: 'object',
+                    description: 'Start point specification',
+                    properties: {
+                        entityId: { type: 'string', description: 'Start from a specific entity ID or slug' },
+                        entityType: { type: 'string', description: 'Start from all entities of this type' },
+                        filter: {
+                            type: 'array',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    key: { type: 'string' },
+                                    operator: { type: 'string', description: 'eq, neq, gt, gte, lt, lte, contains, isNull, isNotNull' },
+                                    value: {}
+                                },
+                                required: ['key', 'operator']
+                            },
+                            description: 'Property filters on start entities'
+                        }
+                    }
+                },
+                steps: {
+                    type: 'array',
+                    description: 'Ordered traversal steps (hops)',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            direction: { type: 'string', enum: ['out', 'in', 'both'], description: 'Hop direction' },
+                            relationshipTypes: { type: 'array', items: { type: 'string' }, description: 'Filter by relationship types' },
+                            entityTypes: { type: 'array', items: { type: 'string' }, description: 'Filter by entity types at this step' },
+                            entityFilter: {
+                                type: 'array',
+                                items: {
+                                    type: 'object',
+                                    properties: {
+                                        key: { type: 'string' },
+                                        operator: { type: 'string' },
+                                        value: {}
+                                    },
+                                    required: ['key', 'operator']
+                                },
+                                description: 'Property filters on entities at this step'
+                            },
+                            repeat: {
+                                type: 'object',
+                                properties: {
+                                    maxDepth: { type: 'number', description: 'Maximum repeat depth' },
+                                    emitIntermediates: { type: 'boolean', description: 'Include intermediate results' }
+                                },
+                                description: 'Repeat this step up to maxDepth times'
+                            }
+                        }
+                    }
+                },
+                returnMode: {
+                    type: 'string',
+                    enum: ['terminal', 'all', 'path'],
+                    description: 'What to return: terminal (only final step entities), all (every visited entity), path (full traversal paths with relationships). Default: terminal'
+                },
+                limit: {
+                    type: 'number',
+                    description: 'Maximum results (default: 50, max: 200)'
+                },
+                detailLevel: {
+                    type: 'string',
+                    enum: ['brief', 'summary', 'full'],
+                    description: 'Detail level for returned entities (default: summary)'
+                }
+            },
+            required: ['memoryGraphId', 'start', 'steps']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, start, steps, returnMode, limit, detailLevel } = params;
+        this.logger.info('GraphTraverseTool', `Traversing graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphTraverse(memoryGraphId, {
+                start,
+                steps,
+                returnMode,
+                limit,
+                detailLevel
+            });
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to traverse graph: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphTraverseTool.js.map

package/dist/mcp-server/tools/memory-graph/GraphUpdateEntitiesTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type GraphUpdateEntitiesParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class GraphUpdateEntitiesTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(params: GraphUpdateEntitiesParams): Promise<string>;
+}
+//# sourceMappingURL=GraphUpdateEntitiesTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/GraphUpdateEntitiesTool.js

@@ -0,0 +1,58 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+import { GraphUpdateEntitiesSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class GraphUpdateEntitiesTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_graph_update_entities'; }
+    get description() {
+        return 'Update one or more entities in a Memory Graph. Each update specifies an entityId and the fields to change (label, summary, properties, data). Pass a single item in the array for single operations.';
+    }
+    get schema() { return GraphUpdateEntitiesSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                memoryGraphId: {
+                    type: 'string',
+                    description: 'The Memory Graph ID'
+                },
+                updates: {
+                    type: 'array',
+                    description: 'Array of entity updates',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            entityId: { type: 'string', description: 'The entity ID to update' },
+                            label: { type: 'string', description: 'New label' },
+                            summary: { type: 'string', description: 'New summary' },
+                            properties: { type: 'object', description: 'Properties to update (merged with existing)' },
+                            data: { type: 'object', description: 'Data to update (merged with existing)' }
+                        },
+                        required: ['entityId']
+                    }
+                }
+            },
+            required: ['memoryGraphId', 'updates']
+        };
+    }
+    async handleExecute(params) {
+        const { memoryGraphId, updates } = params;
+        this.logger.info('GraphUpdateEntitiesTool', `Updating ${updates.length} entities in graph: ${memoryGraphId}`);
+        try {
+            const result = await this.ucmClient.graphUpdateEntities(memoryGraphId, updates);
+            return JSON.stringify(result);
+        }
+        catch (error) {
+            if (error.response?.status === 400) {
+                throw new McpError(McpErrorCode.InvalidParams, error.response.data?.message || 'Validation error');
+            }
+            if (error.response?.status === 404) {
+                throw new McpError(McpErrorCode.InvalidParams, `Entity or Memory Graph not found`);
+            }
+            throw new McpError(McpErrorCode.InternalError, `Failed to update entities: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=GraphUpdateEntitiesTool.js.map

package/dist/mcp-server/tools/memory-graph/KnowledgeSetListTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type KnowledgeSetListParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class KnowledgeSetListTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(_params: KnowledgeSetListParams): Promise<string>;
+}
+//# sourceMappingURL=KnowledgeSetListTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/KnowledgeSetListTool.js

@@ -0,0 +1,25 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { KnowledgeSetListSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class KnowledgeSetListTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_knowledge_set_list'; }
+    get description() {
+        return 'List Knowledge Sets you have access to. Use `ucm_knowledge_set_open` with a Knowledge Set ID to explore its contents.';
+    }
+    get schema() { return KnowledgeSetListSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {},
+            required: []
+        };
+    }
+    async handleExecute(_params) {
+        this.logger.info('KnowledgeSetListTool', 'Listing knowledge sets');
+        const result = await this.ucmClient.listKnowledgeSetSummary();
+        return result;
+    }
+}
+//# sourceMappingURL=KnowledgeSetListTool.js.map

package/dist/mcp-server/tools/memory-graph/KnowledgeSetOpenTool.d.ts

@@ -0,0 +1,14 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+import { type KnowledgeSetOpenParams } from '@/schemas/memory-graph-tool-schemas.js';
+import { ZodSchema } from 'zod';
+export declare class KnowledgeSetOpenTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get schema(): ZodSchema;
+    get inputSchema(): Record<string, unknown>;
+    protected handleExecute(_params: KnowledgeSetOpenParams): Promise<string>;
+}
+//# sourceMappingURL=KnowledgeSetOpenTool.d.ts.map

package/dist/mcp-server/tools/memory-graph/KnowledgeSetOpenTool.js

@@ -0,0 +1,31 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { KnowledgeSetOpenSchema } from '@/schemas/memory-graph-tool-schemas.js';
+export class KnowledgeSetOpenTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() { return 'ucm_knowledge_set_open'; }
+    get description() {
+        return 'Open a Knowledge Set to see its contents — Memory Graphs, artifact repositories, and artifact namespaces — with guidance on which tools to use for each.';
+    }
+    get schema() { return KnowledgeSetOpenSchema; }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                knowledgeSetId: {
+                    type: 'string',
+                    description: 'The Knowledge Set ID to open'
+                }
+            },
+            required: ['knowledgeSetId']
+        };
+    }
+    async handleExecute(_params) {
+        const { knowledgeSetId } = _params;
+        this.logger.info('KnowledgeSetOpenTool', `Opening knowledge set ${knowledgeSetId}`);
+        const result = await this.ucmClient.openKnowledgeSet(knowledgeSetId);
+        return result;
+    }
+}
+//# sourceMappingURL=KnowledgeSetOpenTool.js.map

package/dist/mcp-server/tools/repository/CreateRepositoryTool.d.ts

@@ -0,0 +1,12 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class CreateRepositoryTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: any): Promise<any>;
+}
+//# sourceMappingURL=CreateRepositoryTool.d.ts.map

package/dist/mcp-server/tools/repository/CreateRepositoryTool.js

@@ -0,0 +1,116 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class CreateRepositoryTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'ucm_repository_create';
+    }
+    get description() {
+        const authorInfo = this.publishingAuthorId ? ` Your default workspace id is '${this.publishingAuthorId}'.` : '';
+        return `Create a new repository for a specific workspace. Repository names must be unique within the workspace and follow UCM naming conventions. (3-200 characters, start with letter, alphanumeric and hyphens only, no consecutive hyphens).${authorInfo}`;
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                workspace: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Workspace identifier: ${this.publishingAuthorId}` : 'Workspace identifier (e.g., "utaba", "1064600359")',
+                    minLength: 1,
+                    maxLength: 50
+                },
+                repositoryName: {
+                    type: 'string',
+                    description: 'Unique repository name (3-200 characters, start with letter, alphanumeric and hyphens only)',
+                    minLength: 3,
+                    maxLength: 200,
+                    pattern: '^[a-z][a-z0-9-]{2,199}$'
+                },
+                displayName: {
+                    type: 'string',
+                    description: 'Human-readable display name for the repository (optional)',
+                    maxLength: 255
+                },
+                description: {
+                    type: 'string',
+                    description: 'Repository description (optional)',
+                    maxLength: 1000
+                }
+            },
+            required: ['workspace', 'repositoryName'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        // Additional validation
+        if (!params.workspace || typeof params.workspace !== 'string' || params.workspace.trim() === '') {
+            throw new McpError(McpErrorCode.InvalidParams, 'Author identifier is required and cannot be empty');
+        }
+        if (!params.repositoryName || typeof params.repositoryName !== 'string' || params.repositoryName.trim() === '') {
+            throw new McpError(McpErrorCode.InvalidParams, 'Repository name is required and cannot be empty');
+        }
+        // Validate repository name format
+        const namePattern = /^[a-z][a-z0-9-]{2,199}$/;
+        if (!namePattern.test(params.repositoryName)) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Repository name must be 3-200 characters, start with a lowercase letter, and contain only lowercase letters, numbers, and hyphens (no consecutive hyphens)');
+        }
+        // Check for consecutive hyphens
+        if (params.repositoryName.includes('--')) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Repository name cannot contain consecutive hyphens');
+        }
+        // Validate displayName length if provided
+        if (params.displayName && params.displayName.length > 255) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Display name cannot exceed 255 characters');
+        }
+        // Validate description length if provided
+        if (params.description && params.description.length > 1000) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Description cannot exceed 1,000 characters');
+        }
+    }
+    async handleExecute(params) {
+        const author = params.workspace;
+        this.logger.info('CreateRepositoryTool', `Creating repository ${params.repositoryName} for author ${author}`);
+        try {
+            const repositoryData = {
+                repositoryName: params.repositoryName,
+                displayName: params.displayName,
+                description: params.description
+            };
+            const result = await this.ucmClient.createRepository(author, repositoryData);
+            this.logger.info('CreateRepositoryTool', `Repository created successfully: ${params.repositoryName}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Repository '${params.repositoryName}' created successfully for author '${author}'`,
+                            repository: result,
+                            webUrl: `${process.env.NEXT_PUBLIC_BASE_URL || 'http://localhost:3000'}/repository/${result.id || params.repositoryName}`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            this.logger.error('CreateRepositoryTool', 'Failed to create repository', '', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            // Handle specific error cases
+            if (errorMessage.includes('already exists') || errorMessage.includes('NAME_EXISTS')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Repository name '${params.repositoryName}' already exists for author '${author}'. Please choose a different name.`);
+            }
+            if (errorMessage.includes('not found') || errorMessage.includes('404')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Author '${author}' not found. Please verify the author identifier.`);
+            }
+            if (errorMessage.includes('validation') || errorMessage.includes('invalid')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Repository creation failed due to validation error: ${errorMessage}`);
+            }
+            // Generic error
+            throw new McpError(McpErrorCode.InternalError, `Failed to create repository: ${errorMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=CreateRepositoryTool.js.map

package/dist/mcp-server/tools/repository/GetRepositoryTool.d.ts

@@ -0,0 +1,12 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class GetRepositoryTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: any): Promise<any>;
+}
+//# sourceMappingURL=GetRepositoryTool.d.ts.map

package/dist/mcp-server/tools/repository/GetRepositoryTool.js

@@ -0,0 +1,85 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class GetRepositoryTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'ucm_repository_get';
+    }
+    get description() {
+        return 'Get detailed information about a specific repository, including metadata, statistics, and available categories. Returns repository details along with its content structure.';
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                workspace: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Workspace identifier: ${this.publishingAuthorId}` : 'Workspace identifier (e.g., "utaba", "1064600359")',
+                    minLength: 1,
+                    maxLength: 50
+                },
+                repository: {
+                    type: 'string',
+                    description: 'Repository name (e.g., "main", "project-alpha")',
+                    minLength: 1,
+                    maxLength: 200
+                }
+            },
+            required: ['workspace', 'repository'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        if (!params.workspace || typeof params.workspace !== 'string' || params.workspace.trim() === '') {
+            throw new McpError(McpErrorCode.InvalidParams, 'Author identifier is required and cannot be empty');
+        }
+        if (!params.repository || typeof params.repository !== 'string' || params.repository.trim() === '') {
+            throw new McpError(McpErrorCode.InvalidParams, 'Repository name is required and cannot be empty');
+        }
+    }
+    async handleExecute(params) {
+        const author = params.workspace;
+        this.logger.info('GetRepositoryTool', `Getting repository ${params.repository} for author ${author}`);
+        try {
+            const result = await this.ucmClient.getRepository(author, params.repository);
+            this.logger.info('GetRepositoryTool', `Repository retrieved successfully: ${params.repository}`);
+            // Enhance the response with additional helpful information
+            const enhancedResult = {
+                success: true,
+                message: `Repository '${params.repository}' retrieved successfully for author '${author}'`,
+                repository: result,
+                webUrl: `${process.env.NEXT_PUBLIC_BASE_URL || 'http://localhost:3000'}/browse/${author}/${params.repository}`,
+                apiEndpoints: {
+                    browse: `/api/v1/authors/${author}/${params.repository}`,
+                    artifacts: `/api/v1/authors/${author}/${params.repository}/{category}/{subcategory}`,
+                    files: `/api/v1/files/${author}/${params.repository}/{category}/{subcategory}/{filename}`
+                }
+            };
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(enhancedResult, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            this.logger.error('GetRepositoryTool', 'Failed to get repository', '', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            // Handle specific error cases
+            if (errorMessage.includes('not found') || errorMessage.includes('404')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Repository '${params.repository}' not found for author '${author}'. Please verify the repository name and author identifier.`);
+            }
+            if (errorMessage.includes('403') || errorMessage.includes('Forbidden')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Access denied to repository '${params.repository}' for author '${author}'. You may not have permission to view this repository.`);
+            }
+            // Generic error
+            throw new McpError(McpErrorCode.InternalError, `Failed to retrieve repository: ${errorMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=GetRepositoryTool.js.map

package/dist/mcp-server/tools/repository/UpdateRepositoryTool.d.ts

@@ -0,0 +1,12 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class UpdateRepositoryTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: any): Promise<any>;
+}
+//# sourceMappingURL=UpdateRepositoryTool.d.ts.map

package/dist/mcp-server/tools/repository/UpdateRepositoryTool.js

@@ -0,0 +1,115 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class UpdateRepositoryTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'ucm_repository_update';
+    }
+    get description() {
+        const authorInfo = this.publishingAuthorId ? ` Your default workspace id is '${this.publishingAuthorId}'.` : '';
+        return `Update repository metadata including display name and description.${authorInfo}`;
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                workspace: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Workspace identifier: ${this.publishingAuthorId}` : 'Workspace identifier (e.g., "utaba", "1064600359")',
+                    minLength: 1,
+                    maxLength: 50
+                },
+                repository: {
+                    type: 'string',
+                    description: 'Repository to update (e.g., "main", "project-alpha") however the name will not change. Only the displayname can be updated after creation.',
+                    minLength: 1,
+                    maxLength: 200
+                },
+                displayName: {
+                    type: 'string',
+                    description: 'New human-readable display name for the repository (optional)',
+                    maxLength: 255
+                },
+                description: {
+                    type: 'string',
+                    description: 'New repository description (optional)',
+                    maxLength: 1000
+                }
+            },
+            required: ['workspace', 'repository'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        if (!params.workspace || typeof params.workspace !== 'string' || params.workspace.trim() === '') {
+            throw new McpError(McpErrorCode.InvalidParams, 'Author identifier is required and cannot be empty');
+        }
+        if (!params.repository || typeof params.repository !== 'string' || params.repository.trim() === '') {
+            throw new McpError(McpErrorCode.InvalidParams, 'Repository name is required and cannot be empty');
+        }
+        // Validate at least one field to update is provided
+        const updateFields = ['displayName', 'description'];
+        const hasUpdateField = updateFields.some(field => params[field] !== undefined);
+        if (!hasUpdateField) {
+            throw new McpError(McpErrorCode.InvalidParams, 'At least one field to update must be provided (displayName or description)');
+        }
+        // Validate displayName length if provided
+        if (params.displayName !== undefined && params.displayName.length > 255) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Display name cannot exceed 255 characters');
+        }
+        // Validate description length if provided
+        if (params.description !== undefined && params.description.length > 1000) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Description cannot exceed 1,000 characters');
+        }
+    }
+    async handleExecute(params) {
+        const author = params.workspace;
+        this.logger.info('UpdateRepositoryTool', `Updating repository ${params.repository} for author ${author}`);
+        try {
+            // Build update data from provided parameters
+            const updateData = {};
+            if (params.displayName !== undefined) {
+                updateData.displayName = params.displayName;
+            }
+            if (params.description !== undefined) {
+                updateData.description = params.description;
+            }
+            const result = await this.ucmClient.updateRepository(author, params.repository, updateData);
+            this.logger.info('UpdateRepositoryTool', `Repository updated successfully: ${params.repository}`);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            success: true,
+                            message: `Repository '${params.repository}' updated successfully for author '${author}'`,
+                            repository: result,
+                            updatedFields: Object.keys(updateData),
+                            webUrl: `${process.env.NEXT_PUBLIC_BASE_URL || 'http://localhost:3000'}/repository/${result.id || params.repository}/settings`
+                        }, null, 2)
+                    }
+                ]
+            };
+        }
+        catch (error) {
+            this.logger.error('UpdateRepositoryTool', 'Failed to update repository', '', error);
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            // Handle specific error cases
+            if (errorMessage.includes('not found') || errorMessage.includes('404')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Repository '${params.repository}' not found for author '${author}'. Please verify the repository name and author identifier.`);
+            }
+            if (errorMessage.includes('403') || errorMessage.includes('Forbidden')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Access denied to update repository '${params.repository}' for author '${author}'. You may not have permission to modify this repository.`);
+            }
+            if (errorMessage.includes('validation') || errorMessage.includes('invalid')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Repository update failed due to validation error: ${errorMessage}`);
+            }
+            // Generic error
+            throw new McpError(McpErrorCode.InternalError, `Failed to update repository: ${errorMessage}`);
+        }
+    }
+}
+//# sourceMappingURL=UpdateRepositoryTool.js.map

package/dist/mcp-server/tools/sharepoint/SharePointListConnectionsTool.d.ts

@@ -0,0 +1,19 @@
+/**
+ * ListConnectionsTool
+ * List all external connections available to the user
+ */
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmLocalApiClient } from '../../clients/UcmLocalApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class ListConnectionsTool extends BaseToolController {
+    constructor(ucmClient: UcmLocalApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected validateParams(params: any): void;
+    protected handleExecute(params: {
+        limit?: number;
+        offset?: number;
+    }): Promise<any>;
+}
+//# sourceMappingURL=SharePointListConnectionsTool.d.ts.map