snow-flow 4.6.9 → 5.0.1

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_convert_to_es5.js

@@ -0,0 +1,138 @@
+"use strict";
+/**
+ * snow_convert_to_es5 - Convert modern JavaScript to ES5
+ *
+ * Automatically convert ES6+ JavaScript to ES5 for ServiceNow Rhino engine.
+ * Handles const/let, arrow functions, template literals, destructuring, etc.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_convert_to_es5',
+    description: 'Convert modern JavaScript (ES6+) to ES5 for ServiceNow Rhino engine',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            code: {
+                type: 'string',
+                description: 'JavaScript code to convert to ES5'
+            },
+            validate_only: {
+                type: 'boolean',
+                description: 'Only validate ES5 compliance without converting',
+                default: false
+            }
+        },
+        required: ['code']
+    }
+};
+async function execute(args, context) {
+    const { code, validate_only = false } = args;
+    try {
+        // Detect ES6+ features
+        const violations = detectES6Features(code);
+        if (validate_only) {
+            return (0, error_handler_js_1.createSuccessResult)({
+                valid: violations.length === 0,
+                violations,
+                es5_compliant: violations.length === 0
+            });
+        }
+        // Convert to ES5
+        let es5Code = code;
+        let conversions = [];
+        // 1. Convert const/let to var
+        es5Code = es5Code.replace(/\b(const|let)\s+/g, (match, keyword) => {
+            conversions.push({ from: keyword, to: 'var', type: 'variable_declaration' });
+            return 'var ';
+        });
+        // 2. Convert arrow functions
+        es5Code = es5Code.replace(/\(([^)]*)\)\s*=>\s*\{/g, (match, params) => {
+            conversions.push({ from: `(${params}) => {`, to: `function(${params}) {`, type: 'arrow_function' });
+            return `function(${params}) {`;
+        });
+        // Single-line arrow functions
+        es5Code = es5Code.replace(/\(([^)]*)\)\s*=>\s*([^;{}\n]+)/g, (match, params, body) => {
+            conversions.push({ from: `(${params}) => ${body}`, to: `function(${params}) { return ${body}; }`, type: 'arrow_function_single' });
+            return `function(${params}) { return ${body}; }`;
+        });
+        // 3. Convert template literals
+        es5Code = es5Code.replace(/`([^`]*)`/g, (match, content) => {
+            // Extract ${...} expressions
+            const withVars = content.replace(/\$\{([^}]+)\}/g, (m, expr) => `' + (${expr}) + '`);
+            const converted = `'${withVars}'`.replace(/'' \+ /g, '').replace(/ \+ ''/g, '');
+            conversions.push({ from: match, to: converted, type: 'template_literal' });
+            return converted;
+        });
+        // 4. Convert destructuring (simple cases)
+        es5Code = es5Code.replace(/(?:const|let|var)\s*\{([^}]+)\}\s*=\s*([^;]+);/g, (match, props, source) => {
+            const properties = props.split(',').map((p) => p.trim());
+            const assignments = properties.map((p) => `var ${p} = ${source}.${p};`).join('\n');
+            conversions.push({ from: match, to: assignments, type: 'destructuring' });
+            return assignments;
+        });
+        // 5. Convert for...of to traditional for loop
+        es5Code = es5Code.replace(/for\s*\(\s*(?:const|let|var)\s+(\w+)\s+of\s+([^)]+)\)/g, (match, variable, array) => {
+            const converted = `for (var __i = 0; __i < ${array}.length; __i++) {\nvar ${variable} = ${array}[__i];`;
+            conversions.push({ from: match, to: converted, type: 'for_of_loop' });
+            return converted;
+        });
+        // Validate result
+        const finalViolations = detectES6Features(es5Code);
+        return (0, error_handler_js_1.createSuccessResult)({
+            original_code: code,
+            es5_code: es5Code,
+            conversions,
+            conversions_count: conversions.length,
+            es5_compliant: finalViolations.length === 0,
+            remaining_violations: finalViolations
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+function detectES6Features(code) {
+    const violations = [];
+    const patterns = [
+        { regex: /\bconst\s+/g, type: 'const', severity: 'error' },
+        { regex: /\blet\s+/g, type: 'let', severity: 'error' },
+        { regex: /\([^)]*\)\s*=>/g, type: 'arrow_function', severity: 'error' },
+        { regex: /`[^`]*`/g, type: 'template_literal', severity: 'error' },
+        { regex: /\{[^}]+\}\s*=/g, type: 'destructuring', severity: 'error' },
+        { regex: /for\s*\([^)]*\s+of\s+/g, type: 'for_of', severity: 'error' },
+        { regex: /class\s+\w+/g, type: 'class', severity: 'error' },
+        { regex: /\.\.\./g, type: 'spread_operator', severity: 'error' }
+    ];
+    patterns.forEach(({ regex, type, severity }) => {
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            violations.push({
+                type,
+                severity,
+                line: code.substring(0, match.index).split('\n').length,
+                code: match[0],
+                fix: getFixSuggestion(type)
+            });
+        }
+    });
+    return violations;
+}
+function getFixSuggestion(type) {
+    const fixes = {
+        const: "Use 'var' instead",
+        let: "Use 'var' instead",
+        arrow_function: "Use function() {} syntax",
+        template_literal: "Use string concatenation with +",
+        destructuring: "Use explicit property access",
+        for_of: "Use traditional for loop with index",
+        class: "Use function constructor with prototype",
+        spread_operator: "Use Array.prototype methods"
+    };
+    return fixes[type] || 'Convert to ES5 equivalent';
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_convert_to_es5.js.map

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_list_supported_artifacts.d.ts

@@ -0,0 +1,11 @@
+/**
+ * snow_list_supported_artifacts - List supported artifact types for local sync
+ *
+ * Returns comprehensive list of ServiceNow artifact types that can be pulled/pushed via local sync.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_list_supported_artifacts.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_list_supported_artifacts.js

@@ -0,0 +1,119 @@
+"use strict";
+/**
+ * snow_list_supported_artifacts - List supported artifact types for local sync
+ *
+ * Returns comprehensive list of ServiceNow artifact types that can be pulled/pushed via local sync.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const error_handler_js_1 = require("../../shared/error-handler.js");
+exports.toolDefinition = {
+    name: 'snow_list_supported_artifacts',
+    description: 'List all ServiceNow artifact types supported by local sync',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            include_details: { type: 'boolean', description: 'Include field mappings and sync capabilities', default: false },
+            category: {
+                type: 'string',
+                description: 'Filter by artifact category',
+                enum: ['ui', 'script', 'flow', 'data', 'integration', 'all'],
+                default: 'all'
+            }
+        }
+    }
+};
+async function execute(args, context) {
+    const { include_details = false, category = 'all' } = args;
+    const artifacts = getSupportedArtifacts(category);
+    if (include_details) {
+        return (0, error_handler_js_1.createSuccessResult)({
+            total_count: artifacts.length,
+            artifacts: artifacts.map(a => ({
+                ...a,
+                fields: getArtifactFields(a.table),
+                capabilities: getArtifactCapabilities(a.table)
+            }))
+        }, { category });
+    }
+    return (0, error_handler_js_1.createSuccessResult)({
+        total_count: artifacts.length,
+        artifacts: artifacts.map(a => ({
+            table: a.table,
+            name: a.name,
+            category: a.category,
+            description: a.description
+        }))
+    }, { category });
+}
+function getSupportedArtifacts(category) {
+    const allArtifacts = [
+        // UI Artifacts
+        { table: 'sp_widget', name: 'Service Portal Widget', category: 'ui', description: 'Service Portal widgets with HTML/CSS/JS' },
+        { table: 'sys_ux_page', name: 'UI Builder Page', category: 'ui', description: 'UI Builder / Experience pages' },
+        { table: 'sys_ui_page', name: 'UI Page', category: 'ui', description: 'Classic UI pages with HTML/Jelly' },
+        { table: 'sys_ui_macro', name: 'UI Macro', category: 'ui', description: 'Reusable UI macros' },
+        { table: 'sys_ux_lib_component', name: 'UI Component', category: 'ui', description: 'UI Builder custom components' },
+        // Script Artifacts
+        { table: 'sys_script_include', name: 'Script Include', category: 'script', description: 'Server-side reusable scripts' },
+        { table: 'sys_script', name: 'Business Rule', category: 'script', description: 'Business rules for table operations' },
+        { table: 'sys_script_client', name: 'Client Script', category: 'script', description: 'Client-side form scripts' },
+        { table: 'sys_ui_script', name: 'UI Script', category: 'script', description: 'Global client-side scripts' },
+        { table: 'sys_script_fix', name: 'Fix Script', category: 'script', description: 'One-time fix scripts' },
+        { table: 'sysauto_script', name: 'Scheduled Job', category: 'script', description: 'Scheduled background scripts' },
+        // Flow Artifacts
+        { table: 'sys_hub_flow', name: 'Flow Designer Flow', category: 'flow', description: 'Flow Designer workflows' },
+        { table: 'sys_hub_action_type', name: 'Flow Action', category: 'flow', description: 'Custom flow actions' },
+        { table: 'wf_workflow', name: 'Workflow', category: 'flow', description: 'Classic workflow engine' },
+        // Data Artifacts
+        { table: 'sys_transform_map', name: 'Transform Map', category: 'data', description: 'Data transformation maps' },
+        { table: 'sys_import_set_row', name: 'Import Set', category: 'data', description: 'Data import staging' },
+        // Integration Artifacts
+        { table: 'sys_rest_message', name: 'REST Message', category: 'integration', description: 'Outbound REST integrations' },
+        { table: 'sys_web_service', name: 'Web Service', category: 'integration', description: 'SOAP web services' },
+        { table: 'sys_rest_message_fn', name: 'REST Method', category: 'integration', description: 'REST message methods' }
+    ];
+    if (category === 'all') {
+        return allArtifacts;
+    }
+    return allArtifacts.filter(a => a.category === category);
+}
+function getArtifactFields(table) {
+    const fieldMappings = {
+        sp_widget: {
+            files: ['template.html', 'script.js', 'client_script.js', 'css.css', 'option_schema.json'],
+            metadata: ['name', 'description', 'data_table', 'public', 'roles']
+        },
+        sys_script_include: {
+            files: ['script.js'],
+            metadata: ['name', 'description', 'api_name', 'client_callable', 'access']
+        },
+        sys_script: {
+            files: ['script.js', 'condition.js'],
+            metadata: ['name', 'table', 'when', 'order', 'active', 'filter_condition']
+        },
+        sys_hub_flow: {
+            files: ['flow_definition.json'],
+            metadata: ['name', 'description', 'trigger_type', 'active']
+        },
+        sys_ux_page: {
+            files: ['page_config.json'],
+            metadata: ['name', 'title', 'route', 'experience']
+        }
+    };
+    return fieldMappings[table] || { files: ['main.txt'], metadata: ['name'] };
+}
+function getArtifactCapabilities(table) {
+    return {
+        supports_pull: true,
+        supports_push: true,
+        supports_es5_validation: ['sys_script_include', 'sys_script', 'sp_widget'].includes(table),
+        supports_coherence_check: ['sp_widget'].includes(table),
+        requires_update_set: true,
+        supports_versioning: true
+    };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_list_supported_artifacts.js.map

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_pull_artifact.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_pull_artifact - Pull artifact to local files
+ *
+ * Pull ServiceNow artifacts to local files for editing with Claude Code
+ * native tools. Enables powerful multi-file editing and search.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_pull_artifact.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_pull_artifact.js

@@ -0,0 +1,187 @@
+"use strict";
+/**
+ * snow_pull_artifact - Pull artifact to local files
+ *
+ * Pull ServiceNow artifacts to local files for editing with Claude Code
+ * native tools. Enables powerful multi-file editing and search.
+ */
+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.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+exports.toolDefinition = {
+    name: 'snow_pull_artifact',
+    description: 'Pull ServiceNow artifact to local files for editing with native tools',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sys_id: {
+                type: 'string',
+                description: 'sys_id of artifact to pull'
+            },
+            table: {
+                type: 'string',
+                description: 'Table name (optional, will auto-detect if not provided)',
+                enum: ['sp_widget', 'sys_ux_page', 'sys_hub_flow', 'sys_script_include']
+            },
+            output_dir: {
+                type: 'string',
+                description: 'Local directory to save files (default: /tmp/snow-flow-artifacts)'
+            }
+        },
+        required: ['sys_id']
+    }
+};
+async function execute(args, context) {
+    const { sys_id, table, output_dir = path.join(os.tmpdir(), 'snow-flow-artifacts') } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Auto-detect table if not provided
+        let artifactTable = table;
+        if (!artifactTable) {
+            artifactTable = await detectArtifactTable(client, sys_id);
+        }
+        // Get artifact data
+        const response = await client.get(`/api/now/table/${artifactTable}/${sys_id}`);
+        if (!response.data || !response.data.result) {
+            return (0, error_handler_js_1.createErrorResult)(`Artifact not found: ${sys_id}`);
+        }
+        const artifact = response.data.result;
+        // Create output directory
+        const artifactName = artifact.name || artifact.id || sys_id;
+        const artifactDir = path.join(output_dir, artifactTable, artifactName);
+        await fs.mkdir(artifactDir, { recursive: true });
+        const files = [];
+        // Extract files based on artifact type
+        if (artifactTable === 'sp_widget') {
+            // Widget files
+            if (artifact.template) {
+                const templateFile = path.join(artifactDir, `${artifactName}.html`);
+                await fs.writeFile(templateFile, artifact.template, 'utf-8');
+                files.push(templateFile);
+            }
+            if (artifact.script) {
+                const scriptFile = path.join(artifactDir, `${artifactName}.server.js`);
+                await fs.writeFile(scriptFile, artifact.script, 'utf-8');
+                files.push(scriptFile);
+            }
+            if (artifact.client_script) {
+                const clientFile = path.join(artifactDir, `${artifactName}.client.js`);
+                await fs.writeFile(clientFile, artifact.client_script, 'utf-8');
+                files.push(clientFile);
+            }
+            if (artifact.css) {
+                const cssFile = path.join(artifactDir, `${artifactName}.css`);
+                await fs.writeFile(cssFile, artifact.css, 'utf-8');
+                files.push(cssFile);
+            }
+            if (artifact.option_schema) {
+                const optionsFile = path.join(artifactDir, `${artifactName}.options.json`);
+                await fs.writeFile(optionsFile, artifact.option_schema, 'utf-8');
+                files.push(optionsFile);
+            }
+        }
+        else if (artifactTable === 'sys_script_include') {
+            // Script Include
+            const scriptFile = path.join(artifactDir, `${artifactName}.js`);
+            await fs.writeFile(scriptFile, artifact.script || '', 'utf-8');
+            files.push(scriptFile);
+        }
+        // Create README with context
+        const readmeFile = path.join(artifactDir, 'README.md');
+        const readme = `# ${artifactName}
+
+**Type:** ${artifactTable}
+**sys_id:** ${sys_id}
+**Description:** ${artifact.description || 'No description'}
+
+## Files
+
+${files.map(f => `- ${path.basename(f)}`).join('\n')}
+
+## Instructions
+
+1. Edit files using Claude Code native tools
+2. Use multi-file search and refactoring
+3. Validate changes with snow_validate_artifact_coherence
+4. Push changes back with snow_push_artifact
+
+## Original Data
+
+\`\`\`json
+${JSON.stringify(artifact, null, 2)}
+\`\`\`
+`;
+        await fs.writeFile(readmeFile, readme, 'utf-8');
+        files.push(readmeFile);
+        return (0, error_handler_js_1.createSuccessResult)({
+            directory: artifactDir,
+            files,
+            artifact: {
+                sys_id,
+                table: artifactTable,
+                name: artifactName
+            }
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+async function detectArtifactTable(client, sys_id) {
+    const tables = ['sp_widget', 'sys_ux_page', 'sys_hub_flow', 'sys_script_include'];
+    for (const table of tables) {
+        try {
+            const response = await client.get(`/api/now/table/${table}/${sys_id}`, {
+                params: { sysparm_fields: 'sys_id' }
+            });
+            if (response.data && response.data.result) {
+                return table;
+            }
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    throw new Error(`Could not detect table for sys_id: ${sys_id}`);
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_pull_artifact.js.map

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_push_artifact.d.ts

@@ -0,0 +1,12 @@
+/**
+ * snow_push_artifact - Push local changes back to ServiceNow
+ *
+ * Push locally edited artifact files back to ServiceNow with
+ * validation and coherence checking.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+export declare const version = "1.0.0";
+export declare const author = "Snow-Flow SDK Migration";
+//# sourceMappingURL=snow_push_artifact.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/local-sync/snow_push_artifact.js

@@ -0,0 +1,190 @@
+"use strict";
+/**
+ * snow_push_artifact - Push local changes back to ServiceNow
+ *
+ * Push locally edited artifact files back to ServiceNow with
+ * validation and coherence checking.
+ */
+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.author = exports.version = exports.toolDefinition = void 0;
+exports.execute = execute;
+const auth_js_1 = require("../../shared/auth.js");
+const error_handler_js_1 = require("../../shared/error-handler.js");
+const fs = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+exports.toolDefinition = {
+    name: 'snow_push_artifact',
+    description: 'Push locally edited artifact files back to ServiceNow with validation',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sys_id: {
+                type: 'string',
+                description: 'sys_id of artifact to update'
+            },
+            directory: {
+                type: 'string',
+                description: 'Directory containing edited artifact files'
+            },
+            validate: {
+                type: 'boolean',
+                description: 'Validate before pushing (ES5, coherence)',
+                default: true
+            },
+            force: {
+                type: 'boolean',
+                description: 'Force push despite validation warnings',
+                default: false
+            }
+        },
+        required: ['sys_id', 'directory']
+    }
+};
+async function execute(args, context) {
+    const { sys_id, directory, validate = true, force = false } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Detect artifact type from directory structure
+        const { table, artifact } = await loadArtifactFromDirectory(directory);
+        // Validate if requested
+        if (validate && !force) {
+            if (table === 'sp_widget') {
+                // ES5 validation
+                if (artifact.script) {
+                    const es5Check = validateES5(artifact.script);
+                    if (!es5Check.valid) {
+                        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.ES5_SYNTAX_ERROR, 'Server script contains non-ES5 syntax', { details: { violations: es5Check.violations } });
+                    }
+                }
+                // Coherence validation
+                const coherenceCheck = validateCoherence(artifact);
+                if (!coherenceCheck.coherent) {
+                    const critical = coherenceCheck.issues.filter((i) => i.severity === 'critical');
+                    if (critical.length > 0) {
+                        throw new error_handler_js_1.SnowFlowError(error_handler_js_1.ErrorType.WIDGET_COHERENCE_ERROR, 'Widget coherence validation failed', { details: { issues: critical } });
+                    }
+                }
+            }
+        }
+        // Push to ServiceNow
+        const updateResponse = await client.put(`/api/now/table/${table}/${sys_id}`, artifact);
+        return (0, error_handler_js_1.createSuccessResult)({
+            updated: true,
+            sys_id,
+            table,
+            artifact: updateResponse.data.result,
+            validation: validate ? 'passed' : 'skipped'
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error instanceof error_handler_js_1.SnowFlowError ? error : error.message);
+    }
+}
+async function loadArtifactFromDirectory(directory) {
+    const files = await fs.readdir(directory);
+    // Detect artifact type
+    const hasWidget = files.some(f => f.endsWith('.server.js') || f.endsWith('.client.js'));
+    if (hasWidget) {
+        // Widget artifact
+        const artifact = {};
+        for (const file of files) {
+            const filePath = path.join(directory, file);
+            const content = await fs.readFile(filePath, 'utf-8');
+            if (file.endsWith('.html')) {
+                artifact.template = content;
+            }
+            else if (file.endsWith('.server.js')) {
+                artifact.script = content;
+            }
+            else if (file.endsWith('.client.js')) {
+                artifact.client_script = content;
+            }
+            else if (file.endsWith('.css')) {
+                artifact.css = content;
+            }
+            else if (file.endsWith('.options.json')) {
+                artifact.option_schema = content;
+            }
+        }
+        return { table: 'sp_widget', artifact };
+    }
+    // Default to script include
+    const scriptFile = files.find(f => f.endsWith('.js'));
+    if (scriptFile) {
+        const script = await fs.readFile(path.join(directory, scriptFile), 'utf-8');
+        return { table: 'sys_script_include', artifact: { script } };
+    }
+    throw new Error('Could not determine artifact type from directory');
+}
+function validateES5(code) {
+    const violations = [];
+    const patterns = [
+        { regex: /\b(const|let)\s+/g, type: 'const/let' },
+        { regex: /\([^)]*\)\s*=>/g, type: 'arrow_function' },
+        { regex: /`[^`]*`/g, type: 'template_literal' }
+    ];
+    patterns.forEach(({ regex, type }) => {
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            violations.push({ type, code: match[0] });
+        }
+    });
+    return { valid: violations.length === 0, violations };
+}
+function validateCoherence(artifact) {
+    const issues = [];
+    // Check if HTML references exist in server
+    if (artifact.template && artifact.script) {
+        const dataRefs = [...artifact.template.matchAll(/\{\{data\.(\w+)\}\}/g)].map(m => m[1]);
+        const serverData = [...artifact.script.matchAll(/data\.(\w+)\s*=/g)].map(m => m[1]);
+        dataRefs.forEach(ref => {
+            if (!serverData.includes(ref)) {
+                issues.push({
+                    type: 'missing_data',
+                    severity: 'critical',
+                    description: `HTML references data.${ref} but server doesn't initialize it`
+                });
+            }
+        });
+    }
+    return {
+        coherent: issues.filter(i => i.severity === 'critical').length === 0,
+        issues
+    };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_push_artifact.js.map