snow-flow 3.5.4 → 3.5.5

package/dist/mcp/servicenow-local-development-mcp.d.ts

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 /**
  * ServiceNow Local Development MCP Server
  *
@@ -7,42 +8,5 @@
  *
  * THIS IS THE KEY TO POWERFUL SERVICENOW DEVELOPMENT!
  */
-import { BaseMCPServer } from './base-mcp-server';
-export declare class ServiceNowLocalDevelopmentMCP extends BaseMCPServer {
-    private syncManager;
-    constructor();
-    protected initializeTools(): Promise<void>;
-    /**
-     * DYNAMIC pull artifact to local files
-     */
-    private pullArtifact;
-    /**
-     * Push artifact changes back to ServiceNow
-     */
-    private pushArtifact;
-    /**
-     * Get sync status
-     */
-    private getSyncStatus;
-    /**
-     * Cleanup local files
-     */
-    private cleanup;
-    /**
-     * List supported artifact types
-     */
-    private listSupportedArtifacts;
-    /**
-     * Validate artifact coherence
-     */
-    private validateCoherence;
-    /**
-     * Convert modern JS to ES5
-     */
-    private convertToES5;
-    /**
-     * Search in widgets (like Claude Code search)
-     */
-    private searchInWidgets;
-}
+export {};
 //# sourceMappingURL=servicenow-local-development-mcp.d.ts.map

package/dist/mcp/servicenow-local-development-mcp.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 /**
  * ServiceNow Local Development MCP Server
@@ -8,563 +9,425 @@
  *
  * THIS IS THE KEY TO POWERFUL SERVICENOW DEVELOPMENT!
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceNowLocalDevelopmentMCP = void 0;
-const base_mcp_server_1 = require("./base-mcp-server");
-const artifact_local_sync_1 = require("../utils/artifact-local-sync");
-const artifact_registry_1 = require("../utils/artifact-sync/artifact-registry");
-const fs = __importStar(require("fs"));
-class ServiceNowLocalDevelopmentMCP extends base_mcp_server_1.BaseMCPServer {
+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 artifact_local_sync_js_1 = require("../utils/artifact-local-sync.js");
+const artifact_registry_js_1 = require("../utils/artifact-sync/artifact-registry.js");
+class ServiceNowLocalDevelopmentMCP extends enhanced_base_mcp_server_js_1.EnhancedBaseMCPServer {
     constructor() {
         super('servicenow-local-development', '1.0.0');
-        this.syncManager = new artifact_local_sync_1.ArtifactLocalSync(this.serviceNowClient);
+        // Initialize after client is available
+        this.setupSyncManager();
+        this.setupHandlers();
+    }
+    setupSyncManager() {
+        // Initialize sync manager with the client from enhanced base server
+        this.syncManager = new artifact_local_sync_js_1.ArtifactLocalSync(this.client);
+        this.logger.info('🔧 Local sync manager initialized');
     }
-    async initializeTools() {
-        // DYNAMIC pull tool - works with ALL artifact types!
-        this.addTool({
-            name: 'snow_pull_artifact',
-            description: `Pull ANY ServiceNow artifact to local files for editing with Claude Code's native tools.
-      Automatically detects the artifact type and creates appropriate files based on the artifact registry.
-      Supports: ${(0, artifact_registry_1.getSupportedTables)().map(t => (0, artifact_registry_1.getTableDisplayName)(t)).join(', ')}`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Artifact sys_id to pull'
-                    },
-                    table: {
-                        type: 'string',
-                        description: 'Optional: Specify table name if known',
-                        enum: (0, artifact_registry_1.getSupportedTables)()
+    setupHandlers() {
+        this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: 'snow_pull_artifact',
+                    description: `Pull ANY ServiceNow artifact to local files for editing with Claude Code's native tools. Automatically detects the artifact type and creates appropriate files based on the artifact registry. Supports: ${(0, artifact_registry_js_1.getSupportedTables)().map(t => (0, artifact_registry_js_1.getTableDisplayName)(t)).join(', ')}`,
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Artifact sys_id to pull'
+                            },
+                            table: {
+                                type: 'string',
+                                description: 'Optional: Specify table name if known for faster processing',
+                                enum: (0, artifact_registry_js_1.getSupportedTables)()
+                            }
+                        },
+                        required: ['sys_id']
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.pullArtifact(args)
-        });
-        // Keep backward compatibility - widget-specific tool
-        this.addTool({
-            name: 'snow_pull_widget',
-            description: `Pull a ServiceNow widget to local files (legacy - use snow_pull_artifact instead)`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Widget sys_id to pull'
+                {
+                    name: 'snow_push_artifact',
+                    description: 'Push local artifact changes back to ServiceNow with validation and coherence checking',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Artifact sys_id to push back'
+                            },
+                            force: {
+                                type: 'boolean',
+                                description: 'Force push despite validation warnings',
+                                default: false
+                            }
+                        },
+                        required: ['sys_id']
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.pullArtifact({ ...args, table: 'sp_widget' })
-        });
-        this.addTool({
-            name: 'snow_pull_script_include',
-            description: 'Pull a Script Include to local JavaScript file (legacy - use snow_pull_artifact)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Script Include sys_id'
+                {
+                    name: 'snow_validate_artifact_coherence',
+                    description: 'Validate coherence and relationships between artifact components (e.g., widget HTML-client-server relationships)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Artifact sys_id to validate'
+                            }
+                        },
+                        required: ['sys_id']
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.pullArtifact({ ...args, table: 'sys_script_include' })
-        });
-        this.addTool({
-            name: 'snow_pull_business_rule',
-            description: 'Pull a Business Rule to local JavaScript file (legacy - use snow_pull_artifact)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Business Rule sys_id'
+                {
+                    name: 'snow_list_supported_artifacts',
+                    description: 'List all supported artifact types for local synchronization',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {},
+                        additionalProperties: false
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.pullArtifact({ ...args, table: 'sys_script' })
-        });
-        // DYNAMIC push tool - works with ALL artifact types!
-        this.addTool({
-            name: 'snow_push_artifact',
-            description: `Push local artifact changes back to ServiceNow.
-      Automatically detects which files changed, validates based on artifact type,
-      and updates the corresponding fields. Runs coherence validation for artifacts with rules.`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Artifact sys_id to push changes for'
-                    },
-                    force: {
-                        type: 'boolean',
-                        description: 'Force push even with validation warnings',
-                        default: false
+                {
+                    name: 'snow_sync_status',
+                    description: 'Check sync status of local artifacts',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Optional: Check specific artifact, or all if omitted'
+                            }
+                        }
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.pushArtifact(args)
-        });
-        // Keep backward compatibility
-        this.addTool({
-            name: 'snow_push_widget',
-            description: `Push local widget changes back to ServiceNow (legacy - use snow_push_artifact)`,
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Widget sys_id to push'
+                {
+                    name: 'snow_sync_cleanup',
+                    description: 'Clean up local artifact files after successful sync',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Artifact sys_id to clean up'
+                            },
+                            force: {
+                                type: 'boolean',
+                                description: 'Force cleanup even with unsaved changes',
+                                default: false
+                            }
+                        },
+                        required: ['sys_id']
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.pushArtifact(args)
-        });
-        // Sync status tools
-        this.addTool({
-            name: 'snow_sync_status',
-            description: 'Check sync status of local artifacts - shows what\'s modified',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Optional: specific artifact sys_id'
-                    }
-                }
-            },
-            handler: async (args) => this.getSyncStatus(args)
-        });
-        this.addTool({
-            name: 'snow_sync_cleanup',
-            description: 'Clean up local files after successful sync',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Artifact sys_id to clean up'
-                    },
-                    force: {
-                        type: 'boolean',
-                        description: 'Force cleanup even with unsaved changes',
-                        default: false
+                {
+                    name: 'snow_convert_to_es5',
+                    description: 'Convert modern JavaScript code to ES5 for ServiceNow compatibility',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            code: {
+                                type: 'string',
+                                description: 'JavaScript code to convert to ES5'
+                            },
+                            context: {
+                                type: 'string',
+                                description: 'Context: server_script, client_script, business_rule, etc.',
+                                enum: ['server_script', 'client_script', 'business_rule', 'script_include', 'ui_script']
+                            }
+                        },
+                        required: ['code']
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.cleanup(args)
-        });
-        // List supported artifact types
-        this.addTool({
-            name: 'snow_list_supported_artifacts',
-            description: 'List all artifact types supported by the local sync system',
-            inputSchema: {
-                type: 'object',
-                properties: {}
-            },
-            handler: async () => this.listSupportedArtifacts()
-        });
-        this.addTool({
-            name: 'snow_validate_artifact_coherence',
-            description: 'Validate artifact based on its type-specific coherence rules',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    sys_id: {
-                        type: 'string',
-                        description: 'Artifact sys_id to validate'
+                // Legacy compatibility tools
+                {
+                    name: 'snow_pull_widget',
+                    description: 'Pull a ServiceNow widget to local files (legacy - use snow_pull_artifact instead)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Widget sys_id to pull'
+                            }
+                        },
+                        required: ['sys_id']
                     }
                 },
-                required: ['sys_id']
-            },
-            handler: async (args) => this.validateCoherence(args)
-        });
-        this.addTool({
-            name: 'snow_convert_to_es5',
-            description: 'Convert modern JavaScript to ES5 for ServiceNow compatibility',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    file_path: {
-                        type: 'string',
-                        description: 'Path to JavaScript file to convert'
-                    },
-                    inline_code: {
-                        type: 'string',
-                        description: 'Or provide code directly'
+                {
+                    name: 'snow_push_widget',
+                    description: 'Push widget changes back to ServiceNow (legacy - use snow_push_artifact instead)',
+                    inputSchema: {
+                        type: 'object',
+                        properties: {
+                            sys_id: {
+                                type: 'string',
+                                description: 'Widget sys_id to push'
+                            }
+                        },
+                        required: ['sys_id']
                     }
                 }
-            },
-            handler: async (args) => this.convertToES5(args)
-        });
-        // Search tools that work like Claude Code
-        this.addTool({
-            name: 'snow_search_in_widgets',
-            description: 'Search across all widget fields (like Claude Code search but for ServiceNow)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    search_term: {
-                        type: 'string',
-                        description: 'Text to search for'
-                    },
-                    field: {
-                        type: 'string',
-                        description: 'Specific field to search in',
-                        enum: ['template', 'script', 'client_script', 'css', 'all']
-                    },
-                    regex: {
-                        type: 'boolean',
-                        description: 'Use regex search',
-                        default: false
-                    }
-                },
-                required: ['search_term']
-            },
-            handler: async (args) => this.searchInWidgets(args)
+            ]
+        }));
+        this.server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            try {
+                this.logger.info(`🔧 Executing tool: ${name}`, args);
+                let result;
+                switch (name) {
+                    case 'snow_pull_artifact':
+                        result = await this.pullArtifact(args);
+                        break;
+                    case 'snow_push_artifact':
+                        result = await this.pushArtifact(args);
+                        break;
+                    case 'snow_validate_artifact_coherence':
+                        result = await this.validateArtifactCoherence(args);
+                        break;
+                    case 'snow_sync_status':
+                        result = await this.getSyncStatus(args);
+                        break;
+                    case 'snow_list_supported_artifacts':
+                        result = await this.listSupportedArtifacts(args);
+                        break;
+                    case 'snow_sync_cleanup':
+                        result = await this.syncCleanup(args);
+                        break;
+                    case 'snow_convert_to_es5':
+                        result = await this.convertToES5(args);
+                        break;
+                    // Legacy compatibility
+                    case 'snow_pull_widget':
+                        result = await this.pullWidget(args);
+                        break;
+                    case 'snow_push_widget':
+                        result = await this.pushWidget(args);
+                        break;
+                    default:
+                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                }
+                this.logger.info(`✅ Tool ${name} completed successfully`);
+                return result;
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error(`❌ Tool ${name} failed: ${errorMessage}`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error executing ${name}: ${errorMessage}`
+                        }
+                    ]
+                };
+            }
         });
     }
-    /**
-     * DYNAMIC pull artifact to local files
-     */
     async pullArtifact(args) {
+        const { sys_id, table } = args;
         try {
             let artifact;
-            if (args.table) {
-                // Table specified - direct pull
-                artifact = await this.syncManager.pullArtifact(args.table, args.sys_id);
+            if (table) {
+                // Use specified table
+                artifact = await this.syncManager.pullArtifact(table, sys_id);
             }
             else {
                 // Auto-detect table
-                artifact = await this.syncManager.pullArtifactBySysId(args.sys_id);
+                artifact = await this.syncManager.pullArtifactBySysId(sys_id);
             }
-            const config = artifact.artifactConfig;
-            const hasES5 = config?.fieldMappings.some(fm => fm.validateES5);
-            const hasCoherence = config?.coherenceRules && config.coherenceRules.length > 0;
-            const message = `
-✅ **${artifact.type} pulled to local files successfully!**
-
-📁 **Location:** \`${artifact.localPath}\`
-
-📄 **Files created:**
-${artifact.files.map(f => `- **${f.filename}** (${f.type})`).join('\n')}
-
-🎯 **Now you can:**
-1. Use Claude Code's native tools to edit these files
-2. Search across files with full regex support
-3. Multi-file operations and refactoring
-4. Use all VS Code/editor features
-5. When done, run \`snow_push_artifact\` to sync back
-
-${hasES5 ? `⚠️ **ES5 Requirement:**
-- Server-side scripts MUST be ES5 only
-- No const/let/arrow functions/template literals
-- Use var and function() syntax only
-
-` : ''}
-${hasCoherence ? `🔗 **Coherence Rules:**
-- This artifact has validation rules that will be checked
-- Run \`snow_validate_artifact_coherence\` to test
-- Push will warn about any violations
-
-` : ''}
-📝 **Edit the files now, then push changes back to ServiceNow!**
-`;
             return {
-                success: true,
-                result: artifact,
-                message
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Successfully pulled ${artifact.type} to local files at: ${artifact.localPath}\n\n📁 Files created:\n${artifact.files.map(f => `  - ${f.filename} (${f.type})`).join('\n')}\n\n💡 You can now use Claude Code's native tools to edit these files!`
+                    }
+                ]
             };
         }
         catch (error) {
-            return this.error(`Failed to pull artifact: ${error.message}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to pull artifact: ${errorMessage}`
+                    }
+                ]
+            };
         }
     }
-    /**
-     * Push artifact changes back to ServiceNow
-     */
     async pushArtifact(args) {
+        const { sys_id, force = false } = args;
         try {
-            // First run coherence validation
-            const validationResults = await this.syncManager.validateArtifactCoherence(args.sys_id);
-            if (validationResults.length > 0 && !args.force) {
-                const hasErrors = validationResults.some(r => !r.valid);
-                if (hasErrors) {
-                    const message = `
-⚠️ **Validation Issues Found**
-
-${validationResults.map(r => {
-                        let output = '';
-                        if (r.errors.length > 0) {
-                            output += '**Errors:**\n' + r.errors.map(e => `- ❌ ${e}`).join('\n') + '\n';
-                        }
-                        if (r.warnings.length > 0) {
-                            output += '**Warnings:**\n' + r.warnings.map(w => `- ⚠️ ${w}`).join('\n') + '\n';
-                        }
-                        if (r.hints.length > 0) {
-                            output += '**Hints:**\n' + r.hints.map(h => `- 💡 ${h}`).join('\n');
-                        }
-                        return output;
-                    }).join('\n\n')}
-
-❓ Use \`force: true\` to push anyway, but this may cause runtime errors.
-`;
-                    return {
-                        success: false,
-                        result: { validationResults },
-                        message
-                    };
-                }
-            }
-            const success = await this.syncManager.pushArtifact(args.sys_id);
-            if (success) {
-                return {
-                    success: true,
-                    result: { pushed: true },
-                    message: `✅ Artifact successfully pushed to ServiceNow! Changes are now live.`
-                };
-            }
-            else {
-                return this.error('Failed to push artifact - check logs for details');
-            }
+            const success = await this.syncManager.pushArtifact(sys_id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: success
+                            ? `✅ Successfully pushed changes back to ServiceNow!`
+                            : `❌ Failed to push changes. Check logs for details.`
+                    }
+                ]
+            };
         }
         catch (error) {
-            return this.error(`Failed to push artifact: ${error.message}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to push artifact: ${errorMessage}`
+                    }
+                ]
+            };
         }
     }
-    /**
-     * Get sync status
-     */
     async getSyncStatus(args) {
-        const artifacts = this.syncManager.listLocalArtifacts();
-        if (args.sys_id) {
-            const status = this.syncManager.getSyncStatus(args.sys_id);
+        const { sys_id } = args;
+        if (sys_id) {
+            const status = this.syncManager.getSyncStatus(sys_id);
             return {
-                success: true,
-                result: { status },
-                message: `Sync status for ${args.sys_id}: ${status}`
+                content: [
+                    {
+                        type: 'text',
+                        text: `Sync status for ${sys_id}: ${status}`
+                    }
+                ]
             };
         }
-        const message = `
-📊 **Local Artifacts Sync Status**
-
-${artifacts.length === 0 ? '📭 No local artifacts currently synced' : ''}
-${artifacts.map(a => `
-**${a.name}** (${a.type})
-- sys_id: \`${a.sys_id}\`
-- Status: **${a.syncStatus}**
-- Path: \`${a.localPath}\`
-- Files: ${a.files.length}
-- Modified: ${a.files.filter(f => f.isModified).length}
-- Last sync: ${a.lastSyncedAt.toLocaleString()}
-`).join('\n---\n')}
-
-💡 Use \`snow_push_artifact <sys_id>\` to push changes
-🧹 Use \`snow_sync_cleanup <sys_id>\` to remove local files
-`;
-        return {
-            success: true,
-            result: artifacts,
-            message
-        };
-    }
-    /**
-     * Cleanup local files
-     */
-    async cleanup(args) {
-        try {
-            await this.syncManager.cleanup(args.sys_id, args.force);
+        else {
+            const artifacts = this.syncManager.listLocalArtifacts();
+            const statusText = artifacts.length > 0
+                ? artifacts.map(a => `${a.name} (${a.sys_id}): ${a.syncStatus}`).join('\n')
+                : 'No local artifacts found';
             return {
-                success: true,
-                result: { cleaned: true },
-                message: `✅ Local files cleaned up successfully`
+                content: [
+                    {
+                        type: 'text',
+                        text: `Local artifacts status:\n${statusText}`
+                    }
+                ]
             };
         }
-        catch (error) {
-            return this.error(`Cleanup failed: ${error.message}`);
-        }
     }
-    /**
-     * List supported artifact types
-     */
-    async listSupportedArtifacts() {
-        const types = (0, artifact_registry_1.getSupportedTables)();
-        const details = types.map(table => {
-            const config = artifact_registry_1.ARTIFACT_REGISTRY[table];
+    async listSupportedArtifacts(args) {
+        const supportedTypes = (0, artifact_registry_js_1.getSupportedTables)().map(table => {
+            const config = artifact_registry_js_1.ARTIFACT_REGISTRY[table];
             return {
                 table,
-                displayName: config.displayName,
-                folderName: config.folderName,
-                fields: config.fieldMappings.length,
-                hasCoherence: (config.coherenceRules?.length || 0) > 0,
-                requiresES5: config.fieldMappings.some(fm => fm.validateES5)
+                displayName: config?.displayName || table,
+                folderName: config?.folderName || table,
+                fields: config?.fieldMappings.length || 0,
+                hasCoherence: (config?.coherenceRules?.length || 0) > 0,
+                requiresES5: config?.fieldMappings.some(fm => fm.validateES5) || false
             };
         });
-        const message = `
-📚 **Supported ServiceNow Artifact Types**
-
-${details.map(d => `
-**${d.displayName}**
-- Table: \`${d.table}\`
-- Folder: \`${d.folderName}/\`
-- Fields: ${d.fields}
-- Coherence Rules: ${d.hasCoherence ? '✅' : '❌'}
-- ES5 Required: ${d.requiresES5 ? '⚠️ Yes' : '✅ No'}
-`).join('\n')}
-
-💡 **Usage:**
-\`\`\`
-snow_pull_artifact({ sys_id: 'abc123' })  // Auto-detect type
-snow_pull_artifact({ sys_id: 'abc123', table: 'sp_widget' })  // Specific type
-\`\`\`
-`;
         return {
-            success: true,
-            result: details,
-            message
+            content: [
+                {
+                    type: 'text',
+                    text: `Supported ServiceNow artifact types for local sync:\n\n${supportedTypes.map(t => `📦 ${t.displayName} (${t.table})\n   └── ${t.fields} fields, ES5: ${t.requiresES5 ? '✅' : '❌'}, Coherence: ${t.hasCoherence ? '✅' : '❌'}`).join('\n\n')}\n\nTotal: ${supportedTypes.length} artifact types supported`
+                }
+            ]
         };
     }
-    /**
-     * Validate artifact coherence
-     */
-    async validateCoherence(args) {
+    async validateArtifactCoherence(args) {
+        const { sys_id } = args;
         try {
-            const results = await this.syncManager.validateArtifactCoherence(args.sys_id);
-            if (results.length === 0) {
-                return {
-                    success: true,
-                    result: { valid: true },
-                    message: '✅ No coherence rules defined for this artifact type'
-                };
-            }
-            const allValid = results.every(r => r.valid);
-            const message = `
-${allValid ? '✅' : '❌'} **Coherence Validation Results**
-
-${results.map(r => {
-                let output = r.valid ? '✅ Valid\n' : '❌ Invalid\n';
-                if (r.errors.length > 0) {
-                    output += '\n**Errors:**\n' + r.errors.map(e => `- ${e}`).join('\n');
-                }
-                if (r.warnings.length > 0) {
-                    output += '\n**Warnings:**\n' + r.warnings.map(w => `- ${w}`).join('\n');
-                }
-                if (r.hints.length > 0) {
-                    output += '\n**Hints:**\n' + r.hints.map(h => `- ${h}`).join('\n');
-                }
-                return output;
-            }).join('\n\n')}
-`;
+            const results = await this.syncManager.validateArtifactCoherence(sys_id);
+            const hasErrors = results.some(r => !r.valid);
             return {
-                success: allValid,
-                result: results,
-                message
+                content: [
+                    {
+                        type: 'text',
+                        text: hasErrors
+                            ? `⚠️ Coherence validation found issues:\n${results.filter(r => !r.valid).map(r => r.errors.join(', ')).join('\n')}`
+                            : `✅ Artifact coherence validation passed!`
+                    }
+                ]
             };
         }
         catch (error) {
-            return this.error(`Validation failed: ${error.message}`);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to validate coherence: ${errorMessage}`
+                    }
+                ]
+            };
         }
     }
-    /**
-     * Convert modern JS to ES5
-     */
-    async convertToES5(args) {
-        let code = args.inline_code;
-        if (args.file_path && fs.existsSync(args.file_path)) {
-            code = fs.readFileSync(args.file_path, 'utf8');
+    async syncCleanup(args) {
+        const { sys_id, force = false } = args;
+        try {
+            await this.syncManager.cleanup(sys_id, force);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ Successfully cleaned up local files for ${sys_id}`
+                    }
+                ]
+            };
         }
-        if (!code) {
-            return this.error('No code provided to convert');
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ Failed to cleanup: ${errorMessage}`
+                    }
+                ]
+            };
         }
-        // Basic conversions (in production, use a proper transpiler)
+    }
+    async convertToES5(args) {
+        const { code, context = 'server_script' } = args;
+        // Basic ES5 conversion - in a real implementation this would be more sophisticated
         let es5Code = code
-            // const/let → var
-            .replace(/\b(const|let)\s+/g, 'var ')
-            // Arrow functions
+            .replace(/\bconst\s+/g, 'var ')
+            .replace(/\blet\s+/g, 'var ')
             .replace(/(\w+)\s*=>\s*{/g, 'function($1) {')
-            .replace(/(\([^)]*\))\s*=>\s*{/g, 'function$1 {')
-            .replace(/(\w+)\s*=>\s*/g, 'function($1) { return ')
-            // Template literals (basic)
-            .replace(/`([^`]*)\$\{([^}]*)\}([^`]*)`/g, "'$1' + $2 + '$3'")
-            .replace(/`([^`]*)`/g, "'$1'")
-            // For...of → for loop
-            .replace(/for\s*\(\s*(?:const|let|var)\s+(\w+)\s+of\s+(\w+)\s*\)/g, 'for (var _i = 0; _i < $2.length; _i++) { var $1 = $2[_i];');
-        const message = `
-✅ **Code converted to ES5**
-
-⚠️ **Review the conversion carefully!**
-This is a basic conversion. Complex features may need manual adjustment:
-- Classes → function constructors
-- async/await → callbacks
-- Destructuring → individual assignments
-- Spread operator → manual copying
-
-**Common issues to check:**
-- Arrow function this binding
-- Default parameters
-- Object method shorthand
-`;
+            .replace(/(\w+)\s*=>\s*([^{])/g, 'function($1) { return $2; }')
+            .replace(/`([^`]*)`/g, (match, content) => {
+            return '"' + content.replace(/\$\{([^}]+)\}/g, '" + $1 + "') + '"';
+        });
         return {
-            success: true,
-            result: { es5Code },
-            message
+            content: [
+                {
+                    type: 'text',
+                    text: `✅ Converted to ES5 (basic conversion):\n\n\`\`\`javascript\n${es5Code}\n\`\`\`\n\n⚠️ Note: This is a basic conversion. Please review and test the code.`
+                }
+            ]
         };
     }
-    /**
-     * Search in widgets (like Claude Code search)
-     */
-    async searchInWidgets(args) {
-        const { search_term, field = 'all', regex = false } = args;
-        // This would search in ServiceNow
-        // Similar to Claude Code's search but for ServiceNow widgets
-        return {
-            success: true,
-            result: {},
-            message: `Search results for "${search_term}" in widgets`
-        };
+    // Legacy compatibility methods
+    async pullWidget(args) {
+        return this.pullArtifact({ ...args, table: 'sp_widget' });
+    }
+    async pushWidget(args) {
+        return this.pushArtifact(args);
     }
 }
-exports.ServiceNowLocalDevelopmentMCP = ServiceNowLocalDevelopmentMCP;
+// Start the server
+async function main() {
+    const server = new ServiceNowLocalDevelopmentMCP();
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.server.connect(transport);
+    console.error('🚀 ServiceNow Local Development MCP Server started');
+}
+if (require.main === module) {
+    main().catch((error) => {
+        console.error('❌ Server failed to start:', error);
+        process.exit(1);
+    });
+}
 //# sourceMappingURL=servicenow-local-development-mcp.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snow-flow",
-  "version": "3.5.4",
+  "version": "3.5.5",
   "description": "ServiceNow development framework with MCP server integration. Executes background scripts using ES5 JavaScript only (ServiceNow Rhino engine requirement). Provides 18 MCP servers including local development sync for editing ServiceNow artifacts with Claude Code native tools, widget deployment with coherence validation, table operations, script execution, machine learning, advanced features, and comprehensive platform management.",
   "main": "dist/index.js",
   "type": "commonjs",