@utaba/ucm-mcp-server 1.1.5 → 1.1.7

package/dist/clients/UcmApiClient.d.ts

@@ -30,13 +30,14 @@ export declare class UcmApiClient {
         limit?: number;
     }): Promise<ArtifactData[]>;
     searchArtifactsByText(searchParams: {
-        searchText: string;
+        searchText?: string;
         namespace?: string;
         author?: string;
         repository?: string;
         category?: string;
         subcategory?: string;
         filename?: string;
+        tags?: string;
         offset?: number;
         limit?: number;
     }): Promise<{
@@ -92,5 +93,19 @@ export declare class UcmApiClient {
         };
         _links?: any;
     }>;
+    submitFeedback(data: {
+        title: string;
+        body: string;
+        reportType: 'issue' | 'feedback';
+        tags?: string;
+    }): Promise<any>;
+    editArtifactMetadata(author: string, repository: string, category: string, subcategory: string, filename: string, data: {
+        updateDescription?: string;
+        updateNamespace?: string;
+        updateFilename?: string;
+        updateMimeType?: string;
+        updateTechnology?: string;
+        updateTags?: string;
+    }): Promise<any>;
 }
 //# sourceMappingURL=UcmApiClient.d.ts.map

package/dist/clients/UcmApiClient.js

@@ -188,7 +188,13 @@ export class UcmApiClient {
             // New API structure with query params
             Object.entries(data.queryParams).forEach(([key, value]) => {
                 if (value !== undefined && value !== null && value !== '') {
-                    params.append(key, String(value));
+                    // Handle arrays (e.g., tags) by JSON stringifying them
+                    if (Array.isArray(value)) {
+                        params.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        params.append(key, String(value));
+                    }
                 }
             });
             // Send raw content as text/plain body
@@ -216,7 +222,13 @@ export class UcmApiClient {
             // New API structure with query params
             Object.entries(data.queryParams).forEach(([key, value]) => {
                 if (value !== undefined && value !== null && value !== '') {
-                    params.append(key, String(value));
+                    // Handle arrays (e.g., tags) by JSON stringifying them
+                    if (Array.isArray(value)) {
+                        params.append(key, JSON.stringify(value));
+                    }
+                    else {
+                        params.append(key, String(value));
+                    }
                 }
             });
             // Send raw content as text/plain body
@@ -346,5 +358,16 @@ export class UcmApiClient {
         const response = await client.get(url);
         return response.data;
     }
+    async submitFeedback(data) {
+        const client = this.ensureClient();
+        const response = await client.post('/api/v1/feedback', data);
+        return response.data;
+    }
+    async editArtifactMetadata(author, repository, category, subcategory, filename, data) {
+        const client = this.ensureClient();
+        const url = this.buildApiPath('authors', author, repository, category, subcategory, filename) + '/edit';
+        const response = await client.post(url, data);
+        return response.data;
+    }
 }
 //# sourceMappingURL=UcmApiClient.js.map

package/dist/publish/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "ucm-mcp-server",
+    "version": "1.1.5",
+    "description": "Universal Context Manager MCP Server - AI-native artifact management",
+    "main": "dist/index.js",
+    "type": "module",
+    "bin": {
+        "ucm-mcp-server": "dist/index.js"
+    },
+    "keywords": [
+        "mcp",
+        "model-context-protocol",
+        "ucm",
+        "universal-context-manager",
+        "context-engineering",
+        "ai",
+        "context-manager",
+        "utaba"
+    ],
+    "author": {
+        "name": "Utaba AI",
+        "url": "https://utaba.ai"
+    },
+    "license": "BSD-3-Clause",
+    "homepage": "https://ucm.utaba.ai",
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.0",
+        "commander": "^14.0.0",
+        "axios": "^1.10.0"
+    },
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "publishConfig": {
+        "access": "public"
+    }
+}

package/dist/server/ToolRegistry.js

@@ -5,6 +5,7 @@ import { QuickstartTool } from '../tools/utility/QuickstartTool.js';
 import { AuthorIndexTool } from '../tools/utility/AuthorIndexTool.js';
 import { AuthorRecentsTool } from '../tools/utility/AuthorRecentsTool.js';
 import { ListRepositoriesTool } from '../tools/utility/ListRepositoriesTool.js';
+import { SubmitFeedbackTool } from '../tools/utility/SubmitFeedbackTool.js';
 // Import core tools
 import { GetArtifactTool } from '../tools/core/GetArtifactTool.js';
 import { GetChunkTool } from '../tools/core/GetChunkTool.js';
@@ -14,6 +15,7 @@ import { ListArtifactsTool } from '../tools/core/ListArtifactsTool.js';
 import { DeleteArtifactTool } from '../tools/core/DeleteArtifactTool.js';
 import { GetArtifactVersionsTool } from '../tools/core/GetArtifactVersionsTool.js';
 import { SearchArtifactsTool } from '../tools/core/SearchArtifactsTool.js';
+import { EditArtifactMetadataTool } from '../tools/core/EditArtifactMetadataTool.js';
 // Import repository tools
 import { CreateRepositoryTool } from '../tools/repository/CreateRepositoryTool.js';
 import { GetRepositoryTool } from '../tools/repository/GetRepositoryTool.js';
@@ -41,6 +43,7 @@ export class ToolRegistry {
         this.registerTool(new AuthorIndexTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new AuthorRecentsTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new ListRepositoriesTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new SubmitFeedbackTool(this.ucmClient, this.logger, this.authorId));
         // Register core tools
         this.registerTool(new GetArtifactTool(this.ucmClient, this.logger, this.authorId, this.trustedAuthors));
         this.registerTool(new GetChunkTool(this.ucmClient, this.logger, this.authorId));
@@ -50,6 +53,7 @@ export class ToolRegistry {
         this.registerTool(new DeleteArtifactTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new GetArtifactVersionsTool(this.ucmClient, this.logger, this.authorId));
         this.registerTool(new SearchArtifactsTool(this.ucmClient, this.logger, this.authorId));
+        this.registerTool(new EditArtifactMetadataTool(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));

package/dist/tools/core/EditArtifactMetadataTool.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 EditArtifactMetadataTool extends BaseToolController {
+    constructor(ucmClient: UcmApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected handleExecute(params: any): Promise<any>;
+    protected validateParams(params: any): void;
+}
+//# sourceMappingURL=EditArtifactMetadataTool.d.ts.map

package/dist/tools/core/EditArtifactMetadataTool.js

@@ -0,0 +1,173 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { parsePath } from '../../utils/PathUtils.js';
+import { McpError, McpErrorCode } from '../../utils/McpErrorHandler.js';
+export class EditArtifactMetadataTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'mcp_ucm_edit_artifact_metadata';
+    }
+    get description() {
+        return 'Edit artifact metadata and optionally move artifacts to new locations. Supports updating description, namespace, filename, MIME type, technology, and tags. Move operations affect all versions while metadata-only updates apply to latest version only.';
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: `Full artifact path (e.g., "${this.publishingAuthorId || '1234567890'}/main/commands/user/CreateUserCommand.ts")`,
+                    minLength: 1,
+                    maxLength: 250
+                },
+                updateDescription: {
+                    type: 'string',
+                    description: 'New description for the artifact (up to 1000 characters)',
+                    maxLength: 1000
+                },
+                updateNamespace: {
+                    type: 'string',
+                    description: 'New namespace path to move artifact to (e.g., "utaba/main/services/user")',
+                    maxLength: 200
+                },
+                updateFilename: {
+                    type: 'string',
+                    description: 'New filename for the artifact (e.g., "UserService.ts")',
+                    maxLength: 100
+                },
+                updateMimeType: {
+                    type: 'string',
+                    description: 'New MIME type for the artifact (e.g., "application/typescript")',
+                    maxLength: 100
+                },
+                updateTechnology: {
+                    type: 'string',
+                    description: 'New technology stack (e.g., "typescript", "python", "nextjs")',
+                    maxLength: 50
+                },
+                updateTags: {
+                    type: 'string',
+                    description: 'New comma-separated tags for categorization',
+                    maxLength: 500
+                }
+            },
+            required: ['path'],
+            additionalProperties: false
+        };
+    }
+    async handleExecute(params) {
+        const { path, updateDescription, updateNamespace, updateFilename, updateMimeType, updateTechnology, updateTags } = params;
+        this.logger.debug('EditArtifactMetadataTool', `Editing artifact metadata: ${path}`, '', {
+            hasDescriptionUpdate: !!updateDescription,
+            hasNamespaceUpdate: !!updateNamespace,
+            hasFilenameUpdate: !!updateFilename
+        });
+        try {
+            // Parse the current path to extract components
+            const pathComponents = parsePath(path);
+            // Validate path components exist including repository
+            if (!pathComponents.author || !pathComponents.repository || !pathComponents.category || !pathComponents.subcategory || !pathComponents.filename) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Path must contain author, repository, category, subcategory, and filename (e.g., "utaba/main/commands/user/CreateUserCommand.ts")');
+            }
+            // Validate that at least one update field is provided
+            const hasUpdates = !!(updateDescription || updateNamespace || updateFilename || updateMimeType || updateTechnology || updateTags);
+            if (!hasUpdates) {
+                throw new McpError(McpErrorCode.InvalidParams, 'At least one update field must be provided (updateDescription, updateNamespace, updateFilename, updateMimeType, updateTechnology, or updateTags)');
+            }
+            // Prepare the edit data
+            const editData = {};
+            if (updateDescription !== undefined)
+                editData.updateDescription = updateDescription;
+            if (updateNamespace !== undefined)
+                editData.updateNamespace = updateNamespace;
+            if (updateFilename !== undefined)
+                editData.updateFilename = updateFilename;
+            if (updateMimeType !== undefined)
+                editData.updateMimeType = updateMimeType;
+            if (updateTechnology !== undefined)
+                editData.updateTechnology = updateTechnology;
+            if (updateTags !== undefined)
+                editData.updateTags = updateTags;
+            // Call the API to edit the artifact metadata
+            const result = await this.ucmClient.editArtifactMetadata(pathComponents.author, pathComponents.repository, pathComponents.category, pathComponents.subcategory, pathComponents.filename, editData);
+            // Handle response structure - API might return wrapped in 'data' or direct
+            const responseData = result.data || result;
+            // Build successful response with operation details
+            const isMove = !!(updateNamespace || updateFilename);
+            const operation = isMove ? 'move' : 'metadata_update';
+            const response = {
+                success: true,
+                operation,
+                artifact: {
+                    originalPath: path,
+                    newPath: isMove ?
+                        `${updateNamespace || `${pathComponents.author}/${pathComponents.repository}/${pathComponents.category}/${pathComponents.subcategory}`}/${updateFilename || pathComponents.filename}` :
+                        path,
+                    updatedFields: Object.keys(editData),
+                    affectedVersions: responseData.affectedVersions || (isMove ? 'all' : 'latest'),
+                },
+                details: responseData.details || 'Artifact metadata updated successfully',
+                _links: responseData._links || {}
+            };
+            this.logger.info('EditArtifactMetadataTool', `Artifact edited successfully: ${path}`, '', {
+                operation,
+                updatedFields: Object.keys(editData),
+                affectedVersions: response.artifact.affectedVersions
+            });
+            return response;
+        }
+        catch (error) {
+            this.logger.error('EditArtifactMetadataTool', `Failed to edit artifact: ${path}`, '', error);
+            // Enhanced error handling for edit operations
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage?.includes('not found')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Artifact not found at path: ${path}. Please verify the path is correct and the artifact exists.`);
+            }
+            if (errorMessage?.includes('permission') || errorMessage?.includes('unauthorized')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Insufficient permissions to edit artifact at: ${path}. You must have write access to both source and destination namespaces for move operations.`);
+            }
+            if (errorMessage?.includes('destination already exists')) {
+                throw new McpError(McpErrorCode.InvalidParams, 'Destination artifact already exists. Choose a different filename or namespace for move operations.');
+            }
+            if (errorMessage?.includes('Invalid namespace format')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Invalid namespace format in updateNamespace. Must follow pattern "author/repository/category/subcategory". Example: "${this.publishingAuthorId || '0000000000'}/main/services/user"`);
+            }
+            if (errorMessage?.includes('Author not found')) {
+                throw new McpError(McpErrorCode.InvalidParams, `Author not found. Ensure the path uses a valid author identifier.`);
+            }
+            throw error;
+        }
+    }
+    validateParams(params) {
+        super.validateParams(params);
+        const { path, updateNamespace, updateFilename, updateDescription } = params;
+        // Validate path format
+        if (!path || typeof path !== 'string') {
+            throw new McpError(McpErrorCode.InvalidParams, 'path is required and must be a string');
+        }
+        // Basic path validation - should contain at least author/repository/category/subcategory/filename
+        const pathParts = path.split('/');
+        if (pathParts.length < 5) {
+            throw new McpError(McpErrorCode.InvalidParams, 'path must contain at least author/repository/category/subcategory/filename');
+        }
+        // Validate updateNamespace format if provided
+        if (updateNamespace && updateNamespace.length > 0) {
+            const namespaceParts = updateNamespace.split('/');
+            if (namespaceParts.length !== 4) {
+                throw new McpError(McpErrorCode.InvalidParams, 'updateNamespace must follow format "author/repository/category/subcategory"');
+            }
+        }
+        // Validate updateFilename if provided
+        if (updateFilename && updateFilename.length > 0) {
+            if (!/^[^\/\\:*?"<>|]+\.[a-zA-Z0-9]+$/.test(updateFilename)) {
+                throw new McpError(McpErrorCode.InvalidParams, 'updateFilename must be a valid filename with extension (e.g., "UserService.ts")');
+            }
+        }
+        // Validate description length
+        if (updateDescription && updateDescription.length > 1000) {
+            throw new McpError(McpErrorCode.InvalidParams, 'updateDescription cannot exceed 1000 characters');
+        }
+    }
+}
+//# sourceMappingURL=EditArtifactMetadataTool.js.map

package/dist/tools/core/PublishArtifactFromFileTool.js

@@ -49,13 +49,20 @@ export class PublishArtifactFromFileTool extends BaseToolController {
                 mimeType: {
                     type: 'string',
                     description: 'MIME type (auto-detected if not provided)'
+                },
+                tags: {
+                    type: 'array',
+                    description: 'Optional array of tags for categorization',
+                    items: {
+                        type: 'string'
+                    }
                 }
             },
             required: ['path', 'filename', 'fileUri']
         };
     }
     async handleExecute(params) {
-        const { path, filename, fileUri, description, version, technology, mimeType } = params;
+        const { path, filename, fileUri, description, version, technology, mimeType, tags } = params;
         this.logger.debug('PublishArtifactFromFileTool', `Publishing artifact from file: ${fileUri}`, '', {
             path: `${path}/${filename}`,
             version: version
@@ -89,7 +96,8 @@ export class PublishArtifactFromFileTool extends BaseToolController {
                     version: version ? version.replace(/^v/, '') : undefined, // Remove v prefix if present, undefined if not provided
                     description: description,
                     technology: technology,
-                    mimeType: mimeType || this.detectMimeType(filename)
+                    mimeType: mimeType || this.detectMimeType(filename),
+                    tags: tags
                 }
             };
             // Always use POST endpoint - the API will detect create vs update automatically

package/dist/tools/core/PublishArtifactTool.js

@@ -47,13 +47,20 @@ export class PublishArtifactTool extends BaseToolController {
                 mimeType: {
                     type: 'string',
                     description: 'MIME type (auto-detected if not provided)'
+                },
+                tags: {
+                    type: 'array',
+                    description: 'Optional array of tags for categorization',
+                    items: {
+                        type: 'string'
+                    }
                 }
             },
             required: ['path', 'filename', 'content']
         };
     }
     async handleExecute(params) {
-        const { path, filename, content, description, version, technology, mimeType } = params;
+        const { path, filename, content, description, version, technology, mimeType, tags } = params;
         this.logger.debug('PublishArtifactTool', `Publishing artifact: ${path}/${filename}`, '', {
             version: version,
             size: content.length
@@ -80,7 +87,8 @@ export class PublishArtifactTool extends BaseToolController {
                     version: version ? version.replace(/^v/, '') : undefined, // Remove v prefix if present, undefined if not provided
                     description: description,
                     technology: technology,
-                    mimeType: mimeType || this.detectMimeType(filename)
+                    mimeType: mimeType || this.detectMimeType(filename),
+                    tags: tags
                 }
             };
             // Always use POST endpoint - the API will detect create vs update automatically

package/dist/tools/core/SearchArtifactsTool.js

@@ -7,7 +7,7 @@ export class SearchArtifactsTool extends BaseToolController {
         return 'mcp_ucm_search_artifacts';
     }
     get description() {
-        return `Search artifacts by text across multiple metadata fields with privacy filtering. Searches namespace, filename, and description fields. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;
+        return `Search artifacts by text across multiple metadata fields with privacy filtering. Searches namespace, filename, description, and tags fields. ${this.publishingAuthorId ? "Your author value is '" + this.publishingAuthorId + "'" : ''}`;
     }
     get inputSchema() {
         return {
@@ -15,7 +15,7 @@ export class SearchArtifactsTool extends BaseToolController {
             properties: {
                 searchText: {
                     type: 'string',
-                    description: 'Required text to search across namespace, repository, category, subcategory, filename, and description (case-insensitive)',
+                    description: 'Text to search across namespace, repository, category, subcategory, filename, description, and tags (case-insensitive)',
                     minLength: 1,
                     maxLength: 200
                 },
@@ -49,6 +49,11 @@ export class SearchArtifactsTool extends BaseToolController {
                     description: 'Optional filename filter (e.g., "CreateUserCommand.ts")',
                     maxLength: 100
                 },
+                tags: {
+                    type: 'string',
+                    description: 'Optional tags filter - comma-separated list of tags to search for',
+                    maxLength: 500
+                },
                 offset: {
                     type: 'number',
                     description: 'Number of items to skip for pagination (default: 0)',
@@ -61,18 +66,20 @@ export class SearchArtifactsTool extends BaseToolController {
                     maximum: 100
                 }
             },
-            required: ['searchText']
+            required: []
         };
     }
     async handleExecute(params) {
-        const { searchText, namespace, author, repository, category, subcategory, filename, offset, limit } = params;
-        this.logger.debug('SearchArtifactsTool', `Searching for: "${searchText}" with filters`, '', {
+        const { searchText, namespace, author, repository, category, subcategory, filename, tags, offset, limit } = params;
+        this.logger.debug('SearchArtifactsTool', `Searching with filters`, '', {
+            searchText,
             namespace,
             author,
-            repository: repository || 'main',
+            repository,
             category,
             subcategory,
             filename,
+            tags,
             offset: offset || 0,
             limit: limit || 20
         });
@@ -82,28 +89,38 @@ export class SearchArtifactsTool extends BaseToolController {
                 searchText,
                 namespace,
                 author,
-                repository: repository || 'main', // Default to 'main' for MVP
+                repository, // Don't default to 'main' - let it search all repositories when undefined
                 category,
                 subcategory,
                 filename,
+                tags,
                 offset: offset || 0,
                 limit: limit || 20
             });
-            this.logger.info('SearchArtifactsTool', `Found ${response.data.length} artifacts matching: "${searchText}"`, '', {
+            this.logger.info('SearchArtifactsTool', `Found ${response.data.length} artifacts matching filters`, '', {
                 totalResults: response.pagination.total,
-                filters: { namespace, author, repository, category, subcategory, filename }
+                filters: { searchText, namespace, author, repository, category, subcategory, filename, tags }
             });
-            // Return structured search results
+            // Return structured search results (only include filters that were actually provided)
+            const appliedFilters = {};
+            if (searchText)
+                appliedFilters.searchText = searchText;
+            if (namespace)
+                appliedFilters.namespace = namespace;
+            if (author)
+                appliedFilters.author = author;
+            if (repository)
+                appliedFilters.repository = repository;
+            if (category)
+                appliedFilters.category = category;
+            if (subcategory)
+                appliedFilters.subcategory = subcategory;
+            if (filename)
+                appliedFilters.filename = filename;
+            if (tags)
+                appliedFilters.tags = tags;
             return {
-                searchText,
-                filters: {
-                    namespace,
-                    author,
-                    repository: repository || 'main',
-                    category,
-                    subcategory,
-                    filename
-                },
+                filters: appliedFilters,
                 results: response.data,
                 pagination: response.pagination,
                 hasMore: response.pagination.hasMore,
@@ -111,7 +128,7 @@ export class SearchArtifactsTool extends BaseToolController {
             };
         }
         catch (error) {
-            this.logger.error('SearchArtifactsTool', `Failed to search for: "${searchText}"`, '', error);
+            this.logger.error('SearchArtifactsTool', `Failed to search with provided filters`, '', error);
             throw error;
         }
     }

package/dist/tools/repository/CreateRepositoryTool.js

@@ -9,7 +9,7 @@ export class CreateRepositoryTool extends BaseToolController {
     }
     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}`;
+        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 {

package/dist/tools/repository/DeleteRepositoryGuidanceTool.js

@@ -10,8 +10,7 @@ export class DeleteRepositoryGuidanceTool extends BaseToolController {
         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}`;
+        return `Provides guidance for deleting a repository via the web UI.`;
     }
     get inputSchema() {
         return {

package/dist/tools/utility/HealthCheckController.js

@@ -1,4 +1,6 @@
 import { BaseToolController } from '../base/BaseToolController.js';
+//import packageJson from '../../../../publish/package.json' assert { type: 'json' };
+const version = '1.1.7'; //TODO: tried to sync this with packageJson but it didn't work.
 export class HealthCheckController extends BaseToolController {
     constructor(ucmClient, logger, publishingAuthorId) {
         super(ucmClient, logger, publishingAuthorId);
@@ -25,7 +27,8 @@ export class HealthCheckController extends BaseToolController {
                 mcpServer: {
                     status: 'running',
                     timestamp: new Date().toISOString(),
-                    uptime: process.uptime()
+                    uptime: process.uptime(),
+                    version: version
                 },
                 ucmApi: {
                     status: 'connected',
@@ -43,7 +46,8 @@ export class HealthCheckController extends BaseToolController {
                 mcpServer: {
                     status: 'running',
                     timestamp: new Date().toISOString(),
-                    uptime: process.uptime()
+                    uptime: process.uptime(),
+                    version: version
                 },
                 ucmApi: {
                     status: 'disconnected',

package/dist/tools/utility/SubmitFeedbackTool.d.ts

@@ -0,0 +1,16 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+import { UcmApiClient } from '../../clients/UcmApiClient.js';
+import { ILogger } from '../../interfaces/ILogger.js';
+export declare class SubmitFeedbackTool extends BaseToolController {
+    constructor(ucmClient: UcmApiClient, logger: ILogger, publishingAuthorId?: string);
+    get name(): string;
+    get description(): string;
+    get inputSchema(): any;
+    protected handleExecute(params: {
+        title: string;
+        body: string;
+        reportType: 'issue' | 'feedback';
+        tags?: string;
+    }): Promise<any>;
+}
+//# sourceMappingURL=SubmitFeedbackTool.d.ts.map

package/dist/tools/utility/SubmitFeedbackTool.js

@@ -0,0 +1,68 @@
+import { BaseToolController } from '../base/BaseToolController.js';
+export class SubmitFeedbackTool extends BaseToolController {
+    constructor(ucmClient, logger, publishingAuthorId) {
+        super(ucmClient, logger, publishingAuthorId);
+    }
+    get name() {
+        return 'mcp_ucm_submit_user_issue_or_feedback';
+    }
+    get description() {
+        return 'Submit user feedback, bug reports, feature requests ONLY if the user requests it and they want to send details to the UCM development team. Do NOT include sensitive or project related details. Ask the user before submitting the data if it is appropriate.';
+    }
+    get inputSchema() {
+        return {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Brief title for the feedback or issue (1-100 characters)',
+                    minLength: 1,
+                    maxLength: 100
+                },
+                body: {
+                    type: 'string',
+                    description: 'Detailed description of the feedback or issue (1-1000 characters)',
+                    minLength: 1,
+                    maxLength: 1000
+                },
+                reportType: {
+                    type: 'string',
+                    enum: ['issue', 'feedback'],
+                    description: 'Type of report: "issue" for bug reports and problems, "feedback" for feature requests and general feedback'
+                },
+                tags: {
+                    type: 'string',
+                    description: 'Optional comma-separated tags for categorization (e.g., "ui,bug,performance")',
+                    maxLength: 1000
+                }
+            },
+            required: ['title', 'body', 'reportType']
+        };
+    }
+    async handleExecute(params) {
+        this.logger.info('SubmitFeedbackTool', `Submitting ${params.reportType}: ${params.title}`);
+        try {
+            const result = await this.ucmClient.submitFeedback({
+                title: params.title,
+                body: params.body,
+                reportType: params.reportType,
+                tags: params.tags
+            });
+            this.logger.info('SubmitFeedbackTool', `Successfully submitted ${params.reportType} with ID: ${result.feedbackId}`);
+            return {
+                success: true,
+                feedbackId: result.feedbackId,
+                submittedAt: result.createdAt,
+                message: result.message,
+                reportType: params.reportType,
+                title: params.title
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this.logger.error('SubmitFeedbackTool', `Failed to submit ${params.reportType}: ${errorMessage}`, '', error);
+            throw error;
+        }
+    }
+}
+//# sourceMappingURL=SubmitFeedbackTool.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utaba/ucm-mcp-server",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Universal Context Manager MCP Server - AI-native artifact management",
   "main": "dist/index.js",
   "type": "module",

package/package.json.backup

@@ -1,6 +1,6 @@
 {
   "name": "ucm-mcp-server",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Universal Context Manager MCP Server - AI-native artifact management",
   "main": "dist/index.js",
   "type": "module",