snow-flow 3.0.8 → 3.0.10

package/dist/agents/widget-builder.agent.d.ts

@@ -1,32 +0,0 @@
-/**
- * Widget Builder Agent for Service Portal Widgets
- */
-import { BaseServiceNowAgent } from '../core/base-agent.js';
-import { AgentTask, AgentResult, ServiceNowConfig } from '../types/servicenow.types.js';
-export declare class WidgetBuilderAgent extends BaseServiceNowAgent {
-    constructor(config: ServiceNowConfig);
-    execute(task: AgentTask): Promise<AgentResult>;
-    private createWidget;
-    private updateWidget;
-    private generateTemplate;
-    private createWidgetFromSpec;
-    private generateWidgetId;
-    private generateDefaultTemplate;
-    private generateDefaultCSS;
-    private generateServerScript;
-    private generateClientScript;
-    private generateDataTableTemplate;
-    private generateFormTemplate;
-    private generateChartTemplate;
-    private generateCustomTemplate;
-    private generateTemplateFromSpec;
-    private generateComponentTemplate;
-    private generateCSSFromSpec;
-    private generateServerScriptFromSpec;
-    private generateDataSourceCode;
-    private generateClientScriptFromSpec;
-    private generateOptionsFromSpec;
-    private generateWidgetFileCommands;
-    private toCamelCase;
-}
-//# sourceMappingURL=widget-builder.agent.d.ts.map

package/dist/agents/widget-builder.agent.js

@@ -1,439 +0,0 @@
-"use strict";
-/**
- * Widget Builder Agent for Service Portal Widgets
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WidgetBuilderAgent = void 0;
-const base_agent_js_1 = require("../core/base-agent.js");
-class WidgetBuilderAgent extends base_agent_js_1.BaseServiceNowAgent {
-    constructor(config) {
-        super('widget-builder', servicenow_types_js_1.AgentType.WIDGET_BUILDER, [
-            'create_widget',
-            'update_widget',
-            'generate_angular_template',
-            'create_widget_options',
-            'validate_widget_code',
-            'create_widget_dependencies'
-        ], config);
-    }
-    async execute(task) {
-        this.logger.info(`Executing task: ${task.description}`);
-        try {
-            switch (task.type) {
-                case 'create_widget':
-                    return await this.createWidget(task);
-                case 'update_widget':
-                    return await this.updateWidget(task);
-                case 'generate_template':
-                    return await this.generateTemplate(task);
-                case 'widget_from_spec':
-                    return await this.createWidgetFromSpec(task);
-                default:
-                    throw new Error(`Unknown task type: ${task.type}`);
-            }
-        }
-        catch (error) {
-            this.logger.error(`Task execution failed: ${error.message}`);
-            return {
-                taskId: task.id,
-                success: false,
-                error: error.message
-            };
-        }
-    }
-    async createWidget(task) {
-        const { name, description, template, options } = task.payload;
-        // Generate widget structure
-        const widget = {
-            id: this.generateWidgetId(name),
-            name,
-            template: template || this.generateDefaultTemplate(name),
-            css: this.generateDefaultCSS(),
-            serverScript: this.generateServerScript(options),
-            clientScript: this.generateClientScript(name),
-            options: options || []
-        };
-        // Generate orchestration commands
-        const commands = [
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/widgets/${widget.id}/template.html`,
-                content: widget.template
-            }, `Create widget template for ${name}`),
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/widgets/${widget.id}/client.js`,
-                content: widget.clientScript
-            }, `Create client script for ${name}`),
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/widgets/${widget.id}/server.js`,
-                content: widget.serverScript
-            }, `Create server script for ${name}`),
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/widgets/${widget.id}/styles.css`,
-                content: widget.css
-            }, `Create CSS for ${name}`)
-        ];
-        // Store widget in memory for coordination
-        await this.storeInMemory(`widgets:${widget.id}`, widget);
-        return {
-            taskId: task.id,
-            success: true,
-            output: widget,
-            artifacts: [
-                this.createArtifact('service_portal_widget', widget.name, widget)
-            ],
-            commands
-        };
-    }
-    async updateWidget(task) {
-        const { widgetId, updates } = task.payload;
-        // Retrieve existing widget from memory
-        const existingWidget = await this.retrieveFromMemory(`widgets:${widgetId}`);
-        if (!existingWidget) {
-            throw new Error(`Widget ${widgetId} not found`);
-        }
-        // Apply updates
-        const updatedWidget = { ...existingWidget, ...updates };
-        // Store updated widget
-        await this.storeInMemory(`widgets:${widgetId}`, updatedWidget);
-        return {
-            taskId: task.id,
-            success: true,
-            output: updatedWidget,
-            artifacts: [
-                this.createArtifact('service_portal_widget', updatedWidget.name, updatedWidget)
-            ]
-        };
-    }
-    async generateTemplate(task) {
-        const { componentType, bindings, layout } = task.payload;
-        let template = '';
-        switch (componentType) {
-            case 'data-table':
-                template = this.generateDataTableTemplate(bindings);
-                break;
-            case 'form':
-                template = this.generateFormTemplate(bindings);
-                break;
-            case 'chart':
-                template = this.generateChartTemplate(bindings);
-                break;
-            case 'custom':
-                template = this.generateCustomTemplate(layout, bindings);
-                break;
-            default:
-                template = this.generateDefaultTemplate('Generated Widget');
-        }
-        return {
-            taskId: task.id,
-            success: true,
-            output: { template },
-            artifacts: [
-                this.createArtifact('template', 'generated-template.html', template)
-            ]
-        };
-    }
-    async createWidgetFromSpec(task) {
-        const spec = task.payload;
-        // Parse specification and create widget components
-        const widget = {
-            id: this.generateWidgetId(spec.name),
-            name: spec.name,
-            template: this.generateTemplateFromSpec(spec),
-            css: this.generateCSSFromSpec(spec),
-            serverScript: this.generateServerScriptFromSpec(spec),
-            clientScript: this.generateClientScriptFromSpec(spec),
-            options: this.generateOptionsFromSpec(spec),
-            dependencies: spec.dependencies || []
-        };
-        // Generate comprehensive widget package
-        const commands = [
-            // Main widget files
-            ...this.generateWidgetFileCommands(widget),
-            // Configuration file
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/widgets/${widget.id}/config.json`,
-                content: JSON.stringify({
-                    id: widget.id,
-                    name: widget.name,
-                    version: '1.0.0',
-                    dependencies: widget.dependencies,
-                    options: widget.options
-                }, null, 2)
-            }, `Create widget configuration`)
-        ];
-        return {
-            taskId: task.id,
-            success: true,
-            output: widget,
-            artifacts: [
-                this.createArtifact('service_portal_widget', widget.name, widget, {
-                    spec: spec
-                })
-            ],
-            commands
-        };
-    }
-    // Helper methods
-    generateWidgetId(name) {
-        return name.toLowerCase().replace(/\s+/g, '_').replace(/[^a-z0-9_]/g, '');
-    }
-    generateDefaultTemplate(name) {
-        return `<div class="widget-container">
-  <div class="widget-header">
-    <h2>${name}</h2>
-  </div>
-  <div class="widget-body">
-    <p>Welcome to ${name} widget</p>
-    <div ng-repeat="item in c.data.items">
-      {{item.display_value}}
-    </div>
-  </div>
-</div>`;
-    }
-    generateDefaultCSS() {
-        return `.widget-container {
-  padding: 20px;
-  background: #fff;
-  border-radius: 4px;
-  box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-}
-
-.widget-header {
-  margin-bottom: 20px;
-  padding-bottom: 10px;
-  border-bottom: 1px solid #e0e0e0;
-}
-
-.widget-header h2 {
-  margin: 0;
-  color: #333;
-}
-
-.widget-body {
-  color: #666;
-}`;
-    }
-    generateServerScript(options) {
-        const optionHandling = options ?
-            options.map(opt => `\n  var ${opt.name} = options.${opt.name} || ${JSON.stringify(opt.default_value)};`).join('')
-            : '';
-        return `(function() {
-  /* Widget server script */${optionHandling}
-  
-  // Initialize data object
-  data.items = [];
-  
-  // Example: Fetch data from a table
-  var gr = new GlideRecord('incident');
-  gr.addQuery('active', true);
-  gr.setLimit(10);
-  gr.query();
-  
-  while (gr.next()) {
-    data.items.push({
-      sys_id: gr.getUniqueValue(),
-      display_value: gr.getDisplayValue()
-    });
-  }
-})();`;
-    }
-    generateClientScript(name) {
-        return `function ${this.toCamelCase(name)}Controller() {
-  var c = this;
-  
-  // Initialize controller
-  c.$onInit = function() {
-    console.log('${name} widget initialized');
-    c.loadData();
-  };
-  
-  // Load widget data
-  c.loadData = function() {
-    c.server.get().then(function(response) {
-      c.data = response.data;
-    });
-  };
-  
-  // Handle user interactions
-  c.onClick = function(item) {
-    console.log('Clicked:', item);
-  };
-}`;
-    }
-    generateDataTableTemplate(bindings) {
-        return `<div class="data-table-widget">
-  <div class="table-header">
-    <h3>{{c.data.title || 'Data Table'}}</h3>
-  </div>
-  <table class="table table-striped">
-    <thead>
-      <tr>
-        <th ng-repeat="column in c.data.columns">{{column.label}}</th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr ng-repeat="row in c.data.rows">
-        <td ng-repeat="column in c.data.columns">
-          {{row[column.field]}}
-        </td>
-      </tr>
-    </tbody>
-  </table>
-</div>`;
-    }
-    generateFormTemplate(bindings) {
-        return `<form class="form-widget" ng-submit="c.submit()">
-  <div class="form-group" ng-repeat="field in c.data.fields">
-    <label>{{field.label}}</label>
-    <input 
-      ng-if="field.type === 'text'" 
-      type="text" 
-      class="form-control" 
-      ng-model="c.formData[field.name]"
-      ng-required="field.required">
-    <select 
-      ng-if="field.type === 'choice'" 
-      class="form-control" 
-      ng-model="c.formData[field.name]"
-      ng-required="field.required">
-      <option ng-repeat="choice in field.choices" value="{{choice.value}}">
-        {{choice.label}}
-      </option>
-    </select>
-  </div>
-  <button type="submit" class="btn btn-primary">Submit</button>
-</form>`;
-    }
-    generateChartTemplate(bindings) {
-        return `<div class="chart-widget">
-  <h3>{{c.data.title}}</h3>
-  <canvas id="chart-{{c.data.chartId}}"></canvas>
-  <script>
-    // Chart initialization will be handled in client script
-  </script>
-</div>`;
-    }
-    generateCustomTemplate(layout, bindings) {
-        // Generate custom template based on layout specification
-        return `<div class="custom-widget">
-  <!-- Custom widget implementation -->
-  <div ng-bind-html="c.data.content"></div>
-</div>`;
-    }
-    generateTemplateFromSpec(spec) {
-        // Generate template based on specification
-        if (spec.template) {
-            return spec.template;
-        }
-        // Build template from components
-        let template = '<div class="' + (spec.containerClass || 'widget-container') + '">\n';
-        if (spec.components) {
-            spec.components.forEach((component) => {
-                template += this.generateComponentTemplate(component) + '\n';
-            });
-        }
-        template += '</div>';
-        return template;
-    }
-    generateComponentTemplate(component) {
-        switch (component.type) {
-            case 'header':
-                return `  <div class="widget-header"><h3>{{c.data.${component.binding || 'title'}}}</h3></div>`;
-            case 'list':
-                return `  <ul class="widget-list">
-    <li ng-repeat="item in c.data.${component.binding || 'items'}">{{item.display_value}}</li>
-  </ul>`;
-            case 'button':
-                return `  <button class="btn btn-${component.style || 'default'}" ng-click="c.${component.action}()">{{${component.label}}}</button>`;
-            default:
-                return `  <div>${component.content || ''}</div>`;
-        }
-    }
-    generateCSSFromSpec(spec) {
-        if (spec.css) {
-            return spec.css;
-        }
-        // Generate default CSS based on spec
-        return this.generateDefaultCSS();
-    }
-    generateServerScriptFromSpec(spec) {
-        if (spec.serverScript) {
-            return spec.serverScript;
-        }
-        let script = '(function() {\n';
-        // Handle data sources
-        if (spec.dataSources) {
-            spec.dataSources.forEach((source) => {
-                script += this.generateDataSourceCode(source) + '\n';
-            });
-        }
-        script += '})();';
-        return script;
-    }
-    generateDataSourceCode(source) {
-        return `  // Fetch data from ${source.table}
-  var gr = new GlideRecord('${source.table}');
-  ${source.query ? `gr.addEncodedQuery('${source.query}');` : ''}
-  ${source.limit ? `gr.setLimit(${source.limit});` : ''}
-  gr.query();
-  
-  data.${source.name || 'items'} = [];
-  while (gr.next()) {
-    data.${source.name || 'items'}.push({
-      sys_id: gr.getUniqueValue(),
-      display_value: gr.getDisplayValue()
-    });
-  }`;
-    }
-    generateClientScriptFromSpec(spec) {
-        if (spec.clientScript) {
-            return spec.clientScript;
-        }
-        const controllerName = this.toCamelCase(spec.name) + 'Controller';
-        return this.generateClientScript(spec.name);
-    }
-    generateOptionsFromSpec(spec) {
-        if (!spec.options) {
-            return [];
-        }
-        return spec.options.map((opt) => ({
-            name: opt.name,
-            label: opt.label || opt.name,
-            type: opt.type || 'string',
-            default_value: opt.default,
-            choices: opt.choices
-        }));
-    }
-    generateWidgetFileCommands(widget) {
-        const baseDir = `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/widgets/${widget.id}`;
-        return [
-            this.generateCommand('Bash', 'create', {
-                command: `mkdir -p ${baseDir}`,
-                description: `Create widget directory for ${widget.name}`
-            }, 'Create widget directory'),
-            this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/template.html`,
-                content: widget.template
-            }, 'Create widget template'),
-            this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/client.js`,
-                content: widget.clientScript
-            }, 'Create client script'),
-            this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/server.js`,
-                content: widget.serverScript
-            }, 'Create server script'),
-            this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/styles.css`,
-                content: widget.css
-            }, 'Create widget styles')
-        ];
-    }
-    toCamelCase(str) {
-        return str.replace(/(?:^\w|[A-Z]|\b\w)/g, (word, index) => {
-            return index === 0 ? word.toLowerCase() : word.toUpperCase();
-        }).replace(/\s+/g, '');
-    }
-}
-exports.WidgetBuilderAgent = WidgetBuilderAgent;
-//# sourceMappingURL=widget-builder.agent.js.map

package/dist/agents/widget-creator-agent.d.ts

@@ -1,18 +0,0 @@
-/**
- * Widget Creator Agent
- * Specializes in creating ServiceNow Service Portal widgets
- */
-import { BaseAgent, AgentConfig, AgentResult } from './base-agent';
-export declare class WidgetCreatorAgent extends BaseAgent {
-    constructor(config?: Partial<AgentConfig>);
-    execute(instruction: string, context?: Record<string, any>): Promise<AgentResult>;
-    private analyzeWidgetRequirements;
-    private checkExistingWidgets;
-    private createHTMLTemplate;
-    private createCSS;
-    private createClientScript;
-    private createServerScript;
-    private generateDemoData;
-    private prepareDeploymentInstructions;
-}
-//# sourceMappingURL=widget-creator-agent.d.ts.map