@utaba/ucm-mcp-server 1.0.5 → 1.0.7

package/dist/clients/UcmApiClient.d.ts

@@ -49,5 +49,27 @@ export declare class UcmApiClient {
      * Check if the client is still available for use
      */
     isAvailable(): boolean;
+    createRepository(author: string, data: {
+        repositoryName: string;
+        displayName?: string;
+        description?: string;
+        isPublic?: boolean;
+    }): Promise<any>;
+    getRepository(author: string, repository: string): Promise<any>;
+    updateRepository(author: string, repository: string, data: {
+        displayName?: string;
+        description?: string;
+        isPublic?: boolean;
+    }): Promise<any>;
+    deleteRepository(author: string, repository: string): Promise<any>;
+    listRepositories(author: string, offset?: number, limit?: number): Promise<{
+        data: any[];
+        pagination: {
+            offset: number;
+            limit: number;
+            total: number;
+        };
+        _links?: any;
+    }>;
 }
 //# sourceMappingURL=UcmApiClient.d.ts.map

package/dist/clients/UcmApiClient.js

@@ -147,7 +147,7 @@ export class UcmApiClient {
         const queryString = params.toString();
         // Build URL based on provided parameters for exploratory browsing
         // Default repository to 'main' for MVP
-        const repo = repository || 'main';
+        const repo = repository;
         let metadataApiPath = this.buildApiPath('authors', author, repo, category, subcategory);
         metadataApiPath += queryString ? `?${queryString}` : '';
         const client = this.ensureClient();
@@ -293,5 +293,38 @@ export class UcmApiClient {
     isAvailable() {
         return this.client !== null;
     }
+    // Repository Management Methods
+    async createRepository(author, data) {
+        const client = this.ensureClient();
+        const response = await client.post(`/api/v1/authors/${author}`, data);
+        return response.data;
+    }
+    async getRepository(author, repository) {
+        const client = this.ensureClient();
+        const response = await client.get(`/api/v1/authors/${author}/${repository}`);
+        return response.data;
+    }
+    async updateRepository(author, repository, data) {
+        const client = this.ensureClient();
+        const response = await client.put(`/api/v1/authors/${author}/${repository}`, data);
+        return response.data;
+    }
+    async deleteRepository(author, repository) {
+        const client = this.ensureClient();
+        const response = await client.delete(`/api/v1/authors/${author}/${repository}`);
+        return response.data;
+    }
+    async listRepositories(author, offset, limit) {
+        const params = new URLSearchParams();
+        if (offset !== undefined)
+            params.append('offset', offset.toString());
+        if (limit !== undefined)
+            params.append('limit', limit.toString());
+        const queryString = params.toString();
+        const url = `/api/v1/authors/${author}${queryString ? `?${queryString}` : ''}`;
+        const client = this.ensureClient();
+        const response = await client.get(url);
+        return response.data;
+    }
 }
 //# sourceMappingURL=UcmApiClient.js.map

package/dist/index.js

@@ -6,13 +6,13 @@ import { McpConfig } from './server/McpConfig.js';
 import { LoggerFactory } from './logging/LoggerFactory.js';
 // Increase max listeners to prevent AbortSignal memory leak warnings
 // This is a safety net while we also implement proper cleanup
-EventEmitter.defaultMaxListeners = 20;
+EventEmitter.defaultMaxListeners = 40;
 async function main() {
     const program = new Command();
     program
         .name('ucm-mcp-server')
         .description('Universal Context Manager - Read the mcp_ucm_quickstart first to avoid mistakes')
-        .version('1.0.0')
+        .version('1.0.5')
         .option('-u, --ucm-url <url>', 'UCM API base URL (defaults to https://ucm.utaba.ai)')
         .option('-p, --port <port>', 'Server port', '3001')
         .option('--log-level <level>', 'Log level', 'ERROR')

package/dist/server/McpServer.js

@@ -15,7 +15,7 @@ export class McpServer {
         this.config = config;
         this.logger = logger;
         this.ucmClient = new UcmApiClient(config.ucmApiUrl, config.authToken, config.requestTimeout, config.authorId);
-        this.toolRegistry = new ToolRegistry(this.ucmClient, this.logger, config.trustedAuthors, config.authorId);
+        this.toolRegistry = new ToolRegistry(this.ucmClient, this.logger, config.trustedAuthors, config.authorId, config.ucmApiUrl);
         this.handler = new McpHandler(this.toolRegistry, this.logger, config.authorId);
         this.server = new Server({
             name: 'ucm-mcp-server',

package/dist/server/ToolRegistry.d.ts

@@ -10,8 +10,9 @@ export declare class ToolRegistry {
     private logger;
     private trustedAuthors;
     private authorId?;
+    private baseUrl?;
     private tools;
-    constructor(ucmClient: UcmApiClient, logger: ILogger, trustedAuthors?: string[], authorId?: string | undefined);
+    constructor(ucmClient: UcmApiClient, logger: ILogger, trustedAuthors?: string[], authorId?: string | undefined, baseUrl?: string | undefined);
     private registerTools;
     private registerTool;
     listTools(): Promise<ToolInfo[]>;

package/dist/server/ToolRegistry.js

@@ -12,17 +12,24 @@ import { PublishArtifactFromFileTool } from '../tools/core/PublishArtifactFromFi
 import { ListArtifactsTool } from '../tools/core/ListArtifactsTool.js';
 import { DeleteArtifactTool } from '../tools/core/DeleteArtifactTool.js';
 import { GetArtifactVersionsTool } from '../tools/core/GetArtifactVersionsTool.js';
+// Import repository tools
+import { CreateRepositoryTool } from '../tools/repository/CreateRepositoryTool.js';
+import { GetRepositoryTool } from '../tools/repository/GetRepositoryTool.js';
+import { UpdateRepositoryTool } from '../tools/repository/UpdateRepositoryTool.js';
+import { DeleteRepositoryGuidanceTool } from '../tools/repository/DeleteRepositoryGuidanceTool.js';
 export class ToolRegistry {
     ucmClient;
     logger;
     trustedAuthors;
     authorId;
+    baseUrl;
     tools = new Map();
-    constructor(ucmClient, logger, trustedAuthors = [], authorId) {
+    constructor(ucmClient, logger, trustedAuthors = [], authorId, baseUrl) {
         this.ucmClient = ucmClient;
         this.logger = logger;
         this.trustedAuthors = trustedAuthors;
         this.authorId = authorId;
+        this.baseUrl = baseUrl;
         this.registerTools();
     }
     registerTools() {
@@ -39,6 +46,11 @@ export class ToolRegistry {
         this.registerTool(new ListArtifactsTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new DeleteArtifactTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new GetArtifactVersionsTool(this.ucmClient, this.logger, this.authorId));
+        // Register repository tools
+        this.registerTool(new CreateRepositoryTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new GetRepositoryTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new UpdateRepositoryTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new DeleteRepositoryGuidanceTool(this.ucmClient, this.logger, this.authorId, this.baseUrl));
         this.logger.info('ToolRegistry', `Registered ${this.tools.size} MCP tools`);
     }
     registerTool(tool) {

package/dist/tools/core/ListArtifactsTool.js

@@ -8,7 +8,7 @@ export class ListArtifactsTool extends BaseToolController {
         return 'mcp_ucm_list_artifacts';
     }
     get description() {
-        return `List artifacts with exploratory browsing support. Can list author categories, subcategories, or artifacts depending on path depth. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;
+        return `List artifacts with exploratory browsing support. Can list authors, repositories, categories, subcategories, or artifacts depending on path depth. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;
     }
     get inputSchema() {
         return {
@@ -61,9 +61,9 @@ export class ListArtifactsTool extends BaseToolController {
                 listingType = 'subcategories';
             }
             // For MVP, validate repository is 'main' if provided
-            if (pathSegments.length >= 2 && pathComponents.repository && pathComponents.repository !== 'main') {
-                throw new Error(`Repository must be 'main' for MVP. Received: "${pathComponents.repository}"`);
-            }
+            // if (pathSegments.length >= 2 && pathComponents.repository && pathComponents.repository !== 'main') {
+            //   throw new Error(`Repository must be 'main' for MVP. Received: "${pathComponents.repository}"`);
+            // }
             this.logger.info('ListArtifactsTool', `Listed ${response.data.length} ${listingType} in: ${path}`);
             // Return the full response with pagination metadata and context
             return {

package/dist/tools/core/PublishArtifactFromFileTool.js

@@ -75,9 +75,12 @@ export class PublishArtifactFromFileTool extends BaseToolController {
                 throw new McpError(McpErrorCode.InvalidParams, `Path must contain author, repository, category, and subcategory (e.g., "${this.publishingAuthorId || '1234567890'}/main/commands/user")`);
             }
             // Validate repository is 'main' for MVP
-            if (pathComponents.repository !== 'main') {
-                throw new McpError(McpErrorCode.InvalidParams, `Repository must be 'main' for MVP. Received: "${pathComponents.repository}"`);
-            }
+            // if (pathComponents.repository !== 'main') {
+            //   throw new McpError(
+            //     McpErrorCode.InvalidParams,
+            //     `Repository must be 'main' for MVP. Received: "${pathComponents.repository}"`
+            //   );
+            // }
             // Prepare the publish data - new API expects content in body and metadata in query params
             const publishData = {
                 content, // Raw text content from file

package/dist/tools/core/PublishArtifactTool.js

@@ -66,9 +66,12 @@ export class PublishArtifactTool extends BaseToolController {
                 throw new McpError(McpErrorCode.InvalidParams, 'Path must contain author, repository, category, and subcategory (e.g., "utaba/main/commands/user")');
             }
             // Validate repository is 'main' for MVP
-            if (pathComponents.repository !== 'main') {
-                throw new McpError(McpErrorCode.InvalidParams, `Repository must be 'main' for MVP. Received: "${pathComponents.repository}"`);
-            }
+            // if (pathComponents.repository !== 'main') {
+            //   throw new McpError(
+            //     McpErrorCode.InvalidParams,
+            //     `Repository must be 'main' for MVP. Received: "${pathComponents.repository}"`
+            //   );
+            // }
             // Prepare the publish data - new API expects content in body and metadata in query params
             const publishData = {
                 content, // Raw text content

package/dist/tools/repository/CreateRepositoryTool.d.ts

@@ -0,0 +1,12 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmApiClient } from '../../clients/UcmApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class CreateRepositoryTool extends BaseToolController {
+    constructor(ucmClient: UcmApiClient, 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/tools/repository/CreateRepositoryTool.js

@@ -0,0 +1,125 @@
+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 'mcp_ucm_create_repository';
+    }
+    get description() {
+        const authorInfo = this.publishingAuthorId ? ` Your author id is '${this.publishingAuthorId}'.` : '';
+        return `Create a new repository for a specific author. Repository names must be unique within the author namespace 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: {
+                author: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Author identifier: ${this.publishingAuthorId}` : 'Author 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
+                },
+                isPublic: {
+                    type: 'boolean',
+                    description: 'Whether the repository is public (defaults to false, public repositories not yet supported)',
+                    default: false
+                }
+            },
+            required: ['author', 'repositoryName'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        // Additional validation
+        if (!params.author || typeof params.author !== 'string' || params.author.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');
+        }
+        // Validate isPublic - public repositories are not yet supported
+        if (params.isPublic === true) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Public repositories are not yet supported. Set isPublic to false or omit the parameter.');
+        }
+    }
+    async handleExecute(params) {
+        this.logger.info('CreateRepositoryTool', `Creating repository ${params.repositoryName} for author ${params.author}`);
+        try {
+            const repositoryData = {
+                repositoryName: params.repositoryName,
+                displayName: params.displayName,
+                description: params.description,
+                isPublic: params.isPublic || false
+            };
+            const result = await this.ucmClient.createRepository(params.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 '${params.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 '${params.author}'. Please choose a different name.`);
+            }
+            if (errorMessage.includes('not found') || errorMessage.includes('404')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Author '${params.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/tools/repository/DeleteRepositoryGuidanceTool.d.ts

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

package/dist/tools/repository/DeleteRepositoryGuidanceTool.js

@@ -0,0 +1,94 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class DeleteRepositoryGuidanceTool extends BaseToolController {
+    baseUrl;
+    constructor(ucmClient, logger, publishingAuthorId, baseUrl) {
+        super(ucmClient, logger, publishingAuthorId);
+        this.baseUrl = baseUrl;
+    }
+    get name() {
+        return 'mcp_ucm_delete_repository_guidance';
+    }
+    get description() {
+        const authorInfo = this.publishingAuthorId ? ` Your author id is '${this.publishingAuthorId}'.` : '';
+        return `Provides guidance for deleting a repository via the web UI. Repository deletion is intentionally not available through the MCP tools to prevent accidental deletion. This tool returns the web URL where the user can safely delete the repository with proper confirmation dialogs.${authorInfo}`;
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                author: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Author identifier: ${this.publishingAuthorId}` : 'Author identifier (e.g., "utaba", "1064600359")',
+                    minLength: 1,
+                    maxLength: 50
+                },
+                repository: {
+                    type: 'string',
+                    description: 'Repository name to delete (e.g., "main", "project-alpha")',
+                    minLength: 1,
+                    maxLength: 200
+                }
+            },
+            required: ['author', 'repository'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        if (!params.author || typeof params.author !== 'string' || params.author.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) {
+        this.logger.info('DeleteRepositoryGuidanceTool', `Providing delete guidance for repository ${params.repository} for author ${params.author}`);
+        // Get the base URL for the web interface
+        const baseUrl = this.baseUrl;
+        const repositorySettingsUrl = `${baseUrl}/repository/${params.repository}/settings`;
+        const browseUrl = `${baseUrl}/browse/${params.author}`;
+        const guidance = {
+            action: 'delete_repository_guidance',
+            repository: {
+                author: params.author,
+                name: params.repository
+            },
+            message: `Repository deletion must be performed through the web interface for safety.`,
+            reason: 'Repository deletion is intentionally not available through MCP tools to prevent accidental deletion of valuable content.',
+            instructions: [
+                `1. Open the repository settings page: ${repositorySettingsUrl}`,
+                `2. Scroll to the "Danger Zone" section`,
+                `3. Click "Delete Repository" button`,
+                `4. Confirm the deletion by typing the repository name`,
+                `5. Click "Delete" to permanently remove the repository`
+            ],
+            urls: {
+                repositorySettings: repositorySettingsUrl,
+                authorRepositories: browseUrl
+            },
+            warnings: [
+                'Repository deletion is permanent and cannot be undone',
+                'All artifacts and content in the repository will be permanently lost',
+                'Any links or references to this repository will become invalid',
+                'Make sure to backup any important content before deletion'
+            ],
+            alternatives: [
+                'Consider renaming the repository instead of deleting it',
+                'Archive the repository by updating its description to indicate it is archived',
+                'Move important artifacts to another repository before deletion'
+            ]
+        };
+        this.logger.info('DeleteRepositoryGuidanceTool', `Delete guidance provided for repository: ${params.repository}`);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(guidance, null, 2)
+                }
+            ]
+        };
+    }
+}
+//# sourceMappingURL=DeleteRepositoryGuidanceTool.js.map

package/dist/tools/repository/GetRepositoryTool.d.ts

@@ -0,0 +1,12 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmApiClient } from '../../clients/UcmApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class GetRepositoryTool extends BaseToolController {
+    constructor(ucmClient: UcmApiClient, 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/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 'mcp_ucm_get_repository';
+    }
+    get description() {
+        const authorInfo = this.publishingAuthorId ? ` Your author id is '${this.publishingAuthorId}'.` : '';
+        return `Get detailed information about a specific repository, including metadata, statistics, and available categories. Returns repository details along with its content structure.${authorInfo}`;
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                author: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Author identifier: ${this.publishingAuthorId}` : 'Author 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: ['author', 'repository'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        if (!params.author || typeof params.author !== 'string' || params.author.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) {
+        this.logger.info('GetRepositoryTool', `Getting repository ${params.repository} for author ${params.author}`);
+        try {
+            const result = await this.ucmClient.getRepository(params.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 '${params.author}'`,
+                repository: result,
+                webUrl: `${process.env.NEXT_PUBLIC_BASE_URL || 'http://localhost:3000'}/browse/${params.author}/${params.repository}`,
+                apiEndpoints: {
+                    browse: `/api/v1/authors/${params.author}/${params.repository}`,
+                    artifacts: `/api/v1/authors/${params.author}/${params.repository}/{category}/{subcategory}`,
+                    files: `/api/v1/files/${params.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 '${params.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 '${params.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/tools/repository/UpdateRepositoryTool.d.ts

@@ -0,0 +1,12 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmApiClient } from '../../clients/UcmApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class UpdateRepositoryTool extends BaseToolController {
+    constructor(ucmClient: UcmApiClient, 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/tools/repository/UpdateRepositoryTool.js

@@ -0,0 +1,125 @@
+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 'mcp_ucm_update_repository';
+    }
+    get description() {
+        const authorInfo = this.publishingAuthorId ? ` Your author id is '${this.publishingAuthorId}'.` : '';
+        return `Update repository metadata including display name, description, and visibility settings. Note: Repository names cannot be changed after creation as they serve as permanent identifiers in the namespace path.${authorInfo}`;
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                author: {
+                    type: 'string',
+                    description: this.publishingAuthorId ? `Author identifier: ${this.publishingAuthorId}` : 'Author 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
+                },
+                isPublic: {
+                    type: 'boolean',
+                    description: 'Whether the repository should be public (currently not supported, must be false)'
+                }
+            },
+            required: ['author', 'repository'],
+            additionalProperties: false
+        };
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        if (!params.author || typeof params.author !== 'string' || params.author.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', 'isPublic'];
+        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, description, or isPublic)');
+        }
+        // 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');
+        }
+        // Validate isPublic - public repositories are not yet supported
+        if (params.isPublic === true) {
+            throw new McpError(McpErrorCode.InvalidParams, 'Public repositories are not yet supported. Set isPublic to false or omit the parameter.');
+        }
+    }
+    async handleExecute(params) {
+        this.logger.info('UpdateRepositoryTool', `Updating repository ${params.repository} for author ${params.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;
+            }
+            if (params.isPublic !== undefined) {
+                updateData.isPublic = params.isPublic;
+            }
+            const result = await this.ucmClient.updateRepository(params.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 '${params.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 '${params.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 '${params.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/tools/utility/ListRepositoriesTool.js

@@ -41,11 +41,8 @@ export class ListRepositoriesTool extends BaseToolController {
             limit: limit || 'default'
         });
         try {
-            // Use listArtifacts with just author to get repositories
-            const response = await this.ucmClient.listArtifacts(author, undefined, // no repository - this will list repositories
-            undefined, // no category
-            undefined, // no subcategory
-            offset, limit);
+            // Use listRepositories to get repositories for the author
+            const response = await this.ucmClient.listRepositories(author, offset, limit);
             this.logger.info('ListRepositoriesTool', `Listed ${response.data.length} repositories for author: ${author}`, '', {
                 total: response.pagination?.total,
                 offset: response.pagination?.offset,

package/dist/tools/utility/QuickstartTool.js

@@ -7,7 +7,7 @@ export class QuickstartTool extends BaseToolController {
         return 'mcp_ucm_quickstart';
     }
     get description() {
-        return '**IMPORTANT** READ THIS FIRST before using any other tools as it will guide you to understand how to use the UCM system and MCP tools effectively';
+        return 'IMPORTANT: READ THIS FIRST before using any other tools as it will guide you to understand how to use the UCM system and MCP tools effectively';
     }
     get inputSchema() {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utaba/ucm-mcp-server",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Universal Context Manager MCP Server - AI-native artifact management",
   "main": "dist/index.js",
   "type": "module",
@@ -12,9 +12,9 @@
     "model-context-protocol",
     "ucm",
     "universal-context-manager",
+    "context-engineering",
     "ai",
     "context-manager",
-    "micro-blocks",
     "utaba"
   ],
   "author": {

package/package.json.backup

@@ -1,6 +1,6 @@
 {
   "name": "ucm-mcp-server",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Universal Context Manager MCP Server - AI-native artifact management",
   "main": "dist/index.js",
   "type": "module",
@@ -12,9 +12,9 @@
     "model-context-protocol",
     "ucm",
     "universal-context-manager",
+    "context-engineering",
     "ai",
     "context-manager",
-    "micro-blocks",
     "utaba"
   ],
   "author": {