snow-flow 4.6.9 → 5.0.0

package/dist/mcp/servicenow-mcp-unified/tools/deployment/snow_validate_deployment.js

@@ -0,0 +1,288 @@
+"use strict";
+/**
+ * snow_validate_deployment - Pre-deployment validation
+ *
+ * Validates artifacts before deployment to catch issues early.
+ * Checks ES5 syntax, coherence, dependencies, and security.
+ */
+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");
+exports.toolDefinition = {
+    name: 'snow_validate_deployment',
+    description: 'Validate artifact before deployment (ES5, coherence, dependencies, security)',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: {
+                type: 'string',
+                enum: ['widget', 'page', 'flow', 'script_include', 'business_rule'],
+                description: 'Artifact type to validate'
+            },
+            artifact: {
+                type: 'object',
+                description: 'Artifact configuration to validate'
+            },
+            checks: {
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['es5', 'coherence', 'dependencies', 'security', 'performance']
+                },
+                description: 'Validation checks to perform',
+                default: ['es5', 'coherence', 'dependencies']
+            }
+        },
+        required: ['type', 'artifact']
+    }
+};
+async function execute(args, context) {
+    const { type, artifact, checks = ['es5', 'coherence', 'dependencies'] } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        const results = {
+            valid: true,
+            critical_failures: 0,
+            warnings: 0,
+            checks: []
+        };
+        // ES5 validation
+        if (checks.includes('es5') && artifact.script) {
+            const es5Result = await validateES5(artifact.script);
+            results.checks.push({
+                name: 'ES5 Syntax',
+                status: es5Result.valid ? 'PASS' : 'FAIL',
+                critical: true,
+                violations: es5Result.violations
+            });
+            if (!es5Result.valid) {
+                results.valid = false;
+                results.critical_failures++;
+            }
+        }
+        // Widget coherence validation
+        if (checks.includes('coherence') && type === 'widget') {
+            const coherenceResult = await validateCoherence(artifact);
+            const criticalIssues = coherenceResult.issues.filter((i) => i.severity === 'critical');
+            results.checks.push({
+                name: 'Widget Coherence',
+                status: criticalIssues.length === 0 ? 'PASS' : 'FAIL',
+                critical: true,
+                issues: coherenceResult.issues,
+                analysis: coherenceResult.analysis
+            });
+            if (criticalIssues.length > 0) {
+                results.valid = false;
+                results.critical_failures += criticalIssues.length;
+            }
+            results.warnings += coherenceResult.issues.filter((i) => i.severity === 'warning').length;
+        }
+        // Dependency validation
+        if (checks.includes('dependencies')) {
+            const depResult = await validateDependencies(client, artifact);
+            results.checks.push({
+                name: 'Dependencies',
+                status: depResult.allExist ? 'PASS' : 'FAIL',
+                critical: true,
+                missing: depResult.missing
+            });
+            if (!depResult.allExist) {
+                results.valid = false;
+                results.critical_failures += depResult.missing.length;
+            }
+        }
+        // Security scan
+        if (checks.includes('security')) {
+            const securityResult = await scanSecurity(artifact);
+            results.checks.push({
+                name: 'Security',
+                status: securityResult.critical.length === 0 ? 'PASS' : 'WARNING',
+                critical: false,
+                issues: securityResult
+            });
+            results.warnings += securityResult.warnings.length;
+        }
+        // Performance scan
+        if (checks.includes('performance')) {
+            const perfResult = await scanPerformance(artifact);
+            results.checks.push({
+                name: 'Performance',
+                status: perfResult.issues.length === 0 ? 'PASS' : 'WARNING',
+                critical: false,
+                issues: perfResult.issues
+            });
+            results.warnings += perfResult.issues.length;
+        }
+        // Recommendation
+        results.recommendation = results.critical_failures > 0
+            ? 'FIX_ERRORS_BEFORE_DEPLOY'
+            : results.warnings > 0
+                ? 'PROCEED_WITH_CAUTION'
+                : 'PROCEED';
+        return (0, error_handler_js_1.createSuccessResult)(results);
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error.message);
+    }
+}
+async function validateES5(code) {
+    const violations = [];
+    // ES6+ patterns
+    const patterns = [
+        { regex: /\b(const|let)\s+/g, type: 'const/let', fix: "Use 'var'" },
+        { regex: /\([^)]*\)\s*=>/g, type: 'arrow_function', fix: 'Use function() {}' },
+        { regex: /`[^`]*`/g, type: 'template_literal', fix: 'Use string concatenation' },
+        { regex: /\{[^}]*\}\s*=\s*/g, type: 'destructuring', fix: 'Use explicit properties' },
+        { regex: /for\s*\([^)]*\s+of\s+/g, type: 'for_of', fix: 'Use traditional for loop' }
+    ];
+    patterns.forEach(({ regex, type, fix }) => {
+        let match;
+        while ((match = regex.exec(code)) !== null) {
+            violations.push({
+                type,
+                line: code.substring(0, match.index).split('\n').length,
+                code: match[0],
+                fix
+            });
+        }
+    });
+    return { valid: violations.length === 0, violations };
+}
+async function validateCoherence(artifact) {
+    const issues = [];
+    const serverData = [];
+    const htmlRefs = [];
+    const clientMethods = [];
+    const inputActions = [];
+    // Extract server data initializations
+    if (artifact.script) {
+        const dataPattern = /data\.(\w+)\s*=/g;
+        let match;
+        while ((match = dataPattern.exec(artifact.script)) !== null) {
+            serverData.push(match[1]);
+        }
+        const actionPattern = /input\.action\s*===?\s*['"](\w+)['"]/g;
+        while ((match = actionPattern.exec(artifact.script)) !== null) {
+            inputActions.push(match[1]);
+        }
+    }
+    // Extract HTML data references
+    if (artifact.template) {
+        const htmlPattern = /\{\{data\.(\w+)\}\}/g;
+        let match;
+        while ((match = htmlPattern.exec(artifact.template)) !== null) {
+            htmlRefs.push(match[1]);
+            if (!serverData.includes(match[1])) {
+                issues.push({
+                    type: 'missing_data',
+                    severity: 'critical',
+                    description: `HTML references data.${match[1]} but server doesn't initialize it`,
+                    fix: `Add 'data.${match[1]} = ...;' to server script`
+                });
+            }
+        }
+    }
+    // Extract client methods
+    if (artifact.client_script) {
+        const methodPattern = /(?:c|$scope)\.(\w+)\s*=\s*function/g;
+        let match;
+        while ((match = methodPattern.exec(artifact.client_script)) !== null) {
+            clientMethods.push(match[1]);
+        }
+    }
+    return {
+        coherent: issues.filter((i) => i.severity === 'critical').length === 0,
+        issues,
+        analysis: { serverData, htmlRefs, clientMethods, inputActions }
+    };
+}
+async function validateDependencies(client, artifact) {
+    const missing = [];
+    // Extract table references
+    const tablePattern = /new GlideRecord\(['"](\w+)['"]\)/g;
+    const tables = new Set();
+    if (artifact.script) {
+        let match;
+        while ((match = tablePattern.exec(artifact.script)) !== null) {
+            tables.add(match[1]);
+        }
+    }
+    // Check if tables exist
+    for (const table of tables) {
+        try {
+            const response = await client.get(`/api/now/table/sys_db_object`, {
+                params: {
+                    sysparm_query: `name=${table}`,
+                    sysparm_limit: 1
+                }
+            });
+            if (response.data.result.length === 0) {
+                missing.push({ type: 'table', name: table });
+            }
+        }
+        catch (error) {
+            missing.push({ type: 'table', name: table, error: 'Check failed' });
+        }
+    }
+    return { allExist: missing.length === 0, missing };
+}
+async function scanSecurity(artifact) {
+    const critical = [];
+    const warnings = [];
+    if (artifact.script || artifact.client_script) {
+        const code = (artifact.script || '') + (artifact.client_script || '');
+        // Check for hardcoded credentials
+        if (/password\s*=\s*['"][^'"]+['"]|api[_-]?key\s*=\s*['"][^'"]+['"]/i.test(code)) {
+            critical.push({
+                issue: 'Hardcoded credentials detected',
+                severity: 'critical',
+                fix: 'Use system properties or encrypted credentials'
+            });
+        }
+        // Check for eval usage
+        if (/\beval\s*\(/g.test(code)) {
+            critical.push({
+                issue: 'eval() usage detected',
+                severity: 'critical',
+                fix: 'Avoid eval() - use safer alternatives'
+            });
+        }
+        // Check for innerHTML usage (XSS risk)
+        if (/\.innerHTML\s*=/g.test(code)) {
+            warnings.push({
+                issue: 'innerHTML usage (XSS risk)',
+                severity: 'warning',
+                fix: 'Use textContent or sanitize input'
+            });
+        }
+    }
+    return { critical, warnings };
+}
+async function scanPerformance(artifact) {
+    const issues = [];
+    if (artifact.script) {
+        // Check for unlimited queries
+        if (/new GlideRecord\([^)]+\)[^;]*query\(\)/.test(artifact.script) &&
+            !/setLimit\(/.test(artifact.script)) {
+            issues.push({
+                issue: 'Unlimited query detected',
+                severity: 'warning',
+                fix: 'Add .setLimit(100) before .query()'
+            });
+        }
+        // Check for getRowCount() usage
+        if (/getRowCount\(\)/.test(artifact.script)) {
+            issues.push({
+                issue: 'getRowCount() usage (slow)',
+                severity: 'warning',
+                fix: 'Use GlideAggregate for counts'
+            });
+        }
+    }
+    return { issues };
+}
+exports.version = '1.0.0';
+exports.author = 'Snow-Flow SDK Migration';
+//# sourceMappingURL=snow_validate_deployment.js.map

package/dist/mcp/servicenow-mcp-unified/tools/development/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Development Tools - Index
+ *
+ * Exports all development assistant tools for the ServiceNow Unified MCP Server
+ */
+export { toolDefinition as snow_find_artifact_def, execute as snow_find_artifact_exec } from './snow_find_artifact.js';
+export { toolDefinition as snow_get_by_sysid_def, execute as snow_get_by_sysid_exec } from './snow_get_by_sysid.js';
+export { toolDefinition as snow_analyze_artifact_def, execute as snow_analyze_artifact_exec } from './snow_analyze_artifact.js';
+export { toolDefinition as snow_analyze_requirements_def, execute as snow_analyze_requirements_exec } from './snow_analyze_requirements.js';
+export { toolDefinition as snow_edit_artifact_def, execute as snow_edit_artifact_exec } from './snow_edit_artifact.js';
+export { toolDefinition as snow_edit_by_sysid_def, execute as snow_edit_by_sysid_exec } from './snow_edit_by_sysid.js';
+export { toolDefinition as snow_memory_search_def, execute as snow_memory_search_exec } from './snow_memory_search.js';
+export { toolDefinition as snow_orchestrate_development_def, execute as snow_orchestrate_development_exec } from './snow_orchestrate_development.js';
+export { toolDefinition as snow_sync_data_consistency_def, execute as snow_sync_data_consistency_exec } from './snow_sync_data_consistency.js';
+export { toolDefinition as snow_validate_live_connection_def, execute as snow_validate_live_connection_exec } from './snow_validate_live_connection.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/development/index.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Development Tools - Index
+ *
+ * Exports all development assistant tools for the ServiceNow Unified MCP Server
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.snow_validate_live_connection_exec = exports.snow_validate_live_connection_def = exports.snow_sync_data_consistency_exec = exports.snow_sync_data_consistency_def = exports.snow_orchestrate_development_exec = exports.snow_orchestrate_development_def = exports.snow_memory_search_exec = exports.snow_memory_search_def = exports.snow_edit_by_sysid_exec = exports.snow_edit_by_sysid_def = exports.snow_edit_artifact_exec = exports.snow_edit_artifact_def = exports.snow_analyze_requirements_exec = exports.snow_analyze_requirements_def = exports.snow_analyze_artifact_exec = exports.snow_analyze_artifact_def = exports.snow_get_by_sysid_exec = exports.snow_get_by_sysid_def = exports.snow_find_artifact_exec = exports.snow_find_artifact_def = void 0;
+var snow_find_artifact_js_1 = require("./snow_find_artifact.js");
+Object.defineProperty(exports, "snow_find_artifact_def", { enumerable: true, get: function () { return snow_find_artifact_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_find_artifact_exec", { enumerable: true, get: function () { return snow_find_artifact_js_1.execute; } });
+var snow_get_by_sysid_js_1 = require("./snow_get_by_sysid.js");
+Object.defineProperty(exports, "snow_get_by_sysid_def", { enumerable: true, get: function () { return snow_get_by_sysid_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_get_by_sysid_exec", { enumerable: true, get: function () { return snow_get_by_sysid_js_1.execute; } });
+var snow_analyze_artifact_js_1 = require("./snow_analyze_artifact.js");
+Object.defineProperty(exports, "snow_analyze_artifact_def", { enumerable: true, get: function () { return snow_analyze_artifact_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_analyze_artifact_exec", { enumerable: true, get: function () { return snow_analyze_artifact_js_1.execute; } });
+var snow_analyze_requirements_js_1 = require("./snow_analyze_requirements.js");
+Object.defineProperty(exports, "snow_analyze_requirements_def", { enumerable: true, get: function () { return snow_analyze_requirements_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_analyze_requirements_exec", { enumerable: true, get: function () { return snow_analyze_requirements_js_1.execute; } });
+var snow_edit_artifact_js_1 = require("./snow_edit_artifact.js");
+Object.defineProperty(exports, "snow_edit_artifact_def", { enumerable: true, get: function () { return snow_edit_artifact_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_edit_artifact_exec", { enumerable: true, get: function () { return snow_edit_artifact_js_1.execute; } });
+var snow_edit_by_sysid_js_1 = require("./snow_edit_by_sysid.js");
+Object.defineProperty(exports, "snow_edit_by_sysid_def", { enumerable: true, get: function () { return snow_edit_by_sysid_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_edit_by_sysid_exec", { enumerable: true, get: function () { return snow_edit_by_sysid_js_1.execute; } });
+var snow_memory_search_js_1 = require("./snow_memory_search.js");
+Object.defineProperty(exports, "snow_memory_search_def", { enumerable: true, get: function () { return snow_memory_search_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_memory_search_exec", { enumerable: true, get: function () { return snow_memory_search_js_1.execute; } });
+var snow_orchestrate_development_js_1 = require("./snow_orchestrate_development.js");
+Object.defineProperty(exports, "snow_orchestrate_development_def", { enumerable: true, get: function () { return snow_orchestrate_development_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_orchestrate_development_exec", { enumerable: true, get: function () { return snow_orchestrate_development_js_1.execute; } });
+var snow_sync_data_consistency_js_1 = require("./snow_sync_data_consistency.js");
+Object.defineProperty(exports, "snow_sync_data_consistency_def", { enumerable: true, get: function () { return snow_sync_data_consistency_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_sync_data_consistency_exec", { enumerable: true, get: function () { return snow_sync_data_consistency_js_1.execute; } });
+var snow_validate_live_connection_js_1 = require("./snow_validate_live_connection.js");
+Object.defineProperty(exports, "snow_validate_live_connection_def", { enumerable: true, get: function () { return snow_validate_live_connection_js_1.toolDefinition; } });
+Object.defineProperty(exports, "snow_validate_live_connection_exec", { enumerable: true, get: function () { return snow_validate_live_connection_js_1.execute; } });
+//# sourceMappingURL=index.js.map

package/dist/mcp/servicenow-mcp-unified/tools/development/snow_analyze_artifact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_analyze_artifact - Analyze artifact structure and dependencies
+ *
+ * Performs comprehensive analysis including dependencies, usage patterns, and optimization opportunities.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+//# sourceMappingURL=snow_analyze_artifact.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/development/snow_analyze_artifact.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * snow_analyze_artifact - Analyze artifact structure and dependencies
+ *
+ * Performs comprehensive analysis including dependencies, usage patterns, and optimization opportunities.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.toolDefinition = {
+    name: 'snow_analyze_artifact',
+    description: 'Performs comprehensive analysis of artifacts including dependencies, usage patterns, and optimization opportunities. Caches results for improved performance.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            sys_id: {
+                type: 'string',
+                description: 'System ID of the artifact'
+            },
+            table: {
+                type: 'string',
+                description: 'ServiceNow table name'
+            }
+        },
+        required: ['sys_id', 'table']
+    }
+};
+async function execute(args, context) {
+    const { sys_id, table } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Fetch artifact
+        const response = await client.getRecord(table, sys_id);
+        if (!response.data?.result) {
+            throw new Error('Artifact not found');
+        }
+        const artifact = response.data.result;
+        // Analyze structure
+        const analysis = {
+            meta: {
+                sys_id: artifact.sys_id,
+                name: artifact.name || artifact.title,
+                type: table,
+                active: artifact.active,
+                last_updated: artifact.sys_updated_on
+            },
+            structure: {
+                fields: Object.keys(artifact).filter(k => !k.startsWith('sys_')),
+                hasScript: !!(artifact.script || artifact.server_script),
+                hasClientScript: !!artifact.client_script,
+                hasTemplate: !!artifact.template,
+                hasCSS: !!artifact.css
+            },
+            dependencies: [],
+            modificationPoints: []
+        };
+        // Detect dependencies (basic)
+        if (artifact.script || artifact.server_script) {
+            const scriptContent = artifact.script || artifact.server_script;
+            // Detect GlideRecord references
+            const tableMatches = scriptContent.match(/new GlideRecord\(['"]([^'"]+)['"]\)/g);
+            if (tableMatches) {
+                analysis.dependencies.push({
+                    type: 'table',
+                    references: [...new Set(tableMatches.map((m) => m.match(/['"]([^'"]+)['"]/)?.[1]))]
+                });
+            }
+            // Detect Script Include references
+            const scriptIncludeMatches = scriptContent.match(/new ([A-Z][a-zA-Z0-9_]+)\(/g);
+            if (scriptIncludeMatches) {
+                analysis.dependencies.push({
+                    type: 'script_include',
+                    references: [...new Set(scriptIncludeMatches.map((m) => m.match(/new ([A-Z][a-zA-Z0-9_]+)/)?.[1]))]
+                });
+            }
+        }
+        // Identify modification points
+        if (table === 'sp_widget') {
+            analysis.modificationPoints.push({ field: 'template', description: 'HTML template structure' }, { field: 'script', description: 'Server-side data processing' }, { field: 'client_script', description: 'Client-side behavior' }, { field: 'css', description: 'Widget styling' });
+        }
+        return (0, error_handler_js_1.createSuccessResult)({
+            analysis,
+            summary: `${artifact.name || 'Artifact'} analyzed successfully`,
+            recommendations: []
+        }, {
+            sys_id,
+            table
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error, { sys_id, table });
+    }
+}
+//# sourceMappingURL=snow_analyze_artifact.js.map

package/dist/mcp/servicenow-mcp-unified/tools/development/snow_analyze_requirements.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_analyze_requirements - Analyze development requirements
+ *
+ * Identifies dependencies, suggests reusable components, and creates implementation roadmaps.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+//# sourceMappingURL=snow_analyze_requirements.d.ts.map

package/dist/mcp/servicenow-mcp-unified/tools/development/snow_analyze_requirements.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * snow_analyze_requirements - Analyze development requirements
+ *
+ * Identifies dependencies, suggests reusable components, and creates implementation roadmaps.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+exports.toolDefinition = {
+    name: 'snow_analyze_requirements',
+    description: 'Analyzes development requirements to identify dependencies, suggest reusable components, and create implementation roadmaps.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            objective: {
+                type: 'string',
+                description: 'Development objective (e.g., "iPhone provisioning for new users")'
+            },
+            auto_discover_dependencies: {
+                type: 'boolean',
+                description: 'Automatically discover required dependencies',
+                default: true
+            },
+            suggest_existing_components: {
+                type: 'boolean',
+                description: 'Suggest reuse of existing components',
+                default: true
+            },
+            create_dependency_map: {
+                type: 'boolean',
+                description: 'Create visual dependency map',
+                default: true
+            },
+            scope_preference: {
+                type: 'string',
+                enum: ['global', 'scoped', 'auto'],
+                description: 'Deployment scope preference',
+                default: 'auto'
+            }
+        },
+        required: ['objective']
+    }
+};
+async function execute(args, context) {
+    const { objective, auto_discover_dependencies = true, suggest_existing_components = true, create_dependency_map = true, scope_preference = 'auto' } = args;
+    try {
+        const client = await (0, auth_js_1.getAuthenticatedClient)(context);
+        // Parse objective to identify key components
+        const keywords = objective.toLowerCase();
+        const analysis = {
+            objective,
+            scope: scope_preference,
+            requiredComponents: [],
+            existingComponents: [],
+            dependencyMap: {},
+            implementationPlan: []
+        };
+        // Identify required components based on keywords
+        if (keywords.includes('workflow') || keywords.includes('flow')) {
+            analysis.requiredComponents.push({
+                type: 'flow',
+                table: 'sys_hub_flow',
+                purpose: 'Process automation'
+            });
+        }
+        if (keywords.includes('widget') || keywords.includes('portal')) {
+            analysis.requiredComponents.push({
+                type: 'widget',
+                table: 'sp_widget',
+                purpose: 'User interface'
+            });
+        }
+        if (keywords.includes('notification') || keywords.includes('email')) {
+            analysis.requiredComponents.push({
+                type: 'notification',
+                table: 'sysevent_email_action',
+                purpose: 'Email notifications'
+            });
+        }
+        if (keywords.includes('table') || keywords.includes('data')) {
+            analysis.requiredComponents.push({
+                type: 'table',
+                table: 'sys_db_object',
+                purpose: 'Data storage'
+            });
+        }
+        // Search for existing components if requested
+        if (suggest_existing_components) {
+            for (const component of analysis.requiredComponents) {
+                try {
+                    const response = await client.query(component.table, {
+                        query: `nameLIKE${objective.split(' ')[0]}^active=true`,
+                        limit: 5
+                    });
+                    if (response.data?.result?.length > 0) {
+                        analysis.existingComponents.push({
+                            ...component,
+                            found: response.data.result.map((r) => ({
+                                sys_id: r.sys_id,
+                                name: r.name || r.title,
+                                description: r.short_description
+                            }))
+                        });
+                    }
+                }
+                catch (error) {
+                    // Continue if search fails
+                }
+            }
+        }
+        // Create dependency map
+        if (create_dependency_map) {
+            analysis.dependencyMap = {
+                nodes: analysis.requiredComponents.map(c => ({
+                    id: c.type,
+                    label: c.type.toUpperCase(),
+                    table: c.table
+                })),
+                edges: []
+            };
+        }
+        // Create implementation plan
+        analysis.implementationPlan = [
+            {
+                phase: 1,
+                name: 'Planning',
+                tasks: [
+                    'Define scope and requirements',
+                    'Review existing components',
+                    'Identify dependencies'
+                ],
+                estimated_days: 2
+            },
+            {
+                phase: 2,
+                name: 'Development',
+                tasks: analysis.requiredComponents.map(c => `Create ${c.type}`),
+                estimated_days: 5
+            },
+            {
+                phase: 3,
+                name: 'Testing',
+                tasks: [
+                    'Unit testing',
+                    'Integration testing',
+                    'User acceptance testing'
+                ],
+                estimated_days: 3
+            },
+            {
+                phase: 4,
+                name: 'Deployment',
+                tasks: [
+                    'Create update set',
+                    'Deploy to production',
+                    'Monitor and validate'
+                ],
+                estimated_days: 1
+            }
+        ];
+        return (0, error_handler_js_1.createSuccessResult)({
+            analysis,
+            summary: `Requirements analyzed: ${analysis.requiredComponents.length} components needed, ${analysis.existingComponents.length} existing components found`,
+            recommendations: [
+                analysis.existingComponents.length > 0 ? 'Consider reusing existing components to save development time' : null,
+                'Follow ServiceNow best practices for component development',
+                'Test in sub-production environment before deploying'
+            ].filter(Boolean)
+        }, {
+            objective,
+            components_needed: analysis.requiredComponents.length,
+            existing_found: analysis.existingComponents.length
+        });
+    }
+    catch (error) {
+        return (0, error_handler_js_1.createErrorResult)(error, { objective });
+    }
+}
+//# sourceMappingURL=snow_analyze_requirements.js.map

package/dist/mcp/servicenow-mcp-unified/tools/development/snow_edit_artifact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * snow_edit_artifact - Edit existing artifacts intelligently
+ *
+ * Modifies ServiceNow artifacts using natural language instructions with automatic validation.
+ */
+import { MCPToolDefinition, ServiceNowContext, ToolResult } from '../../shared/types.js';
+export declare const toolDefinition: MCPToolDefinition;
+export declare function execute(args: any, context: ServiceNowContext): Promise<ToolResult>;
+//# sourceMappingURL=snow_edit_artifact.d.ts.map