snow-flow 3.0.8 → 3.0.10

package/dist/utils/scope-utils.js

@@ -1,386 +0,0 @@
-"use strict";
-/**
- * Utility functions for scope management and analysis
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScopeUtils = void 0;
-const global_scope_strategy_js_1 = require("../strategies/global-scope-strategy.js");
-class ScopeUtils {
-    /**
-     * Analyze artifact content to determine optimal scope
-     */
-    static analyzeArtifactScope(artifactType, artifactData) {
-        const _analysis = {
-            recommendedScope: global_scope_strategy_js_1.ScopeType.GLOBAL,
-            confidence: 0,
-            indicators: {
-                global: [],
-                application: [],
-                system: []
-            },
-            complexity: 'low',
-            crossAppIntegration: false
-        };
-        const content = this.extractArtifactContent(artifactData);
-        const contentLower = content.toLowerCase();
-        // Global scope indicators
-        const globalIndicators = [
-            { pattern: /\b(global|system|util|common|shared|library)\b/gi, weight: 0.3 },
-            { pattern: /\b(cross[_-]?application|multi[_-]?app|enterprise)\b/gi, weight: 0.4 },
-            { pattern: /\b(infrastructure|platform|framework)\b/gi, weight: 0.35 },
-            { pattern: /\b(gs\.|GlideSystem|GlideRecord)\b/gi, weight: 0.2 },
-            { pattern: /\b(api|rest|soap|integration)\b/gi, weight: 0.25 }
-        ];
-        // Application scope indicators
-        const applicationIndicators = [
-            { pattern: /\b(business|custom|specific|department)\b/gi, weight: 0.3 },
-            { pattern: /\b(workflow|process|procedure)\b/gi, weight: 0.2 },
-            { pattern: /\b(application[_-]?specific|app[_-]?only)\b/gi, weight: 0.4 },
-            { pattern: /\b(isolated|contained|scoped)\b/gi, weight: 0.25 }
-        ];
-        // System indicators
-        const systemIndicators = [
-            { pattern: /\b(admin|administrator|system[_-]?admin)\b/gi, weight: 0.3 },
-            { pattern: /\b(configuration|setting|property)\b/gi, weight: 0.2 },
-            { pattern: /\b(maintenance|monitoring|logging)\b/gi, weight: 0.25 }
-        ];
-        // Analyze global indicators
-        let globalScore = 0;
-        globalIndicators.forEach(indicator => {
-            const matches = content.match(indicator.pattern);
-            if (matches) {
-                globalScore += indicator.weight * matches.length;
-                _analysis.indicators.global.push(`${indicator.pattern.source} (${matches.length} matches)`);
-            }
-        });
-        // Analyze application indicators
-        let applicationScore = 0;
-        applicationIndicators.forEach(indicator => {
-            const matches = content.match(indicator.pattern);
-            if (matches) {
-                applicationScore += indicator.weight * matches.length;
-                _analysis.indicators.application.push(`${indicator.pattern.source} (${matches.length} matches)`);
-            }
-        });
-        // Analyze system indicators
-        let systemScore = 0;
-        systemIndicators.forEach(indicator => {
-            const matches = content.match(indicator.pattern);
-            if (matches) {
-                systemScore += indicator.weight * matches.length;
-                _analysis.indicators.system.push(`${indicator.pattern.source} (${matches.length} matches)`);
-            }
-        });
-        // Determine recommended scope
-        const totalScore = globalScore + applicationScore + systemScore;
-        if (totalScore > 0) {
-            if (globalScore > applicationScore && globalScore > systemScore) {
-                _analysis.recommendedScope = global_scope_strategy_js_1.ScopeType.GLOBAL;
-                _analysis.confidence = Math.min(globalScore / totalScore, 1.0);
-            }
-            else if (applicationScore > globalScore && applicationScore > systemScore) {
-                _analysis.recommendedScope = global_scope_strategy_js_1.ScopeType.APPLICATION;
-                _analysis.confidence = Math.min(applicationScore / totalScore, 1.0);
-            }
-            else {
-                _analysis.recommendedScope = global_scope_strategy_js_1.ScopeType.AUTO;
-                _analysis.confidence = 0.5;
-            }
-        }
-        else {
-            _analysis.confidence = 0.3;
-        }
-        // Analyze complexity
-        _analysis.complexity = this.analyzeComplexity(artifactType, artifactData);
-        // Check for cross-application integration
-        _analysis.crossAppIntegration = this.hasCrossAppIntegration(content);
-        return _analysis;
-    }
-    /**
-     * Extract content from artifact for analysis
-     */
-    static extractArtifactContent(artifactData) {
-        const contentFields = [
-            'name', 'description', 'short_description', 'script', 'template',
-            'client_script', 'server_script', 'condition', 'instructions'
-        ];
-        let content = '';
-        contentFields.forEach(field => {
-            if (artifactData[field]) {
-                content += ` ${artifactData[field]}`;
-            }
-        });
-        // Include activity and variable information for flows
-        if (artifactData.activities) {
-            artifactData.activities.forEach((activity) => {
-                content += ` ${activity.name} ${activity.type}`;
-                if (activity.description)
-                    content += ` ${activity.description}`;
-            });
-        }
-        return content;
-    }
-    /**
-     * Analyze artifact complexity
-     */
-    static analyzeComplexity(artifactType, artifactData) {
-        let complexityScore = 0;
-        // Type-specific complexity scoring
-        switch (artifactType) {
-            case 'flow':
-                const activityCount = artifactData.activities?.length || 0;
-                complexityScore += activityCount * 0.1;
-                // Check for complex activity types
-                if (artifactData.activities) {
-                    const complexTypes = ['script', 'condition', 'loop', 'rest', 'soap'];
-                    const complexActivities = artifactData.activities.filter((a) => complexTypes.includes(a.type));
-                    complexityScore += complexActivities.length * 0.3;
-                }
-                break;
-            case 'script_include':
-                const scriptLength = artifactData.script?.length || 0;
-                complexityScore += scriptLength / 1000 * 0.2; // 0.2 per 1000 chars
-                // Check for complex script patterns
-                if (artifactData.script) {
-                    const complexPatterns = [
-                        /function\s+\w+\s*\(/g, // Function definitions
-                        /for\s*\(|while\s*\(/g, // Loops
-                        /if\s*\(|switch\s*\(/g, // Conditionals
-                        /try\s*\{|catch\s*\(/g // Error handling
-                    ];
-                    complexPatterns.forEach(pattern => {
-                        const matches = artifactData.script.match(pattern);
-                        if (matches)
-                            complexityScore += matches.length * 0.1;
-                    });
-                }
-                break;
-            case 'widget':
-                const templateLength = artifactData.template?.length || 0;
-                const scriptLength2 = (artifactData.client_script?.length || 0) + (artifactData.server_script?.length || 0);
-                complexityScore += (templateLength + scriptLength2) / 1000 * 0.15;
-                break;
-            default:
-                complexityScore += 0.3; // Default complexity
-        }
-        // Return complexity level
-        if (complexityScore > 2.0)
-            return 'high';
-        if (complexityScore > 1.0)
-            return 'medium';
-        return 'low';
-    }
-    /**
-     * Check if artifact has cross-application integration
-     */
-    static hasCrossAppIntegration(content) {
-        const integrationPatterns = [
-            /\b(rest|soap|api)\b/gi,
-            /\b(integration|connector|bridge)\b/gi,
-            /\b(cross[_-]?application|multi[_-]?app)\b/gi,
-            /\b(external|third[_-]?party)\b/gi,
-            /\b(http|https|url|endpoint)\b/gi
-        ];
-        return integrationPatterns.some(pattern => pattern.test(content));
-    }
-    /**
-     * Validate scope configuration
-     */
-    static validateScopeConfiguration(config) {
-        const issues = [];
-        // Validate scope type
-        if (!config.type || !Object.values(global_scope_strategy_js_1.ScopeType).includes(config.type)) {
-            issues.push('Invalid or missing scope type');
-        }
-        // Validate global scope configuration
-        if (config.type === global_scope_strategy_js_1.ScopeType.GLOBAL) {
-            if (config.globalDomain && config.globalDomain !== 'global') {
-                issues.push('Global scope should use "global" domain');
-            }
-        }
-        // Validate application scope configuration
-        if (config.type === global_scope_strategy_js_1.ScopeType.APPLICATION) {
-            if (!config.applicationId && !config.applicationName) {
-                issues.push('Application scope requires applicationId or applicationName');
-            }
-        }
-        return {
-            isValid: issues.length === 0,
-            issues
-        };
-    }
-    /**
-     * Generate scope recommendation report
-     */
-    static generateScopeReport(_analysis) {
-        const report = `
-Scope Analysis Report
-====================
-
-Recommended Scope: ${_analysis.recommendedScope}
-Confidence: ${(_analysis.confidence * 100).toFixed(1)}%
-Complexity: ${_analysis.complexity}
-Cross-App Integration: ${_analysis.crossAppIntegration ? 'Yes' : 'No'}
-
-Indicators:
------------
-Global Scope Indicators:
-${_analysis.indicators.global.map(i => `  • ${i}`).join('\n')}
-
-Application Scope Indicators:
-${_analysis.indicators.application.map(i => `  • ${i}`).join('\n')}
-
-System Indicators:
-${_analysis.indicators.system.map(i => `  • ${i}`).join('\n')}
-
-Recommendations:
----------------
-${this.generateRecommendations(_analysis).map(r => `  • ${r}`).join('\n')}
-`;
-        return report;
-    }
-    /**
-     * Generate recommendations based on analysis
-     */
-    static generateRecommendations(_analysis) {
-        const recommendations = [];
-        if (_analysis.confidence < 0.5) {
-            recommendations.push('Consider manual scope selection due to low confidence');
-        }
-        if (_analysis.complexity === 'high') {
-            recommendations.push('High complexity artifact - ensure proper testing');
-        }
-        if (_analysis.crossAppIntegration) {
-            recommendations.push('Cross-application integration detected - global scope recommended');
-        }
-        if (_analysis.recommendedScope === global_scope_strategy_js_1.ScopeType.GLOBAL) {
-            recommendations.push('Ensure global scope permissions are available');
-            recommendations.push('Consider impact on system performance');
-        }
-        if (_analysis.recommendedScope === global_scope_strategy_js_1.ScopeType.APPLICATION) {
-            recommendations.push('Ensure application scope is properly configured');
-            recommendations.push('Consider application lifecycle management');
-        }
-        return recommendations;
-    }
-    /**
-     * Compare two scope configurations
-     */
-    static compareScopeConfigurations(config1, config2) {
-        const differences = [];
-        if (config1.type !== config2.type) {
-            differences.push(`Scope type: ${config1.type} vs ${config2.type}`);
-        }
-        if (config1.globalDomain !== config2.globalDomain) {
-            differences.push(`Global domain: ${config1.globalDomain} vs ${config2.globalDomain}`);
-        }
-        if (config1.applicationId !== config2.applicationId) {
-            differences.push(`Application ID: ${config1.applicationId} vs ${config2.applicationId}`);
-        }
-        if (config1.fallbackToGlobal !== config2.fallbackToGlobal) {
-            differences.push(`Fallback to global: ${config1.fallbackToGlobal} vs ${config2.fallbackToGlobal}`);
-        }
-        return {
-            isDifferent: differences.length > 0,
-            differences
-        };
-    }
-    /**
-     * Get scope display name
-     */
-    static getScopeDisplayName(scope) {
-        switch (scope) {
-            case global_scope_strategy_js_1.ScopeType.GLOBAL:
-                return 'Global Scope';
-            case global_scope_strategy_js_1.ScopeType.APPLICATION:
-                return 'Application Scope';
-            case global_scope_strategy_js_1.ScopeType.AUTO:
-                return 'Auto Selection';
-            default:
-                return 'Unknown Scope';
-        }
-    }
-    /**
-     * Get scope description
-     */
-    static getScopeDescription(scope) {
-        switch (scope) {
-            case global_scope_strategy_js_1.ScopeType.GLOBAL:
-                return 'System-wide scope with no application boundaries';
-            case global_scope_strategy_js_1.ScopeType.APPLICATION:
-                return 'Application-specific scope with isolation';
-            case global_scope_strategy_js_1.ScopeType.AUTO:
-                return 'Automatic scope selection based on _analysis';
-            default:
-                return 'Unknown scope type';
-        }
-    }
-    /**
-     * Get scope benefits
-     */
-    static getScopeBenefits(scope) {
-        switch (scope) {
-            case global_scope_strategy_js_1.ScopeType.GLOBAL:
-                return [
-                    'System-wide availability',
-                    'Cross-application integration',
-                    'Simplified maintenance',
-                    'Better performance for utilities',
-                    'No boundary restrictions'
-                ];
-            case global_scope_strategy_js_1.ScopeType.APPLICATION:
-                return [
-                    'Application isolation',
-                    'Dedicated namespace',
-                    'Simplified lifecycle management',
-                    'Better security boundaries',
-                    'Easier deployment control'
-                ];
-            case global_scope_strategy_js_1.ScopeType.AUTO:
-                return [
-                    'Optimal scope selection',
-                    'Reduced configuration complexity',
-                    'Intelligent decision making',
-                    'Automatic fallback support',
-                    'Context-aware deployment'
-                ];
-            default:
-                return [];
-        }
-    }
-    /**
-     * Get scope risks
-     */
-    static getScopeRisks(scope) {
-        switch (scope) {
-            case global_scope_strategy_js_1.ScopeType.GLOBAL:
-                return [
-                    'System-wide impact of changes',
-                    'Potential security implications',
-                    'Higher permission requirements',
-                    'More complex troubleshooting',
-                    'Broader testing requirements'
-                ];
-            case global_scope_strategy_js_1.ScopeType.APPLICATION:
-                return [
-                    'Limited cross-application functionality',
-                    'Potential integration challenges',
-                    'Increased complexity for shared utilities',
-                    'Multiple application management',
-                    'Duplication of common functionality'
-                ];
-            case global_scope_strategy_js_1.ScopeType.AUTO:
-                return [
-                    'Potential incorrect scope selection',
-                    'Reduced user control',
-                    'Dependency on _analysis accuracy',
-                    'Complexity in troubleshooting decisions',
-                    'Need for fallback mechanisms'
-                ];
-            default:
-                return [];
-        }
-    }
-}
-exports.ScopeUtils = ScopeUtils;
-//# sourceMappingURL=scope-utils.js.map

package/dist/utils/snow-oauth-old.d.ts

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-/**
- * ServiceNow OAuth Authentication Utility
- * Handles OAuth2 flow for ServiceNow integration
- */
-export interface ServiceNowCredentials {
-    instance: string;
-    clientId: string;
-    clientSecret: string;
-    redirectUri: string;
-    accessToken?: string;
-    refreshToken?: string;
-    expiresAt?: number;
-}
-export interface ServiceNowAuthResult {
-    success: boolean;
-    credentials?: ServiceNowCredentials;
-    error?: string;
-}
-export declare class ServiceNowOAuth {
-    private credentialsFile;
-    private credentials;
-    constructor();
-    /**
-     * Initialize OAuth flow - opens browser and handles callback
-     */
-    authenticate(instance: string, clientId: string, clientSecret: string): Promise<ServiceNowAuthResult>;
-    /**
-     * Generate ServiceNow OAuth authorization URL
-     */
-    private generateAuthUrl;
-    /**
-     * Start local HTTP server to handle OAuth callback
-     */
-    private startCallbackServer;
-    /**
-     * Exchange authorization code for access tokens
-     */
-    private exchangeCodeForTokens;
-    /**
-     * Save credentials to file
-     */
-    private saveCredentials;
-    /**
-     * Load credentials from file
-     */
-    loadCredentials(): Promise<ServiceNowCredentials | null>;
-    /**
-     * Check if credentials are valid and not expired
-     */
-    isAuthenticated(): Promise<boolean>;
-    /**
-     * Refresh access token using refresh token
-     */
-    refreshAccessToken(): Promise<boolean>;
-    /**
-     * Get current credentials
-     */
-    getCredentials(): ServiceNowCredentials | null;
-    /**
-     * Clear stored credentials
-     */
-    logout(): Promise<void>;
-}
-//# sourceMappingURL=snow-oauth-old.d.ts.map