snow-flow 3.5.7 → 3.5.9

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

@@ -37,7 +37,7 @@ export declare class ArtifactLocalSync {
     private artifacts;
     private client;
     private smartFetcher;
-    constructor(client: ServiceNowClient);
+    constructor(client: ServiceNowClient, customBaseDir?: string);
     /**
      * DYNAMIC pull artifact from ServiceNow using artifact registry
      * Works with ANY artifact type defined in the registry!

package/dist/utils/artifact-local-sync.js

@@ -45,20 +45,71 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArtifactLocalSync = void 0;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
 const smart_field_fetcher_js_1 = require("./smart-field-fetcher.js");
 const artifact_registry_1 = require("./artifact-sync/artifact-registry");
 class ArtifactLocalSync {
-    constructor(client) {
+    constructor(client, customBaseDir) {
         this.artifacts = new Map();
         this.client = client;
         this.smartFetcher = new smart_field_fetcher_js_1.SmartFieldFetcher(client);
-        // Create base directory for Snow-Flow artifacts
-        this.baseDir = path.join(os.tmpdir(), 'snow-flow-artifacts');
+        // Use custom directory, environment variable, or default to current project's servicenow folder
+        if (customBaseDir) {
+            this.baseDir = customBaseDir;
+        }
+        else if (process.env.SNOW_FLOW_ARTIFACTS_DIR) {
+            this.baseDir = process.env.SNOW_FLOW_ARTIFACTS_DIR;
+        }
+        else {
+            // Default to 'servicenow' folder in current working directory
+            this.baseDir = path.join(process.cwd(), 'servicenow');
+        }
+        // Create base directory if it doesn't exist
         if (!fs.existsSync(this.baseDir)) {
             fs.mkdirSync(this.baseDir, { recursive: true });
+            console.log(`📁 Created ServiceNow artifacts directory: ${this.baseDir}`);
+        }
+        else {
+            console.log(`📁 Using ServiceNow artifacts directory: ${this.baseDir}`);
+        }
+        // Create .gitignore if it doesn't exist to optionally exclude from version control
+        const gitignorePath = path.join(this.baseDir, '.gitignore');
+        if (!fs.existsSync(gitignorePath)) {
+            fs.writeFileSync(gitignorePath, '# ServiceNow Artifacts\n' +
+                '# Uncomment the following lines to exclude from version control:\n' +
+                '# *\n' +
+                '# !.gitignore\n' +
+                '# !README.md\n');
+        }
+        // Create README if it doesn't exist
+        const readmePath = path.join(this.baseDir, 'README.md');
+        if (!fs.existsSync(readmePath)) {
+            fs.writeFileSync(readmePath, '# ServiceNow Artifacts Directory\n\n' +
+                'This directory contains ServiceNow artifacts synchronized from your instance for local development.\n\n' +
+                '## Structure\n\n' +
+                '```\n' +
+                'servicenow/\n' +
+                '├── widgets/          # Service Portal widgets\n' +
+                '├── script_includes/  # Script Includes\n' +
+                '├── business_rules/   # Business Rules\n' +
+                '├── flows/           # Flow Designer flows\n' +
+                '├── ui_pages/        # UI Pages\n' +
+                '└── ...              # Other artifact types\n' +
+                '```\n\n' +
+                '## Workflow\n\n' +
+                '1. **Pull artifacts**: `snow_pull_artifact` downloads artifacts here\n' +
+                '2. **Edit locally**: Use your IDE/editor to modify files\n' +
+                '3. **Push changes**: `snow_push_artifact` syncs changes back to ServiceNow\n' +
+                '4. **Clean up**: `snow_sync_cleanup` removes local files after sync\n\n' +
+                '## Version Control\n\n' +
+                'You can choose to:\n' +
+                '- **Track changes**: Keep artifacts in git for version history\n' +
+                '- **Ignore artifacts**: Edit `.gitignore` to exclude from git\n\n' +
+                '## Configuration\n\n' +
+                'Set custom location with environment variable:\n' +
+                '```bash\n' +
+                'export SNOW_FLOW_ARTIFACTS_DIR=/path/to/artifacts\n' +
+                '```\n');
         }
-        console.log(`📁 Snow-Flow local sync directory: ${this.baseDir}`);
     }
     /**
      * DYNAMIC pull artifact from ServiceNow using artifact registry
@@ -143,8 +194,11 @@ class ArtifactLocalSync {
             artifactConfig: config
         };
         this.artifacts.set(sys_id, artifact);
+        // Show relative path if in project directory
+        const relativePath = path.relative(process.cwd(), artifactPath);
+        const displayPath = relativePath.startsWith('..') ? artifactPath : relativePath;
         console.log(`✅ ${config.displayName} synced to local files:`);
-        console.log(`📁 Location: ${artifactPath}`);
+        console.log(`📁 Location: ${displayPath}`);
         console.log(`📄 Files created:`);
         files.forEach(f => console.log(`   - ${f.filename} (${f.type})`));
         console.log(`\n💡 Claude Code can now use its native tools on these files!`);
@@ -158,77 +212,6 @@ class ArtifactLocalSync {
      */
     async pullWidget(sys_id) {
         return this.pullArtifact('sp_widget', sys_id);
-        console.log(`\n🔄 Pulling widget ${sys_id} to local files...`);
-        // Fetch widget with smart chunking
-        const widget = await this.smartFetcher.fetchWidget(sys_id);
-        // Create local directory structure
-        const widgetName = this.sanitizeFilename(widget.name || `widget_${sys_id}`);
-        const widgetPath = path.join(this.baseDir, 'widgets', widgetName);
-        // Clean up any existing files
-        if (fs.existsSync(widgetPath)) {
-            fs.rmSync(widgetPath, { recursive: true });
-        }
-        fs.mkdirSync(widgetPath, { recursive: true });
-        // Create local files for each widget component
-        const files = [];
-        // 1. HTML Template
-        if (widget.template) {
-            const htmlFile = this.createLocalFile(widgetPath, `${widgetName}.html`, widget.template, 'template', 'html', '<!-- ServiceNow Widget Template -->\n<!-- Widget: ' + widget.name + ' -->\n<!-- Bindings: {{data.x}} from server, ng-click calls client methods -->\n\n');
-            files.push(htmlFile);
-        }
-        // 2. Server Script (ES5)
-        if (widget.script) {
-            const serverFile = this.createLocalFile(widgetPath, `${widgetName}.server.js`, widget.script, 'script', 'js', '/**\n * ServiceNow Widget Server Script (ES5 ONLY!)\n * Widget: ' + widget.name + '\n * \n * Available objects:\n * - data: Object to send to client\n * - input: Data from client\n * - options: Widget instance options\n * - gs: GlideSystem\n * - $sp: Service Portal API\n */\n\n(function() {\n', '\n})();');
-            files.push(serverFile);
-        }
-        // 3. Client Script (AngularJS)
-        if (widget.client_script) {
-            const clientFile = this.createLocalFile(widgetPath, `${widgetName}.client.js`, widget.client_script, 'client_script', 'js', '/**\n * ServiceNow Widget Client Controller (AngularJS)\n * Widget: ' + widget.name + '\n * \n * Available objects:\n * - c: Widget controller (this)\n * - c.data: Data from server\n * - c.server: Server communication\n * - $scope: Angular scope\n */\n\nfunction(');
-            files.push(clientFile);
-        }
-        // 4. CSS
-        if (widget.css) {
-            const cssFile = this.createLocalFile(widgetPath, `${widgetName}.css`, widget.css, 'css', 'css', '/* ServiceNow Widget Styles */\n/* Widget: ' + widget.name + ' */\n/* Prefix classes to avoid conflicts */\n\n');
-            files.push(cssFile);
-        }
-        // 5. Widget Configuration (JSON)
-        const config = {
-            sys_id: widget.sys_id,
-            name: widget.name,
-            title: widget.title,
-            option_schema: widget.option_schema,
-            data_table: widget.data_table,
-            roles: widget.roles,
-            public: widget.public,
-            _coherence_hints: widget._coherence_hints || []
-        };
-        const configFile = this.createLocalFile(widgetPath, `${widgetName}.config.json`, JSON.stringify(config, null, 2), 'metadata', 'json');
-        files.push(configFile);
-        // 6. README with context
-        const readmeContent = this.generateWidgetReadme(widget, files);
-        const readmeFile = this.createLocalFile(widgetPath, 'README.md', readmeContent, 'documentation', 'md');
-        files.push(readmeFile);
-        // Create artifact record
-        const artifact = {
-            sys_id: widget.sys_id,
-            name: widget.name,
-            type: 'widget',
-            tableName: 'sp_widget', // Added missing tableName
-            localPath: widgetPath,
-            files: files,
-            metadata: widget,
-            syncStatus: 'synced',
-            createdAt: new Date(),
-            lastSyncedAt: new Date()
-        };
-        this.artifacts.set(sys_id, artifact);
-        console.log(`✅ Widget synced to local files:`);
-        console.log(`📁 Location: ${widgetPath}`);
-        console.log(`📄 Files created:`);
-        files.forEach(f => console.log(`   - ${f.filename} (${f.type})`));
-        console.log(`\n💡 Claude Code can now use its native tools on these files!`);
-        console.log(`   Edit, search, refactor - then run 'pushWidget' to sync back.`);
-        return artifact;
     }
     /**
      * DYNAMIC push local changes back to ServiceNow using artifact registry
@@ -336,60 +319,6 @@ class ArtifactLocalSync {
      */
     async pushWidget(sys_id) {
         return this.pushArtifact(sys_id);
-        const artifact = this.artifacts.get(sys_id);
-        if (!artifact) {
-            throw new Error(`No local artifact found for ${sys_id}. Run pullWidget first.`);
-        }
-        console.log(`\n🔄 Pushing local changes back to ServiceNow...`);
-        // Read current content from all files
-        const updates = {};
-        let hasChanges = false;
-        for (const file of artifact.files) {
-            if (fs.existsSync(file.path)) {
-                const currentContent = fs.readFileSync(file.path, 'utf8');
-                // Strip our added headers/footers for comparison
-                const cleanContent = this.stripAddedWrappers(currentContent, file.type);
-                if (cleanContent !== file.originalContent) {
-                    hasChanges = true;
-                    file.currentContent = cleanContent;
-                    file.isModified = true;
-                    // Map back to ServiceNow field
-                    if (file.field && file.field !== 'documentation' && file.field !== 'metadata') {
-                        updates[file.field] = cleanContent;
-                        console.log(`   📝 Changed: ${file.filename} (${file.field})`);
-                    }
-                }
-            }
-        }
-        if (!hasChanges) {
-            console.log(`✅ No changes detected. Widget is up to date.`);
-            return true;
-        }
-        // Validate ES5 compliance for server script
-        if (updates.script) {
-            const es5Issues = this.validateES5(updates.script);
-            if (es5Issues.length > 0) {
-                console.log(`\n⚠️ ES5 Validation Issues in server script:`);
-                es5Issues.forEach(issue => console.log(`   - ${issue}`));
-                console.log(`\n❓ Continue with deployment anyway? (ServiceNow might fail)`);
-                // In real implementation, prompt for confirmation
-            }
-        }
-        // Update in ServiceNow
-        try {
-            console.log(`\n📤 Updating widget in ServiceNow...`);
-            await this.client.updateRecord('sp_widget', sys_id, updates);
-            artifact.syncStatus = 'synced';
-            artifact.lastSyncedAt = new Date();
-            console.log(`✅ Widget successfully updated in ServiceNow!`);
-            console.log(`🔗 sys_id: ${sys_id}`);
-            return true;
-        }
-        catch (error) {
-            console.error(`❌ Failed to update widget:`, error);
-            artifact.syncStatus = 'pending_upload';
-            return false;
-        }
     }
     /**
      * Clean up local files after successful sync

package/dist/utils/servicenow-client-with-tracking.d.ts

@@ -10,6 +10,10 @@ export declare class ServiceNowClientWithTracking extends ServiceNowClient {
      * Override makeRequest to add tracking
      */
     makeRequest(config: any): Promise<any>;
+    /**
+     * Override searchRecordsWithFields to add tracking
+     */
+    searchRecordsWithFields(table: string, query: string, fields: string[], limit?: number): Promise<any>;
     /**
      * Override searchRecords to add tracking
      */

package/dist/utils/servicenow-client-with-tracking.js

@@ -36,6 +36,27 @@ class ServiceNowClientWithTracking extends servicenow_client_js_1.ServiceNowClie
             throw error;
         }
     }
+    /**
+     * Override searchRecordsWithFields to add tracking
+     */
+    async searchRecordsWithFields(table, query, fields, limit = 10) {
+        this.mcpLogger.progress(`Searching ${table} with specific fields: ${fields.join(', ')}`);
+        try {
+            const result = await super.searchRecordsWithFields(table, query, fields, limit);
+            // Estimate tokens based on fields requested
+            const fieldCount = fields.length;
+            const estimatedTokens = Math.min(fieldCount * 100, 1000); // Rough estimate
+            this.mcpLogger.trackTokens(estimatedTokens, 0);
+            if (result?.data?.result?.length > 0) {
+                this.mcpLogger.info(`Found ${result.data.result.length} records with ${fieldCount} fields`);
+            }
+            return result;
+        }
+        catch (error) {
+            this.mcpLogger.error('Search with fields failed', error);
+            throw error;
+        }
+    }
     /**
      * Override searchRecords to add tracking
      */

package/dist/utils/servicenow-client.d.ts

@@ -156,6 +156,10 @@ export declare class ServiceNowClient {
      * Get multiple records from a table
      */
     getRecords(table: string, params?: any): Promise<ServiceNowAPIResponse<any[]>>;
+    /**
+     * Search records with specific fields
+     */
+    searchRecordsWithFields(table: string, query: string, fields: string[], limit?: number): Promise<ServiceNowAPIResponse<any>>;
     /**
      * Search records in a table using encoded query
      */

package/dist/utils/servicenow-client.js

@@ -1039,6 +1039,33 @@ class ServiceNowClient {
             };
         }
     }
+    /**
+     * Search records with specific fields
+     */
+    async searchRecordsWithFields(table, query, fields, limit = 10) {
+        try {
+            await this.ensureAuthenticated();
+            const url = `/api/now/table/${table}`;
+            const params = {
+                sysparm_query: query,
+                sysparm_limit: limit.toString(),
+                sysparm_fields: fields.join(',')
+            };
+            const response = await this.client.get(url, { params });
+            return {
+                success: true,
+                data: response.data
+            };
+        }
+        catch (error) {
+            console.error('API Error:', error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                data: null
+            };
+        }
+    }
     /**
      * Search records in a table using encoded query
      */

package/dist/utils/smart-field-fetcher.js

@@ -152,34 +152,103 @@ class SmartFieldFetcher {
      * (Wrapper for backward compatibility)
      */
     async fetchWidget(sys_id) {
-        return this.fetchArtifact('sp_widget', sys_id);
         console.log(`\n🔍 Smart fetching widget: ${sys_id}`);
         const results = {
             _fetch_strategy: 'smart_chunked',
             _context_hint: 'Widget fields fetched separately but are interconnected: template references {{data.x}} from server script, calls methods from client script, and uses CSS classes',
             _field_groups: {}
         };
-        // Fetch each field group
-        for (const group of WIDGET_FIELD_GROUPS) {
-            console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
-            try {
-                const response = await this.client.getRecord('sp_widget', sys_id);
-                if (response) {
+        // Try to fetch all fields first, then fall back to individual fields if too large
+        console.log(`📦 Attempting to fetch complete widget data...`);
+        try {
+            // Try to get all fields at once
+            const response = await this.client.searchRecords('sp_widget', `sys_id=${sys_id}`, 1);
+            if (response && response.result && response.result.length > 0) {
+                const widgetData = response.result[0];
+                console.log(`✅ Successfully fetched complete widget`);
+                // Organize into field groups for better context
+                for (const group of WIDGET_FIELD_GROUPS) {
+                    const groupData = {};
+                    for (const fieldName of group.fields) {
+                        if (widgetData[fieldName] !== undefined) {
+                            groupData[fieldName] = widgetData[fieldName];
+                        }
+                    }
                     results._field_groups[group.groupName] = {
-                        data: response,
+                        data: groupData,
                         description: group.description,
                         fields: group.fields
                     };
-                    // Add to flat structure for easy access
-                    Object.assign(results, response.result[0]);
                 }
+                // Add complete widget data to flat structure
+                Object.assign(results, widgetData);
             }
-            catch (error) {
-                console.log(`⚠️ Failed to fetch ${group.groupName}: ${error.message}`);
-                // If group fails due to size, fetch fields individually
-                if (error.message?.includes('exceeds maximum allowed tokens')) {
-                    results._field_groups[group.groupName] = await this.fetchFieldsIndividually('sp_widget', sys_id, group.fields, group.description);
+            else {
+                throw new Error('Widget not found');
+            }
+        }
+        catch (error) {
+            console.log(`⚠️ Complete fetch failed: ${error.message}`);
+            console.log(`🔄 Switching to field-by-field fetching...`);
+            // Fall back to fetching fields per group or individually
+            for (const group of WIDGET_FIELD_GROUPS) {
+                console.log(`📦 Fetching ${group.groupName}: ${group.description}`);
+                try {
+                    // Try to fetch all fields in this group at once
+                    const groupResponse = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, group.fields, 1);
+                    if (groupResponse && groupResponse.success && groupResponse.data && groupResponse.data.result && groupResponse.data.result.length > 0) {
+                        const groupData = groupResponse.data.result[0];
+                        console.log(`  ✅ Successfully fetched ${group.groupName}`);
+                        results._field_groups[group.groupName] = {
+                            data: groupData,
+                            description: group.description,
+                            fields: group.fields
+                        };
+                        // Add to flat structure
+                        Object.assign(results, groupData);
+                    }
+                    else {
+                        throw new Error('No data returned for group');
+                    }
                 }
+                catch (groupError) {
+                    console.log(`  ⚠️ Group ${group.groupName} failed, fetching fields individually...`);
+                    // If group fails, fetch fields one by one
+                    const groupData = {};
+                    for (const fieldName of group.fields) {
+                        console.log(`    📄 Fetching field: ${fieldName}`);
+                        try {
+                            // Fetch just this single field
+                            const fieldResponse = await this.client.searchRecordsWithFields('sp_widget', `sys_id=${sys_id}`, [fieldName], 1);
+                            if (fieldResponse && fieldResponse.success && fieldResponse.data && fieldResponse.data.result && fieldResponse.data.result.length > 0) {
+                                const fieldValue = fieldResponse.data.result[0][fieldName];
+                                if (fieldValue !== undefined && fieldValue !== null) {
+                                    groupData[fieldName] = fieldValue;
+                                    results[fieldName] = fieldValue; // Also add to flat structure
+                                    console.log(`      ✅ Got ${fieldName} (${typeof fieldValue === 'string' ? fieldValue.length : 0} chars)`);
+                                }
+                                else {
+                                    groupData[fieldName] = '';
+                                    console.log(`      ⚠️ ${fieldName} is empty`);
+                                }
+                            }
+                        }
+                        catch (fieldError) {
+                            console.log(`      ❌ Failed to fetch ${fieldName}: ${fieldError.message}`);
+                            groupData[fieldName] = ''; // Empty string for failed fields
+                        }
+                    }
+                    results._field_groups[group.groupName] = {
+                        data: groupData,
+                        description: group.description,
+                        fields: group.fields,
+                        _fetched_individually: true
+                    };
+                }
+            }
+            // Make sure we have at least the sys_id
+            if (!results.sys_id) {
+                results.sys_id = sys_id;
             }
         }
         // Add coherence validation hints

package/package.json

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