snow-flow 3.2.3 → 3.3.1

package/dist/mcp/servicenow-knowledge-catalog-mcp-enhanced.js

@@ -0,0 +1,709 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ServiceNow Knowledge Management & Service Catalog MCP Server - ENHANCED VERSION
+ * With logging, token tracking, and progress indicators
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const enhanced_base_mcp_server_js_1 = require("./shared/enhanced-base-mcp-server.js");
+const mcp_config_manager_js_1 = require("../utils/mcp-config-manager.js");
+class ServiceNowKnowledgeCatalogMCPEnhanced extends enhanced_base_mcp_server_js_1.EnhancedBaseMCPServer {
+    constructor() {
+        super('servicenow-knowledge-catalog-enhanced', '2.0.0');
+        this.config = mcp_config_manager_js_1.mcpConfig.getConfig();
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [
+                // Knowledge Management Tools
+                {
+                    name: 'snow_create_knowledge_article',
+                    description: 'Creates a knowledge article in ServiceNow Knowledge Base using kb_knowledge table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            short_description: { type: 'string', description: 'Article title' },
+                            text: { type: 'string', description: 'Article content (HTML supported)' },
+                            kb_knowledge_base: { type: 'string', description: 'Knowledge base sys_id or name' },
+                            kb_category: { type: 'string', description: 'Category sys_id or name' },
+                            article_type: { type: 'string', description: 'Type: text, html, wiki' },
+                            workflow_state: { type: 'string', description: 'State: draft, review, published, retired' },
+                            valid_to: { type: 'string', description: 'Expiration date (YYYY-MM-DD)' },
+                            meta_description: { type: 'string', description: 'SEO meta description' },
+                            keywords: { type: 'array', items: { type: 'string' }, description: 'Search keywords' },
+                            author: { type: 'string', description: 'Author user sys_id or username' }
+                        },
+                        required: ['short_description', 'text']
+                    }
+                },
+                {
+                    name: 'snow_search_knowledge',
+                    description: 'Searches knowledge articles in kb_knowledge table with full-text search.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Search query text' },
+                            kb_knowledge_base: { type: 'string', description: 'Filter by knowledge base' },
+                            kb_category: { type: 'string', description: 'Filter by category' },
+                            workflow_state: { type: 'string', description: 'Filter by state (published, draft, etc.)' },
+                            limit: { type: 'number', description: 'Maximum results to return', default: 10 },
+                            include_content: { type: 'boolean', description: 'Include full article content', default: false }
+                        },
+                        required: ['query']
+                    }
+                },
+                {
+                    name: 'snow_update_knowledge_article',
+                    description: 'Updates existing knowledge article in kb_knowledge table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: { type: 'string', description: 'Article sys_id to update' },
+                            short_description: { type: 'string', description: 'Article title' },
+                            text: { type: 'string', description: 'Article content' },
+                            workflow_state: { type: 'string', description: 'State: draft, review, published' },
+                            valid_to: { type: 'string', description: 'Expiration date' },
+                            keywords: { type: 'array', items: { type: 'string' } }
+                        },
+                        required: ['sys_id']
+                    }
+                },
+                {
+                    name: 'snow_retire_knowledge_article',
+                    description: 'Retires knowledge article by setting workflow_state to retired in kb_knowledge table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: { type: 'string', description: 'Article sys_id' },
+                            retirement_reason: { type: 'string', description: 'Reason for retirement' }
+                        },
+                        required: ['sys_id']
+                    }
+                },
+                {
+                    name: 'snow_create_knowledge_base',
+                    description: 'Creates new knowledge base using kb_knowledge_base table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            title: { type: 'string', description: 'Knowledge base name' },
+                            description: { type: 'string', description: 'KB description' },
+                            owner: { type: 'string', description: 'Owner user/group' },
+                            kb_managers: { type: 'array', items: { type: 'string' } }
+                        },
+                        required: ['title']
+                    }
+                },
+                {
+                    name: 'snow_discover_knowledge_bases',
+                    description: 'Lists all knowledge bases from kb_knowledge_base table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            active_only: { type: 'boolean', default: true }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_get_knowledge_stats',
+                    description: 'Gets statistics for knowledge articles from kb_knowledge table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            kb_knowledge_base: { type: 'string', description: 'Filter by KB' },
+                            date_range: { type: 'string', description: 'Date range filter' }
+                        }
+                    }
+                },
+                {
+                    name: 'snow_knowledge_feedback',
+                    description: 'Manages feedback for knowledge articles using kb_feedback table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            article_id: { type: 'string', description: 'Article sys_id' },
+                            rating: { type: 'number', description: 'Rating 1-5' },
+                            comments: { type: 'string', description: 'Feedback comments' }
+                        },
+                        required: ['article_id']
+                    }
+                },
+                // Service Catalog Tools
+                {
+                    name: 'snow_create_catalog_item',
+                    description: 'Creates service catalog item using sc_cat_item table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            name: { type: 'string', description: 'Catalog item name' },
+                            short_description: { type: 'string', description: 'Brief description' },
+                            category: { type: 'string', description: 'Category sys_id' },
+                            price: { type: 'string', description: 'Item price' },
+                            workflow: { type: 'string', description: 'Fulfillment workflow' }
+                        },
+                        required: ['name', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_create_catalog_variable',
+                    description: 'Creates variables for catalog items using item_option_new table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cat_item: { type: 'string', description: 'Catalog item sys_id' },
+                            name: { type: 'string', description: 'Variable name' },
+                            question_text: { type: 'string', description: 'Question to display' },
+                            type: { type: 'string', description: 'Variable type' },
+                            mandatory: { type: 'boolean', default: false }
+                        },
+                        required: ['cat_item', 'name', 'question_text']
+                    }
+                },
+                {
+                    name: 'snow_create_catalog_ui_policy',
+                    description: 'Creates UI policies for catalog items using catalog_ui_policy table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cat_item: { type: 'string', description: 'Catalog item sys_id' },
+                            short_description: { type: 'string', description: 'Policy name' },
+                            condition: { type: 'string', description: 'When to apply' },
+                            actions: { type: 'array', items: { type: 'object' } }
+                        },
+                        required: ['cat_item', 'short_description']
+                    }
+                },
+                {
+                    name: 'snow_order_catalog_item',
+                    description: 'Submits catalog item order using sc_req_item table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            cat_item: { type: 'string', description: 'Catalog item sys_id' },
+                            requested_for: { type: 'string', description: 'User sys_id' },
+                            variables: { type: 'object', description: 'Variable values' },
+                            quantity: { type: 'number', default: 1 }
+                        },
+                        required: ['cat_item']
+                    }
+                },
+                {
+                    name: 'snow_search_catalog',
+                    description: 'Searches service catalog items in sc_cat_item table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            query: { type: 'string', description: 'Search text' },
+                            category: { type: 'string', description: 'Filter by category' },
+                            active_only: { type: 'boolean', default: true },
+                            limit: { type: 'number', default: 10 }
+                        },
+                        required: ['query']
+                    }
+                },
+                {
+                    name: 'snow_get_catalog_item_details',
+                    description: 'Gets full details of catalog item from sc_cat_item table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: { type: 'string', description: 'Catalog item sys_id' },
+                            include_variables: { type: 'boolean', default: true }
+                        },
+                        required: ['sys_id']
+                    }
+                },
+                {
+                    name: 'snow_discover_catalogs',
+                    description: 'Discovers catalog structure from sc_catalog table.',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            include_categories: { type: 'boolean', default: true }
+                        }
+                    }
+                }
+            ]
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            try {
+                const { name, arguments: args } = request.params;
+                // Execute with enhanced tracking
+                return await this.executeTool(name, async () => {
+                    switch (name) {
+                        case 'snow_create_knowledge_article':
+                            return await this.createKnowledgeArticle(args);
+                        case 'snow_search_knowledge':
+                            return await this.searchKnowledge(args);
+                        case 'snow_update_knowledge_article':
+                            return await this.updateKnowledgeArticle(args);
+                        case 'snow_retire_knowledge_article':
+                            return await this.retireKnowledgeArticle(args);
+                        case 'snow_create_knowledge_base':
+                            return await this.createKnowledgeBase(args);
+                        case 'snow_discover_knowledge_bases':
+                            return await this.discoverKnowledgeBases(args);
+                        case 'snow_get_knowledge_stats':
+                            return await this.getKnowledgeStats(args);
+                        case 'snow_knowledge_feedback':
+                            return await this.knowledgeFeedback(args);
+                        case 'snow_create_catalog_item':
+                            return await this.createCatalogItem(args);
+                        case 'snow_create_catalog_variable':
+                            return await this.createCatalogVariable(args);
+                        case 'snow_create_catalog_ui_policy':
+                            return await this.createCatalogUIPolicy(args);
+                        case 'snow_order_catalog_item':
+                            return await this.orderCatalogItem(args);
+                        case 'snow_search_catalog':
+                            return await this.searchCatalog(args);
+                        case 'snow_get_catalog_item_details':
+                            return await this.getCatalogItemDetails(args);
+                        case 'snow_discover_catalogs':
+                            return await this.discoverCatalogs(args);
+                        default:
+                            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                    }
+                });
+            }
+            catch (error) {
+                if (error instanceof types_js_1.McpError)
+                    throw error;
+                throw new types_js_1.McpError(types_js_1.ErrorCode.InternalError, `Tool execution failed: ${error}`);
+            }
+        });
+    }
+    /**
+     * Create Knowledge Article with enhanced tracking
+     */
+    async createKnowledgeArticle(args) {
+        this.logger.info('Creating knowledge article...', {
+            title: args.short_description,
+            hasContent: !!args.text,
+            contentLength: args.text?.length
+        });
+        // Validate connection
+        const connCheck = await this.validateConnection();
+        if (!connCheck.success) {
+            return this.createResponse(`❌ Connection failed: ${connCheck.error}`);
+        }
+        // Progress indicator
+        this.logger.progress('Building knowledge article data...');
+        const articleData = {
+            short_description: args.short_description,
+            text: args.text,
+            kb_knowledge_base: args.kb_knowledge_base || '',
+            kb_category: args.kb_category || '',
+            article_type: args.article_type || 'text',
+            workflow_state: args.workflow_state || 'draft',
+            valid_to: args.valid_to || '',
+            meta_description: args.meta_description || '',
+            keywords: args.keywords?.join(',') || '',
+            author: args.author || ''
+        };
+        this.logger.progress('Creating article in ServiceNow...');
+        // Create with tracking
+        const response = await this.createRecord('kb_knowledge', articleData);
+        if (!response.success) {
+            this.logger.error('Failed to create knowledge article', response.error);
+            return this.createResponse(`❌ Failed to create article: ${response.error}`);
+        }
+        // Success with details
+        const result = response.data;
+        this.logger.info('✅ Knowledge article created successfully', {
+            sys_id: result.sys_id,
+            number: result.number,
+            title: args.short_description
+        });
+        return this.createResponse(`✅ Knowledge Article created successfully!
+
+📚 **${args.short_description}**
+🆔 sys_id: ${result.sys_id}
+📋 Number: ${result.number}
+📊 State: ${args.workflow_state || 'draft'}
+📝 Type: ${args.article_type || 'text'}
+${args.kb_knowledge_base ? `📁 Knowledge Base: ${args.kb_knowledge_base}` : ''}
+${args.kb_category ? `🏷️ Category: ${args.kb_category}` : ''}
+${args.valid_to ? `📅 Valid Until: ${args.valid_to}` : ''}
+
+✨ Article created and ready for review!`);
+    }
+    /**
+     * Search Knowledge with enhanced tracking
+     */
+    async searchKnowledge(args) {
+        this.logger.info('Searching knowledge articles...', {
+            query: args.query,
+            limit: args.limit || 10,
+            includeContent: args.include_content
+        });
+        // Build query
+        let query = `short_descriptionLIKE${args.query}^ORtextLIKE${args.query}`;
+        if (args.kb_knowledge_base) {
+            query += `^kb_knowledge_base=${args.kb_knowledge_base}`;
+        }
+        if (args.kb_category) {
+            query += `^kb_category=${args.kb_category}`;
+        }
+        if (args.workflow_state) {
+            query += `^workflow_state=${args.workflow_state}`;
+        }
+        else {
+            query += '^workflow_state=published'; // Default to published only
+        }
+        this.logger.progress(`Searching kb_knowledge table for: "${args.query}"...`);
+        // Search with tracking
+        const limit = args.limit || 10;
+        const response = await this.queryTable('kb_knowledge', query, limit);
+        if (!response.success) {
+            this.logger.error('Knowledge search failed', response.error);
+            return this.createResponse(`❌ Search failed: ${response.error}`);
+        }
+        const articles = response.data.result;
+        if (!articles.length) {
+            this.logger.info('No articles found', { query: args.query });
+            return this.createResponse(`❌ No knowledge articles found matching "${args.query}"`);
+        }
+        this.logger.info(`Found ${articles.length} knowledge articles`);
+        // Format results
+        const articleList = articles.map((article) => {
+            const snippet = args.include_content ?
+                article.text?.substring(0, 200) + '...' :
+                article.short_description;
+            return `📄 **${article.short_description}**
+🆔 ${article.sys_id}
+📊 State: ${article.workflow_state}
+📅 Updated: ${article.sys_updated_on}
+${args.include_content ? `📝 ${snippet}` : ''}`;
+        }).join('\n\n');
+        return this.createResponse(`🔍 Knowledge Search Results for "${args.query}":
+
+${articleList}
+
+✨ Found ${articles.length} article(s)`);
+    }
+    /**
+     * Update Knowledge Article
+     */
+    async updateKnowledgeArticle(args) {
+        this.logger.info('Updating knowledge article...', { sys_id: args.sys_id });
+        const updateData = {};
+        if (args.short_description)
+            updateData.short_description = args.short_description;
+        if (args.text)
+            updateData.text = args.text;
+        if (args.workflow_state)
+            updateData.workflow_state = args.workflow_state;
+        if (args.valid_to)
+            updateData.valid_to = args.valid_to;
+        if (args.keywords)
+            updateData.keywords = args.keywords.join(',');
+        this.logger.progress('Updating article in ServiceNow...');
+        const response = await this.updateRecord('kb_knowledge', args.sys_id, updateData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to update article: ${response.error}`);
+        }
+        this.logger.info('✅ Article updated successfully');
+        return this.createResponse(`✅ Knowledge article updated successfully!\n🆔 sys_id: ${args.sys_id}`);
+    }
+    /**
+     * Retire Knowledge Article
+     */
+    async retireKnowledgeArticle(args) {
+        this.logger.info('Retiring knowledge article...', { sys_id: args.sys_id });
+        const updateData = {
+            workflow_state: 'retired',
+            u_retirement_reason: args.retirement_reason || 'Retired via API'
+        };
+        const response = await this.updateRecord('kb_knowledge', args.sys_id, updateData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to retire article: ${response.error}`);
+        }
+        this.logger.info('✅ Article retired successfully');
+        return this.createResponse(`✅ Knowledge article retired!\n🆔 sys_id: ${args.sys_id}`);
+    }
+    /**
+     * Create Knowledge Base
+     */
+    async createKnowledgeBase(args) {
+        this.logger.info('Creating knowledge base...', { title: args.title });
+        const kbData = {
+            title: args.title,
+            description: args.description || '',
+            owner: args.owner || '',
+            kb_managers: args.kb_managers?.join(',') || ''
+        };
+        this.logger.progress('Creating KB in ServiceNow...');
+        const response = await this.createRecord('kb_knowledge_base', kbData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create KB: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ Knowledge base created', { sys_id: result.sys_id });
+        return this.createResponse(`✅ Knowledge Base created!\n📚 **${args.title}**\n🆔 sys_id: ${result.sys_id}`);
+    }
+    /**
+     * Discover Knowledge Bases
+     */
+    async discoverKnowledgeBases(args) {
+        this.logger.info('Discovering knowledge bases...');
+        const query = args.active_only ? 'active=true' : '';
+        const response = await this.queryTable('kb_knowledge_base', query, 50);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to discover KBs: ${response.error}`);
+        }
+        const kbs = response.data.result;
+        this.logger.info(`Found ${kbs.length} knowledge bases`);
+        const kbList = kbs.map((kb) => `📚 **${kb.title}**\n🆔 ${kb.sys_id}\n📝 ${kb.description || 'No description'}`).join('\n\n');
+        return this.createResponse(`📚 Knowledge Bases Found:\n\n${kbList}\n\n✨ Total: ${kbs.length} knowledge base(s)`);
+    }
+    /**
+     * Get Knowledge Stats
+     */
+    async getKnowledgeStats(args) {
+        this.logger.info('Getting knowledge statistics...');
+        let query = 'active=true';
+        if (args.kb_knowledge_base) {
+            query += `^kb_knowledge_base=${args.kb_knowledge_base}`;
+        }
+        this.logger.progress('Gathering statistics...');
+        // Get article counts by state
+        const states = ['draft', 'review', 'published', 'retired'];
+        const stats = { total: 0, by_state: {} };
+        for (const state of states) {
+            const stateQuery = `${query}^workflow_state=${state}`;
+            const response = await this.queryTable('kb_knowledge', stateQuery, 1);
+            if (response.success && response.data.headers) {
+                const count = parseInt(response.data.headers['x-total-count'] || '0');
+                stats.by_state[state] = count;
+                stats.total += count;
+            }
+        }
+        this.logger.info('✅ Statistics gathered', stats);
+        return this.createResponse(`📊 Knowledge Base Statistics:\n\n` +
+            `📚 Total Articles: ${stats.total}\n` +
+            `📝 Draft: ${stats.by_state.draft || 0}\n` +
+            `👁️ In Review: ${stats.by_state.review || 0}\n` +
+            `✅ Published: ${stats.by_state.published || 0}\n` +
+            `🗄️ Retired: ${stats.by_state.retired || 0}`);
+    }
+    /**
+     * Knowledge Feedback
+     */
+    async knowledgeFeedback(args) {
+        this.logger.info('Managing knowledge feedback...', { article_id: args.article_id });
+        if (args.rating || args.comments) {
+            // Create feedback
+            const feedbackData = {
+                article: args.article_id,
+                rating: args.rating || 0,
+                comments: args.comments || '',
+                user: 'api_user'
+            };
+            this.logger.progress('Submitting feedback...');
+            const response = await this.createRecord('kb_feedback', feedbackData);
+            if (!response.success) {
+                return this.createResponse(`❌ Failed to submit feedback: ${response.error}`);
+            }
+            this.logger.info('✅ Feedback submitted');
+            return this.createResponse(`✅ Feedback submitted!\n⭐ Rating: ${args.rating || 'N/A'}`);
+        }
+        else {
+            // Get feedback for article
+            const query = `article=${args.article_id}`;
+            const response = await this.queryTable('kb_feedback', query, 10);
+            if (!response.success) {
+                return this.createResponse(`❌ Failed to get feedback: ${response.error}`);
+            }
+            const feedback = response.data.result;
+            const avgRating = feedback.length > 0 ?
+                (feedback.reduce((sum, f) => sum + (f.rating || 0), 0) / feedback.length).toFixed(1) :
+                'N/A';
+            return this.createResponse(`📊 Article Feedback:\n⭐ Average Rating: ${avgRating}\n💬 ${feedback.length} feedback entries`);
+        }
+    }
+    /**
+     * Create Catalog Item
+     */
+    async createCatalogItem(args) {
+        this.logger.info('Creating catalog item...', { name: args.name });
+        const itemData = {
+            name: args.name,
+            short_description: args.short_description,
+            category: args.category || '',
+            price: args.price || '0',
+            workflow: args.workflow || '',
+            active: true
+        };
+        this.logger.progress('Creating item in ServiceNow...');
+        const response = await this.createRecord('sc_cat_item', itemData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create catalog item: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ Catalog item created', { sys_id: result.sys_id });
+        return this.createResponse(`✅ Catalog Item created!\n🛍️ **${args.name}**\n🆔 sys_id: ${result.sys_id}\n💰 Price: ${args.price || '0'}`);
+    }
+    /**
+     * Create Catalog Variable
+     */
+    async createCatalogVariable(args) {
+        this.logger.info('Creating catalog variable...', { name: args.name });
+        const varData = {
+            cat_item: args.cat_item,
+            name: args.name,
+            question_text: args.question_text,
+            type: args.type || '6', // Single line text
+            mandatory: args.mandatory || false,
+            order: 100
+        };
+        this.logger.progress('Creating variable...');
+        const response = await this.createRecord('item_option_new', varData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create variable: ${response.error}`);
+        }
+        this.logger.info('✅ Variable created');
+        return this.createResponse(`✅ Catalog variable created!\n📝 ${args.question_text}\n🔤 Name: ${args.name}`);
+    }
+    /**
+     * Create Catalog UI Policy
+     */
+    async createCatalogUIPolicy(args) {
+        this.logger.info('Creating catalog UI policy...', { short_description: args.short_description });
+        const policyData = {
+            cat_item: args.cat_item,
+            short_description: args.short_description,
+            condition: args.condition || '',
+            active: true
+        };
+        this.logger.progress('Creating UI policy...');
+        const response = await this.createRecord('catalog_ui_policy', policyData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to create UI policy: ${response.error}`);
+        }
+        this.logger.info('✅ UI policy created');
+        return this.createResponse(`✅ Catalog UI Policy created!\n📋 ${args.short_description}\n🆔 sys_id: ${response.data.sys_id}`);
+    }
+    /**
+     * Order Catalog Item
+     */
+    async orderCatalogItem(args) {
+        this.logger.info('Ordering catalog item...', { cat_item: args.cat_item });
+        const orderData = {
+            cat_item: args.cat_item,
+            requested_for: args.requested_for || 'current_user',
+            quantity: args.quantity || 1,
+            variables: JSON.stringify(args.variables || {})
+        };
+        this.logger.progress('Submitting order...');
+        const response = await this.createRecord('sc_req_item', orderData);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to order item: ${response.error}`);
+        }
+        const result = response.data;
+        this.logger.info('✅ Order submitted', { number: result.number });
+        return this.createResponse(`✅ Catalog item ordered!\n📦 Request: ${result.number}\n🆔 sys_id: ${result.sys_id}\n📊 Status: ${result.state || 'Submitted'}`);
+    }
+    /**
+     * Search Catalog
+     */
+    async searchCatalog(args) {
+        this.logger.info('Searching service catalog...', { query: args.query });
+        let query = `nameLIKE${args.query}^ORshort_descriptionLIKE${args.query}`;
+        if (args.category) {
+            query += `^category=${args.category}`;
+        }
+        if (args.active_only) {
+            query += '^active=true';
+        }
+        this.logger.progress('Searching catalog...');
+        const response = await this.queryTable('sc_cat_item', query, args.limit || 10);
+        if (!response.success) {
+            return this.createResponse(`❌ Search failed: ${response.error}`);
+        }
+        const items = response.data.result;
+        if (!items.length) {
+            return this.createResponse(`❌ No catalog items found matching "${args.query}"`);
+        }
+        this.logger.info(`Found ${items.length} catalog items`);
+        const itemList = items.map((item) => `🛍️ **${item.name}**\n📝 ${item.short_description}\n💰 ${item.price || '0'}\n🆔 ${item.sys_id}`).join('\n\n');
+        return this.createResponse(`🔍 Catalog Search Results:\n\n${itemList}\n\n✨ Found ${items.length} item(s)`);
+    }
+    /**
+     * Get Catalog Item Details
+     */
+    async getCatalogItemDetails(args) {
+        this.logger.info('Getting catalog item details...', { sys_id: args.sys_id });
+        const response = await this.getRecord('sc_cat_item', args.sys_id);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to get item details: ${response.error}`);
+        }
+        const item = response.data;
+        let details = `🛍️ **${item.name}**\n` +
+            `📝 ${item.short_description}\n` +
+            `💰 Price: ${item.price || '0'}\n` +
+            `📊 Active: ${item.active}\n` +
+            `🆔 sys_id: ${item.sys_id}`;
+        if (args.include_variables) {
+            // Get variables
+            const varQuery = `cat_item=${args.sys_id}`;
+            const varResponse = await this.queryTable('item_option_new', varQuery, 50);
+            if (varResponse.success && varResponse.data.result.length > 0) {
+                const variables = varResponse.data.result;
+                details += `\n\n📋 Variables (${variables.length}):\n`;
+                variables.forEach((v) => {
+                    details += `  • ${v.question_text} (${v.name})\n`;
+                });
+            }
+        }
+        this.logger.info('✅ Retrieved item details');
+        return this.createResponse(details);
+    }
+    /**
+     * Discover Catalogs
+     */
+    async discoverCatalogs(args) {
+        this.logger.info('Discovering service catalogs...');
+        const response = await this.queryTable('sc_catalog', 'active=true', 20);
+        if (!response.success) {
+            return this.createResponse(`❌ Failed to discover catalogs: ${response.error}`);
+        }
+        const catalogs = response.data.result;
+        this.logger.info(`Found ${catalogs.length} catalogs`);
+        let catalogInfo = `📚 Service Catalogs:\n\n`;
+        for (const catalog of catalogs) {
+            catalogInfo += `🛍️ **${catalog.title}**\n🆔 ${catalog.sys_id}\n`;
+            if (args.include_categories) {
+                // Get categories for this catalog
+                const catQuery = `sc_catalog=${catalog.sys_id}^active=true`;
+                const catResponse = await this.queryTable('sc_category', catQuery, 10);
+                if (catResponse.success && catResponse.data.result.length > 0) {
+                    catalogInfo += `📁 Categories:\n`;
+                    catResponse.data.result.forEach((cat) => {
+                        catalogInfo += `  • ${cat.title}\n`;
+                    });
+                }
+            }
+            catalogInfo += '\n';
+        }
+        return this.createResponse(`${catalogInfo}✨ Total: ${catalogs.length} catalog(s) discovered`);
+    }
+    async start() {
+        const transport = new stdio_js_1.StdioServerTransport();
+        await this.server.connect(transport);
+        // Log ready state
+        this.logger.info('🚀 ServiceNow Knowledge & Catalog MCP Server (Enhanced) running');
+        this.logger.info('📊 Token tracking enabled');
+        this.logger.info('⏳ Progress indicators active');
+    }
+}
+// Start the enhanced server
+const server = new ServiceNowKnowledgeCatalogMCPEnhanced();
+server.start().catch((error) => {
+    console.error('Failed to start enhanced server:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=servicenow-knowledge-catalog-mcp-enhanced.js.map