snow-flow 3.4.39 → 3.5.0

package/dist/queen/queen-knowledge-base.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Queen Agent Knowledge Base
+ *
+ * Central repository of ServiceNow development patterns, tools, and capabilities
+ * that the Queen Agent uses for strategic decision making.
+ */
+export declare const QUEEN_KNOWLEDGE_BASE: {
+    /**
+     * ServiceNow Development Patterns
+     */
+    developmentPatterns: {
+        widgetDevelopment: {
+            description: string;
+            approaches: {
+                name: string;
+                description: string;
+                optimal_for: string[];
+                workflow: string[];
+                advantages: string[];
+            }[];
+        };
+        scriptDevelopment: {
+            description: string;
+            approaches: {
+                name: string;
+                description: string;
+                optimal_for: string[];
+                workflow: string[];
+                advantages: string[];
+            }[];
+        };
+        flowDevelopment: {
+            description: string;
+            approaches: {
+                name: string;
+                description: string;
+                optimal_for: string[];
+                workflow: string[];
+                limitations: string[];
+            }[];
+        };
+    };
+    /**
+     * Tool Selection Criteria
+     */
+    toolSelectionCriteria: {
+        useLocalSync: {
+            when: string[];
+            artifacts: string[];
+        };
+        useDirectDeployment: {
+            when: string[];
+        };
+        useDirectUpdate: {
+            when: string[];
+        };
+    };
+    /**
+     * Artifact Type Capabilities
+     */
+    artifactCapabilities: {
+        sp_widget: {
+            localSync: boolean;
+            directDeploy: boolean;
+            directUpdate: boolean;
+            coherenceValidation: boolean;
+            es5Required: string[];
+            fields: string[];
+        };
+        sys_script_include: {
+            localSync: boolean;
+            directDeploy: boolean;
+            directUpdate: boolean;
+            es5Required: string[];
+            fields: string[];
+        };
+        sys_script: {
+            localSync: boolean;
+            directDeploy: boolean;
+            directUpdate: boolean;
+            es5Required: string[];
+            fields: string[];
+        };
+        sys_hub_flow: {
+            localSync: boolean;
+            directDeploy: boolean;
+            directUpdate: boolean;
+            fields: string[];
+        };
+        sys_ui_page: {
+            localSync: boolean;
+            directDeploy: boolean;
+            directUpdate: boolean;
+            es5Required: string[];
+            fields: string[];
+        };
+    };
+    /**
+     * Strategic Recommendations
+     */
+    strategicRecommendations: {
+        complexWidgetEdit: {
+            pattern: string;
+            reasoning: string;
+            steps: string[];
+        };
+        bulkRefactoring: {
+            pattern: string;
+            reasoning: string;
+            steps: string[];
+        };
+        quickPrototype: {
+            pattern: string;
+            reasoning: string;
+            steps: string[];
+        };
+    };
+    /**
+     * Common Pitfalls to Avoid
+     */
+    pitfallsToAvoid: {
+        pitfall: string;
+        solution: string;
+    }[];
+    /**
+     * MCP Server Mapping
+     */
+    mcpServerMapping: {
+        snow_pull_artifact: string;
+        snow_push_artifact: string;
+        snow_validate_artifact_coherence: string;
+        snow_list_supported_artifacts: string;
+        snow_sync_status: string;
+        snow_sync_cleanup: string;
+        snow_convert_to_es5: string;
+        snow_deploy: string;
+        snow_update: string;
+        snow_query_table: string;
+        snow_create_script_include: string;
+    };
+};
+/**
+ * Helper function for Queen to determine optimal approach
+ */
+export declare function determineOptimalApproach(objective: string, artifactType: string, context: {
+    hasExistingArtifact: boolean;
+    complexity: 'low' | 'medium' | 'high';
+    requiresRefactoring: boolean;
+    userMentionedModifications: boolean;
+}): string;
+//# sourceMappingURL=queen-knowledge-base.d.ts.map

package/dist/queen/queen-knowledge-base.js

@@ -0,0 +1,283 @@
+"use strict";
+/**
+ * Queen Agent Knowledge Base
+ *
+ * Central repository of ServiceNow development patterns, tools, and capabilities
+ * that the Queen Agent uses for strategic decision making.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUEEN_KNOWLEDGE_BASE = void 0;
+exports.determineOptimalApproach = determineOptimalApproach;
+exports.QUEEN_KNOWLEDGE_BASE = {
+    /**
+     * ServiceNow Development Patterns
+     */
+    developmentPatterns: {
+        widgetDevelopment: {
+            description: 'Service Portal Widget Development',
+            approaches: [
+                {
+                    name: 'Local Sync Development',
+                    description: 'Pull widget to local files, edit with Claude Code, push back',
+                    optimal_for: ['complex widgets', 'multi-file editing', 'refactoring', 'bulk changes'],
+                    workflow: [
+                        'snow_pull_artifact({ sys_id, table: "sp_widget" })',
+                        'Edit with Claude Code native tools',
+                        'snow_validate_artifact_coherence({ sys_id })',
+                        'snow_push_artifact({ sys_id })'
+                    ],
+                    advantages: [
+                        'Full IDE capabilities',
+                        'Multi-file search and replace',
+                        'Git integration possible',
+                        'Offline development',
+                        'Advanced refactoring'
+                    ]
+                },
+                {
+                    name: 'Direct Deployment',
+                    description: 'Deploy widget directly to ServiceNow',
+                    optimal_for: ['new widgets', 'simple widgets', 'quick prototypes'],
+                    workflow: [
+                        'snow_deploy({ type: "widget", config: {...} })'
+                    ],
+                    advantages: [
+                        'Fast deployment',
+                        'No local files needed',
+                        'Immediate availability'
+                    ]
+                },
+                {
+                    name: 'Direct Update',
+                    description: 'Update existing widget fields directly',
+                    optimal_for: ['small changes', 'field updates', 'quick fixes'],
+                    workflow: [
+                        'snow_update({ type: "widget", identifier, config: {...} })'
+                    ],
+                    advantages: [
+                        'Minimal overhead',
+                        'Targeted updates',
+                        'Fast iteration'
+                    ]
+                }
+            ]
+        },
+        scriptDevelopment: {
+            description: 'Script Include and Business Rule Development',
+            approaches: [
+                {
+                    name: 'Local Sync Development',
+                    description: 'Pull script to local file, edit, validate ES5, push back',
+                    optimal_for: ['complex scripts', 'refactoring', 'bulk operations'],
+                    workflow: [
+                        'snow_pull_artifact({ sys_id, table: "sys_script_include" })',
+                        'Edit with full IDE support',
+                        'Validate ES5 compliance',
+                        'snow_push_artifact({ sys_id })'
+                    ],
+                    advantages: [
+                        'ES5 validation',
+                        'Syntax highlighting',
+                        'Code completion',
+                        'Search across scripts'
+                    ]
+                }
+            ]
+        },
+        flowDevelopment: {
+            description: 'Flow Designer Development',
+            approaches: [
+                {
+                    name: 'Local Sync for Analysis',
+                    description: 'Pull flow definition for analysis and documentation',
+                    optimal_for: ['flow analysis', 'documentation', 'debugging'],
+                    workflow: [
+                        'snow_pull_artifact({ sys_id, table: "sys_hub_flow" })',
+                        'Analyze JSON structure',
+                        'Document flow logic'
+                    ],
+                    limitations: [
+                        'Flow creation must be done in ServiceNow UI',
+                        'Cannot programmatically create flows'
+                    ]
+                }
+            ]
+        }
+    },
+    /**
+     * Tool Selection Criteria
+     */
+    toolSelectionCriteria: {
+        useLocalSync: {
+            when: [
+                'User requests editing existing artifact',
+                'Complex multi-file changes needed',
+                'Refactoring required',
+                'Bulk search/replace operations',
+                'User wants to use Claude Code native tools',
+                'Need offline development capability'
+            ],
+            artifacts: [
+                'sp_widget',
+                'sys_script_include',
+                'sys_script',
+                'sys_ui_page',
+                'sys_script_client',
+                'sys_ui_policy',
+                'sysauto_script',
+                'sys_script_fix'
+            ]
+        },
+        useDirectDeployment: {
+            when: [
+                'Creating new artifact from scratch',
+                'Simple artifact with minimal complexity',
+                'Quick prototype needed',
+                'No existing artifact to modify'
+            ]
+        },
+        useDirectUpdate: {
+            when: [
+                'Small targeted changes',
+                'Single field update',
+                'Quick fix needed',
+                'No complex editing required'
+            ]
+        }
+    },
+    /**
+     * Artifact Type Capabilities
+     */
+    artifactCapabilities: {
+        sp_widget: {
+            localSync: true,
+            directDeploy: true,
+            directUpdate: true,
+            coherenceValidation: true,
+            es5Required: ['script'],
+            fields: ['template', 'script', 'client_script', 'css', 'option_schema']
+        },
+        sys_script_include: {
+            localSync: true,
+            directDeploy: true,
+            directUpdate: true,
+            es5Required: ['script'],
+            fields: ['script', 'api_name', 'description']
+        },
+        sys_script: {
+            localSync: true,
+            directDeploy: true,
+            directUpdate: true,
+            es5Required: ['script'],
+            fields: ['script', 'condition', 'collection', 'when']
+        },
+        sys_hub_flow: {
+            localSync: true,
+            directDeploy: false, // Cannot create flows programmatically
+            directUpdate: false,
+            fields: ['definition', 'description']
+        },
+        sys_ui_page: {
+            localSync: true,
+            directDeploy: true,
+            directUpdate: true,
+            es5Required: ['processing_script'],
+            fields: ['html', 'client_script', 'processing_script']
+        }
+    },
+    /**
+     * Strategic Recommendations
+     */
+    strategicRecommendations: {
+        complexWidgetEdit: {
+            pattern: 'Local Sync Development',
+            reasoning: 'Complex widgets benefit from full IDE capabilities and multi-file editing',
+            steps: [
+                'Pull widget to local files',
+                'Use Claude Code search/replace across template, scripts, CSS',
+                'Validate coherence between components',
+                'Push back when complete'
+            ]
+        },
+        bulkRefactoring: {
+            pattern: 'Local Sync Development',
+            reasoning: 'Refactoring requires searching and replacing across multiple files',
+            steps: [
+                'Pull all related artifacts',
+                'Use regex search/replace',
+                'Validate changes',
+                'Push all artifacts back'
+            ]
+        },
+        quickPrototype: {
+            pattern: 'Direct Deployment',
+            reasoning: 'Prototypes need speed over complex editing capabilities',
+            steps: [
+                'Generate basic structure',
+                'Deploy directly to ServiceNow',
+                'Iterate quickly with direct updates'
+            ]
+        }
+    },
+    /**
+     * Common Pitfalls to Avoid
+     */
+    pitfallsToAvoid: [
+        {
+            pitfall: 'Using modern JavaScript in ServiceNow',
+            solution: 'Always validate ES5 compliance for server-side scripts'
+        },
+        {
+            pitfall: 'Breaking widget coherence',
+            solution: 'Run coherence validation before pushing widget changes'
+        },
+        {
+            pitfall: 'Not fetching latest version before editing',
+            solution: 'Always pull latest artifact if user mentions they modified it'
+        },
+        {
+            pitfall: 'Trying to create flows programmatically',
+            solution: 'Direct users to ServiceNow Flow Designer UI for flow creation'
+        }
+    ],
+    /**
+     * MCP Server Mapping
+     */
+    mcpServerMapping: {
+        'snow_pull_artifact': 'servicenow-local-development',
+        'snow_push_artifact': 'servicenow-local-development',
+        'snow_validate_artifact_coherence': 'servicenow-local-development',
+        'snow_list_supported_artifacts': 'servicenow-local-development',
+        'snow_sync_status': 'servicenow-local-development',
+        'snow_sync_cleanup': 'servicenow-local-development',
+        'snow_convert_to_es5': 'servicenow-local-development',
+        'snow_deploy': 'servicenow-deployment',
+        'snow_update': 'servicenow-deployment',
+        'snow_query_table': 'servicenow-operations',
+        'snow_create_script_include': 'servicenow-platform-development'
+    }
+};
+/**
+ * Helper function for Queen to determine optimal approach
+ */
+function determineOptimalApproach(objective, artifactType, context) {
+    // If user mentioned modifications, always sync first
+    if (context.userMentionedModifications && context.hasExistingArtifact) {
+        return 'Local Sync Development';
+    }
+    // For complex operations or refactoring
+    if (context.requiresRefactoring || context.complexity === 'high') {
+        return 'Local Sync Development';
+    }
+    // For new artifacts
+    if (!context.hasExistingArtifact) {
+        return context.complexity === 'low' ? 'Direct Deployment' : 'Local Sync Development';
+    }
+    // For simple updates
+    if (context.complexity === 'low' && context.hasExistingArtifact) {
+        return 'Direct Update';
+    }
+    // Default to local sync for safety
+    return 'Local Sync Development';
+}
+//# sourceMappingURL=queen-knowledge-base.js.map

package/dist/queen/servicenow-queen.d.ts

@@ -87,6 +87,8 @@ export declare class ServiceNowQueen {
     /**
      * Extract the core business problem from user request
      */
+    private getTableForType;
+    private extractSysIdFromObjective;
     private extractCoreProblem;
     /**
      * Assess objective complexity

package/dist/queen/servicenow-queen.js

@@ -42,6 +42,7 @@ const queen_memory_1 = require("./queen-memory");
 const neural_learning_1 = require("./neural-learning");
 const agent_factory_1 = require("./agent-factory");
 const mcp_execution_bridge_1 = require("./mcp-execution-bridge");
+const queen_knowledge_base_1 = require("./queen-knowledge-base");
 const theme_manager_1 = require("../utils/theme-manager");
 const dependency_detector_1 = require("../utils/dependency-detector");
 // Gap Analysis Engine removed - using direct MCP approach
@@ -311,6 +312,46 @@ class ServiceNowQueen {
         }
     }
     createDeploymentPlan(task, agentResults, _analysis) {
+        // Determine optimal approach based on knowledge base
+        const hasExistingArtifact = task.objective.toLowerCase().includes('update') ||
+            task.objective.toLowerCase().includes('edit') ||
+            task.objective.toLowerCase().includes('modify') ||
+            task.objective.toLowerCase().includes('change');
+        const requiresRefactoring = task.objective.toLowerCase().includes('refactor') ||
+            task.objective.toLowerCase().includes('rename') ||
+            task.objective.toLowerCase().includes('reorganize');
+        const userMentionedModifications = task.objective.toLowerCase().includes('i modified') ||
+            task.objective.toLowerCase().includes('i changed') ||
+            task.objective.toLowerCase().includes('i updated') ||
+            task.objective.toLowerCase().includes('aangepast') ||
+            task.objective.toLowerCase().includes('zelf');
+        const approach = (0, queen_knowledge_base_1.determineOptimalApproach)(task.objective, task.type, {
+            hasExistingArtifact,
+            complexity: _analysis.estimatedComplexity > 7 ? 'high' :
+                _analysis.estimatedComplexity > 4 ? 'medium' : 'low',
+            requiresRefactoring,
+            userMentionedModifications
+        });
+        if (this.config.debugMode) {
+            this.logger.info(`🎨 Optimal approach: ${approach}`);
+            this.logger.info(`🔍 Artifact sync available: ${queen_knowledge_base_1.QUEEN_KNOWLEDGE_BASE.artifactCapabilities[this.getTableForType(task.type)]?.localSync}`);
+        }
+        // If local sync is optimal and available
+        if (approach === 'Local Sync Development' && hasExistingArtifact) {
+            const table = this.getTableForType(task.type);
+            if (queen_knowledge_base_1.QUEEN_KNOWLEDGE_BASE.artifactCapabilities[table]?.localSync) {
+                return {
+                    type: 'local-sync',
+                    approach: approach,
+                    mcpTool: 'snow_pull_artifact',
+                    workflow: queen_knowledge_base_1.QUEEN_KNOWLEDGE_BASE.developmentPatterns.widgetDevelopment.approaches[0].workflow,
+                    config: {
+                        table: table,
+                        sys_id: this.extractSysIdFromObjective(task.objective)
+                    }
+                };
+            }
+        }
         // Extract deployment instructions from agent results
         const widgetCreator = agentResults.find(r => r.agentType === 'widget-creator');
         const flowBuilder = agentResults.find(r => r.agentType === 'flow-builder');
@@ -609,6 +650,36 @@ function($scope) {
 })();`;
     }
     async executeDeploymentPlan(plan) {
+        // Handle local sync workflow for artifact editing
+        if (plan.type === 'local-sync') {
+            if (this.config.debugMode) {
+                this.logger.info('🔄 Executing Local Sync Development workflow');
+                this.logger.info('📁 Artifact will be synced to local files for editing');
+            }
+            // Create recommendation for local sync
+            const recommendation = {
+                agentId: 'queen-agent',
+                agentType: 'queen',
+                action: 'local-sync',
+                tool: 'snow_pull_artifact',
+                server: 'servicenow-local-development',
+                params: plan.config,
+                reasoning: 'Syncing artifact to local files for advanced editing with Claude Code',
+                confidence: 0.95
+            };
+            // Execute pull through MCP bridge
+            const result = await this.mcpBridge.executeAgentRecommendation({ id: 'queen-agent', type: 'queen' }, recommendation);
+            if (result.success) {
+                return {
+                    success: true,
+                    type: 'local-sync',
+                    approach: plan.approach,
+                    message: 'Artifact synced to local files. Edit with Claude Code, then use snow_push_artifact to sync back.',
+                    localPath: result.toolResult?.localPath,
+                    files: result.toolResult?.files
+                };
+            }
+        }
         // Execute real MCP tools through the bridge
         if (this.config.debugMode) {
             this.logger.info('🚀 Executing deployment plan with MCP Bridge');
@@ -942,6 +1013,26 @@ function($scope) {
     /**
      * Extract the core business problem from user request
      */
+    getTableForType(type) {
+        const typeToTable = {
+            'widget': 'sp_widget',
+            'flow': 'sys_hub_flow',
+            'script': 'sys_script_include',
+            'business_rule': 'sys_script',
+            'ui_page': 'sys_ui_page',
+            'client_script': 'sys_script_client',
+            'ui_policy': 'sys_ui_policy',
+            'scheduled_job': 'sysauto_script',
+            'fix_script': 'sys_script_fix'
+        };
+        return typeToTable[type] || 'sys_metadata';
+    }
+    extractSysIdFromObjective(objective) {
+        // Look for sys_id patterns in the objective
+        const sysIdPattern = /[a-f0-9]{32}/i;
+        const match = objective.match(sysIdPattern);
+        return match ? match[0] : undefined;
+    }
     extractCoreProblem(objective) {
         const objective_lower = objective.toLowerCase();
         // Analyze patterns to understand underlying need

package/dist/utils/artifact-local-sync.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Artifact Local Sync System
+ *
+ * Creates temporary local files from ServiceNow artifacts so Claude Code
+ * can use its native tools (search, edit, multi-file operations, etc.)
+ * Then syncs changes back to ServiceNow.
+ *
+ * THIS IS THE BRIDGE BETWEEN SERVICENOW AND CLAUDE CODE!
+ */
+import { ServiceNowClient } from './servicenow-client';
+import { ArtifactTypeConfig, FieldMapping, ValidationResult } from './artifact-sync/artifact-registry';
+export interface LocalArtifact {
+    sys_id: string;
+    name: string;
+    type: string;
+    tableName: string;
+    localPath: string;
+    files: LocalFile[];
+    metadata: any;
+    syncStatus: 'synced' | 'modified' | 'pending_upload';
+    createdAt: Date;
+    lastSyncedAt: Date;
+    artifactConfig?: ArtifactTypeConfig;
+}
+export interface LocalFile {
+    filename: string;
+    path: string;
+    field: string;
+    type: string;
+    originalContent: string;
+    currentContent?: string;
+    isModified: boolean;
+    fieldMapping?: FieldMapping;
+}
+export declare class ArtifactLocalSync {
+    private baseDir;
+    private artifacts;
+    private client;
+    private smartFetcher;
+    constructor(client: ServiceNowClient);
+    /**
+     * DYNAMIC pull artifact from ServiceNow using artifact registry
+     * Works with ANY artifact type defined in the registry!
+     */
+    pullArtifact(tableName: string, sys_id: string): Promise<LocalArtifact>;
+    /**
+     * Pull a widget from ServiceNow and create local files
+     * This is the magic that lets Claude Code use its native tools!
+     * (Wrapper for backward compatibility)
+     */
+    pullWidget(sys_id: string): Promise<LocalArtifact>;
+    /**
+     * DYNAMIC push local changes back to ServiceNow using artifact registry
+     */
+    pushArtifact(sys_id: string): Promise<boolean>;
+    /**
+     * Push local changes back to ServiceNow
+     * (Wrapper for backward compatibility)
+     */
+    pushWidget(sys_id: string): Promise<boolean>;
+    /**
+     * Clean up local files after successful sync
+     */
+    cleanup(sys_id: string, force?: boolean): Promise<void>;
+    /**
+     * Create a local file with appropriate headers
+     */
+    private createLocalFile;
+    /**
+     * Generate README with artifact-specific context using registry
+     */
+    private generateArtifactReadme;
+    /**
+     * Replace placeholders in wrapper strings
+     */
+    private replacePlaceholders;
+    /**
+     * Generate README with widget context
+     * (Wrapper for backward compatibility)
+     */
+    private generateWidgetReadme;
+    /**
+     * Validate ES5 compliance
+     */
+    private validateES5;
+    /**
+     * Strip headers/footers we added - now uses field mapping for accuracy
+     */
+    private stripAddedWrappers;
+    /**
+     * Sanitize filename for filesystem
+     */
+    private sanitizeFilename;
+    /**
+     * List all local artifacts
+     */
+    listLocalArtifacts(): LocalArtifact[];
+    /**
+     * Get sync status for an artifact
+     */
+    getSyncStatus(sys_id: string): string;
+    /**
+     * Pull any supported artifact type by detecting table from sys_id
+     */
+    pullArtifactBySysId(sys_id: string): Promise<LocalArtifact>;
+    /**
+     * Get supported artifact types
+     */
+    getSupportedTypes(): string[];
+    /**
+     * Validate coherence for an artifact
+     */
+    validateArtifactCoherence(sys_id: string): Promise<ValidationResult[]>;
+}
+//# sourceMappingURL=artifact-local-sync.d.ts.map