snow-flow 3.0.9 → 3.0.10

package/dist/agents/app-creator.agent.js

@@ -1,1292 +0,0 @@
-"use strict";
-/**
- * App Creator Agent for Scoped Applications
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppCreatorAgent = void 0;
-const base_agent_js_1 = require("../core/base-agent.js");
-class AppCreatorAgent extends base_agent_js_1.BaseServiceNowAgent {
-    constructor(config) {
-        super('app-creator', servicenow_types_js_1.AgentType.APP_CREATOR, [
-            'create_application',
-            'add_tables',
-            'create_menus',
-            'generate_app_structure',
-            'create_security_rules',
-            'package_application',
-            'generate_app_documentation'
-        ], config);
-    }
-    async execute(task) {
-        this.logger.info(`Executing app creation task: ${task.description}`);
-        try {
-            switch (task.type) {
-                case 'create_application':
-                    return await this.createApplication(task);
-                case 'generate_from_requirements':
-                    return await this.generateFromRequirements(task);
-                case 'add_app_components':
-                    return await this.addAppComponents(task);
-                case 'package_application':
-                    return await this.packageApplication(task);
-                default:
-                    throw new Error(`Unknown task type: ${task.type}`);
-            }
-        }
-        catch (error) {
-            this.logger.error(`App creation task failed: ${error.message}`);
-            return {
-                taskId: task.id,
-                success: false,
-                error: error.message
-            };
-        }
-    }
-    async createApplication(task) {
-        const { name, scope, vendor, description, initialTables } = task.payload;
-        const app = {
-            name,
-            scope: scope || this.generateScope(name),
-            version: '1.0.0',
-            vendor: vendor || 'Custom',
-            vendorPrefix: this.generateVendorPrefix(vendor || 'Custom'),
-            shortDescription: description || `${name} Application`,
-            description: description || `Scoped application: ${name}`,
-            tables: initialTables || [],
-            menus: []
-        };
-        // Generate application structure
-        const appStructure = this.generateApplicationStructure(app);
-        // Generate orchestration commands
-        const commands = [
-            // Create base directory structure
-            this.generateCommand('Bash', 'create', {
-                command: `mkdir -p /Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}/{sys_app,tables,menus,security,scripts,ui,docs}`,
-                description: `Create application directory structure for ${name}`
-            }, 'Create directories'),
-            // Application manifest
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}/sys_app/manifest.json`,
-                content: JSON.stringify(appStructure.manifest, null, 2)
-            }, 'Create application manifest'),
-            // Application properties
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}/sys_app/properties.json`,
-                content: JSON.stringify(appStructure.properties, null, 2)
-            }, 'Create application properties'),
-            // README
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}/README.md`,
-                content: this.generateApplicationReadme(app)
-            }, 'Create application README')
-        ];
-        // Store in memory for coordination
-        await this.storeInMemory(`applications:${app.scope}`, app);
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                application: app,
-                structure: appStructure
-            },
-            artifacts: [
-                this.createArtifact('scoped_application', app.name, app, {
-                    scope: app.scope,
-                    version: app.version
-                })
-            ],
-            commands
-        };
-    }
-    async generateFromRequirements(task) {
-        const { requirements, appType, businessDomain } = task.payload;
-        // Analyze requirements to determine app structure
-        const analysis = this.analyzeAppRequirements(requirements, appType, businessDomain);
-        // Generate application based on analysis
-        const app = {
-            name: analysis.suggestedName,
-            scope: this.generateScope(analysis.suggestedName),
-            version: '1.0.0',
-            vendor: 'Auto-Generated',
-            vendorPrefix: 'x',
-            shortDescription: analysis.description,
-            description: `Application generated from requirements: ${requirements.substring(0, 200)}...`,
-            tables: this.generateTablesFromAnalysis(analysis),
-            menus: this.generateMenusFromAnalysis(analysis)
-        };
-        // Generate complete application package
-        const appPackage = await this.generateCompleteApplication(app, analysis);
-        // Generate comprehensive commands for all app components
-        const commands = this.generateApplicationCommands(app, appPackage);
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                application: app,
-                package: appPackage,
-                analysis
-            },
-            artifacts: [
-                this.createArtifact('scoped_application', app.name, app),
-                ...appPackage.artifacts
-            ],
-            commands
-        };
-    }
-    async addAppComponents(task) {
-        const { appScope, components } = task.payload;
-        // Retrieve existing application
-        const app = await this.retrieveFromMemory(`applications:${appScope}`);
-        if (!app) {
-            throw new Error(`Application ${appScope} not found`);
-        }
-        const addedComponents = {
-            tables: [],
-            menus: [],
-            scripts: [],
-            ui: []
-        };
-        // Add tables
-        if (components.tables) {
-            components.tables.forEach((table) => {
-                const appTable = this.createApplicationTable(table, app.scope);
-                app.tables.push(appTable);
-                addedComponents.tables.push(appTable);
-            });
-        }
-        // Add menus
-        if (components.menus) {
-            components.menus.forEach((menu) => {
-                const appMenu = this.createApplicationMenu(menu, app.scope);
-                app.menus.push(appMenu);
-                addedComponents.menus.push(appMenu);
-            });
-        }
-        // Update stored application
-        await this.storeInMemory(`applications:${appScope}`, app);
-        // Generate commands for new components
-        const commands = this.generateComponentCommands(app.scope, addedComponents);
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                application: app,
-                addedComponents
-            },
-            artifacts: [
-                ...addedComponents.tables.map((table) => this.createArtifact('application_table', table.name, table)),
-                ...addedComponents.menus.map((menu) => this.createArtifact('application_menu', menu.name, menu))
-            ],
-            commands
-        };
-    }
-    async packageApplication(task) {
-        const { appScope, includeData, format } = task.payload;
-        const app = await this.retrieveFromMemory(`applications:${appScope}`);
-        if (!app) {
-            throw new Error(`Application ${appScope} not found`);
-        }
-        // Generate application package
-        const appPackage = {
-            manifest: this.generateManifest(app),
-            metadata: this.generateMetadata(app),
-            components: {
-                tables: app.tables,
-                menus: app.menus,
-                security: this.generateSecurityRules(app),
-                scripts: this.generateApplicationScripts(app),
-                ui: this.generateApplicationUI(app)
-            },
-            data: includeData ? this.generateSampleData(app) : null
-        };
-        // Generate export based on format
-        let exportContent;
-        let fileName;
-        switch (format) {
-            case 'xml':
-                exportContent = this.generateXMLExport(appPackage);
-                fileName = `${app.scope}.xml`;
-                break;
-            case 'json':
-                exportContent = JSON.stringify(appPackage, null, 2);
-                fileName = `${app.scope}.json`;
-                break;
-            default:
-                exportContent = this.generateUpdateSetXML(appPackage);
-                fileName = `${app.scope}_update_set.xml`;
-        }
-        const commands = [
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}/export/${fileName}`,
-                content: exportContent
-            }, `Export application package as ${format}`),
-            this.generateCommand('Write', 'create', {
-                file_path: `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}/export/install-guide.md`,
-                content: this.generateInstallationGuide(app)
-            }, 'Create installation guide')
-        ];
-        return {
-            taskId: task.id,
-            success: true,
-            output: {
-                package: appPackage,
-                exportFile: fileName
-            },
-            artifacts: [
-                this.createArtifact('application_package', fileName, exportContent),
-                this.createArtifact('documentation', 'install-guide.md', this.generateInstallationGuide(app))
-            ],
-            commands
-        };
-    }
-    // Helper methods
-    generateScope(name) {
-        return 'x_' + name.toLowerCase()
-            .replace(/[^a-z0-9]/g, '_')
-            .replace(/_+/g, '_')
-            .substring(0, 18);
-    }
-    generateVendorPrefix(vendor) {
-        return vendor.toLowerCase()
-            .split(/\s+/)
-            .map(word => word.charAt(0))
-            .join('')
-            .substring(0, 3) || 'x';
-    }
-    generateApplicationStructure(app) {
-        return {
-            manifest: {
-                name: app.name,
-                scope: app.scope,
-                version: app.version,
-                vendor: app.vendor,
-                vendor_prefix: app.vendorPrefix,
-                created: new Date().toISOString(),
-                dependencies: [],
-                components: {
-                    tables: app.tables.length,
-                    menus: app.menus.length
-                }
-            },
-            properties: {
-                js_level: 'helsinki',
-                logo: '',
-                private: false,
-                offline_mobile: false,
-                active: true,
-                enforce_license: 'none',
-                short_description: app.shortDescription,
-                description: app.description
-            }
-        };
-    }
-    generateApplicationReadme(app) {
-        return `# ${app.name}
-
-## Overview
-${app.description}
-
-## Scope
-- **Application Scope**: ${app.scope}
-- **Version**: ${app.version}
-- **Vendor**: ${app.vendor}
-- **Vendor Prefix**: ${app.vendorPrefix}
-
-## Components
-
-### Tables
-${app.tables.map(table => `- **${table.label}** (${table.name})
-  - Extends: ${table.extends}
-  - Fields: ${table.fields.length}`).join('\n')}
-
-### Menus
-${app.menus.map(menu => `- **${menu.label}**
-  - Modules: ${menu.modules.length}`).join('\n')}
-
-## Installation
-1. Import the application package into your ServiceNow instance
-2. Navigate to System Applications > Applications
-3. Find "${app.name}" and click Install
-4. Follow the installation wizard
-
-## Configuration
-After installation:
-1. Configure security rules as needed
-2. Set up any required integrations
-3. Customize UI as desired
-
-## Usage
-${this.generateUsageInstructions(app)}
-
-## Support
-For issues or questions, contact the application vendor.
-
-Generated on: ${new Date().toISOString()}
-Generated by: ServiceNow Multi-Agent Framework
-`;
-    }
-    generateUsageInstructions(app) {
-        let instructions = '';
-        if (app.tables.length > 0) {
-            instructions += '\n### Working with Tables\n';
-            app.tables.forEach(table => {
-                instructions += `\n**${table.label}**:\n`;
-                instructions += `- Navigate to ${app.name} > ${table.label}\n`;
-                instructions += `- Use the New button to create records\n`;
-                instructions += `- Click on existing records to view/edit\n`;
-            });
-        }
-        if (app.menus.length > 0) {
-            instructions += '\n### Navigation\n';
-            app.menus.forEach(menu => {
-                instructions += `\n**${menu.label}** menu contains:\n`;
-                menu.modules.forEach(module => {
-                    instructions += `- ${module.label}: ${module.table ? `View ${module.table} records` : 'Custom module'}\n`;
-                });
-            });
-        }
-        return instructions || 'See application menus for available features.';
-    }
-    analyzeAppRequirements(requirements, appType, businessDomain) {
-        const analysis = {
-            suggestedName: '',
-            description: '',
-            tables: [],
-            features: [],
-            workflows: [],
-            integrations: []
-        };
-        // Extract app name suggestion
-        const words = requirements.split(/\s+/).slice(0, 3);
-        analysis.suggestedName = words.join(' ') + ' App';
-        // Detect required tables
-        if (requirements.toLowerCase().includes('track') || requirements.toLowerCase().includes('manage')) {
-            analysis.tables.push({
-                purpose: 'main',
-                suggestedName: 'Main Records',
-                fields: ['name', 'description', 'status', 'assigned_to']
-            });
-        }
-        if (requirements.toLowerCase().includes('approve') || requirements.toLowerCase().includes('approval')) {
-            analysis.tables.push({
-                purpose: 'approval',
-                suggestedName: 'Approvals',
-                fields: ['request', 'approver', 'status', 'comments']
-            });
-            analysis.features.push('approval_workflow');
-        }
-        if (requirements.toLowerCase().includes('report') || requirements.toLowerCase().includes('dashboard')) {
-            analysis.features.push('reporting');
-            analysis.features.push('dashboard');
-        }
-        // Detect workflows
-        if (requirements.toLowerCase().includes('workflow') || requirements.toLowerCase().includes('process')) {
-            analysis.workflows.push('main_process');
-        }
-        // Detect integrations
-        if (requirements.toLowerCase().includes('integrate') || requirements.toLowerCase().includes('api')) {
-            analysis.integrations.push('rest_api');
-        }
-        // Set description
-        analysis.description = `${businessDomain || 'Business'} application for ${requirements.substring(0, 100)}...`;
-        return analysis;
-    }
-    generateTablesFromAnalysis(analysis) {
-        const tables = [];
-        analysis.tables.forEach((tableSpec, index) => {
-            const table = {
-                name: `u_${tableSpec.suggestedName.toLowerCase().replace(/\s+/g, '_')}`,
-                label: tableSpec.suggestedName,
-                parent: tableSpec.purpose === 'approval' ? 'sysapproval_approver' : 'task',
-                fields: this.generateFieldsFromSpec(tableSpec.fields)
-            };
-            tables.push(table);
-        });
-        // Add default table if none specified
-        if (tables.length === 0) {
-            tables.push({
-                name: 'u_main_table',
-                label: 'Main Table',
-                parent: 'task',
-                fields: this.generateDefaultFields()
-            });
-        }
-        return tables;
-    }
-    generateFieldsFromSpec(fieldNames) {
-        const fields = [];
-        fieldNames.forEach(fieldName => {
-            fields.push(this.createFieldFromName(fieldName));
-        });
-        return fields;
-    }
-    createFieldFromName(fieldName) {
-        const field = {
-            name: `u_${fieldName.toLowerCase().replace(/\s+/g, '_')}`,
-            label: fieldName.charAt(0).toUpperCase() + fieldName.slice(1).replace(/_/g, ' '),
-            type: 'string',
-            max_length: 255
-        };
-        // Detect field types
-        if (fieldName.includes('date') || fieldName.includes('time')) {
-            field.type = 'glide_date_time';
-            delete field.max_length;
-        }
-        else if (fieldName.includes('user') || fieldName.includes('assigned')) {
-            field.type = 'reference';
-            field.reference = 'sys_user';
-            delete field.max_length;
-        }
-        else if (fieldName.includes('group')) {
-            field.type = 'reference';
-            field.reference = 'sys_user_group';
-            delete field.max_length;
-        }
-        else if (fieldName.includes('status') || fieldName.includes('state')) {
-            field.type = 'choice';
-            delete field.max_length;
-        }
-        else if (fieldName.includes('description') || fieldName.includes('comments')) {
-            field.type = 'string';
-            field.max_length = 4000;
-        }
-        else if (fieldName.includes('amount') || fieldName.includes('cost') || fieldName.includes('price')) {
-            field.type = 'currency';
-            delete field.max_length;
-        }
-        return field;
-    }
-    generateDefaultFields() {
-        return [
-            {
-                name: 'u_description',
-                label: 'Description',
-                type: 'string',
-                max_length: 4000
-            },
-            {
-                name: 'u_status',
-                label: 'Status',
-                type: 'choice'
-            },
-            {
-                name: 'u_priority',
-                label: 'Priority',
-                type: 'integer',
-                default_value: 3
-            },
-            {
-                name: 'u_assigned_user',
-                label: 'Assigned User',
-                type: 'reference',
-                reference: 'sys_user'
-            }
-        ];
-    }
-    generateMenusFromAnalysis(analysis) {
-        const menus = [];
-        // Main application menu
-        const mainMenu = {
-            name: 'main_menu',
-            label: analysis.suggestedName,
-            application: 'custom',
-            modules: []
-        };
-        // Add modules for each table
-        analysis.tables.forEach((tableSpec, index) => {
-            const tableName = `u_${tableSpec.suggestedName.toLowerCase().replace(/\s+/g, '_')}`;
-            mainMenu.modules.push({
-                name: `${tableName}_list`,
-                label: `All ${tableSpec.suggestedName}`,
-                table: tableName,
-                order: (index + 1) * 100
-            });
-            mainMenu.modules.push({
-                name: `${tableName}_new`,
-                label: `Create New`,
-                table: tableName,
-                view: 'new',
-                order: (index + 1) * 100 + 10
-            });
-        });
-        // Add reporting module if needed
-        if (analysis.features.includes('reporting')) {
-            mainMenu.modules.push({
-                name: 'reports',
-                label: 'Reports',
-                table: 'sys_report',
-                filter: `table=u_main_table`,
-                order: 900
-            });
-        }
-        // Add dashboard module if needed
-        if (analysis.features.includes('dashboard')) {
-            mainMenu.modules.push({
-                name: 'dashboard',
-                label: 'Dashboard',
-                table: 'pa_dashboards',
-                order: 50
-            });
-        }
-        menus.push(mainMenu);
-        return menus;
-    }
-    async generateCompleteApplication(app, analysis) {
-        const appPackage = {
-            tables: {},
-            menus: {},
-            security: {},
-            scripts: {},
-            ui: {},
-            workflows: {},
-            artifacts: []
-        };
-        // Generate table definitions
-        app.tables.forEach(table => {
-            appPackage.tables[table.name] = {
-                definition: table,
-                dictionary: this.generateTableDictionary(table),
-                acls: this.generateTableACLs(table, app.scope)
-            };
-            appPackage.artifacts.push(this.createArtifact('table_definition', table.name, appPackage.tables[table.name]));
-        });
-        // Generate menu definitions
-        app.menus.forEach(menu => {
-            appPackage.menus[menu.name] = {
-                definition: menu,
-                modules: menu.modules
-            };
-            appPackage.artifacts.push(this.createArtifact('menu_definition', menu.name, appPackage.menus[menu.name]));
-        });
-        // Generate security rules
-        appPackage.security = this.generateSecurityRules(app);
-        // Generate application scripts
-        appPackage.scripts = this.generateApplicationScripts(app);
-        // Generate UI components
-        appPackage.ui = this.generateApplicationUI(app);
-        // Generate workflows if needed
-        if (analysis.workflows.length > 0) {
-            appPackage.workflows = this.generateApplicationWorkflows(app, analysis);
-        }
-        return appPackage;
-    }
-    generateTableDictionary(table) {
-        return table.fields.map(field => ({
-            element: field.name,
-            column_label: field.label,
-            type: field.type,
-            max_length: field.max_length,
-            reference: field.reference,
-            mandatory: field.mandatory || false,
-            default_value: field.default_value,
-            attributes: this.getFieldAttributes(field)
-        }));
-    }
-    getFieldAttributes(field) {
-        const attributes = [];
-        if (field.type === 'reference') {
-            attributes.push(`ref_auto_completer=AJAXTableCompleter`);
-            attributes.push(`ref_ac_columns=${field.reference}.name`);
-        }
-        if (field.type === 'choice') {
-            attributes.push('edge_encryption_enabled=false');
-        }
-        return attributes.join(',');
-    }
-    generateTableACLs(table, scope) {
-        const operations = ['create', 'read', 'write', 'delete'];
-        const acls = [];
-        operations.forEach(operation => {
-            acls.push({
-                name: `${table.name}.${operation}`,
-                operation,
-                admin_overrides: true,
-                active: true,
-                condition: '',
-                description: `${operation} access to ${table.label}`,
-                script: '',
-                type: 'record'
-            });
-        });
-        return acls;
-    }
-    generateSecurityRules(app) {
-        return {
-            roles: [
-                {
-                    name: `${app.scope}.user`,
-                    description: `User role for ${app.name}`,
-                    assignable_by: 'admin'
-                },
-                {
-                    name: `${app.scope}.admin`,
-                    description: `Admin role for ${app.name}`,
-                    assignable_by: 'admin',
-                    contains_roles: [`${app.scope}.user`]
-                }
-            ],
-            acls: app.tables.map(table => ({
-                table: table.name,
-                rules: this.generateTableACLs(table, app.scope)
-            }))
-        };
-    }
-    generateApplicationScripts(app) {
-        const scripts = {
-            script_includes: [],
-            business_rules: [],
-            client_scripts: []
-        };
-        // Generate utility script include
-        scripts.script_includes.push({
-            name: `${app.vendorPrefix}_${app.scope}_Utils`,
-            api_name: `${app.vendorPrefix}_${app.scope}_Utils`,
-            description: `Utility functions for ${app.name}`,
-            script: this.generateUtilityScriptInclude(app),
-            access: 'public'
-        });
-        // Generate business rules for main tables
-        app.tables.forEach(table => {
-            if (table.fields.some(f => f.name.includes('number'))) {
-                scripts.business_rules.push({
-                    name: `Generate ${table.label} Number`,
-                    table: table.name,
-                    when: 'before',
-                    insert: true,
-                    script: this.generateNumberingBusinessRule(table),
-                    order: 100
-                });
-            }
-        });
-        return scripts;
-    }
-    generateUtilityScriptInclude(app) {
-        return `var ${app.vendorPrefix}_${app.scope}_Utils = Class.create();
-${app.vendorPrefix}_${app.scope}_Utils.prototype = {
-    initialize: function() {
-    },
-
-    /**
-     * Get application properties
-     */
-    getAppProperties: function() {
-        return {
-            scope: '${app.scope}',
-            version: '${app.version}',
-            name: '${app.name}'
-        };
-    },
-
-    /**
-     * Log application message
-     */
-    log: function(message, source) {
-        gs.info('[${app.name}] ' + (source || 'General') + ': ' + message);
-    },
-
-    /**
-     * Check user role
-     */
-    hasRole: function(role) {
-        return gs.hasRole(role) || gs.hasRole('${app.scope}.admin') || gs.hasRole('admin');
-    },
-
-    type: '${app.vendorPrefix}_${app.scope}_Utils'
-};`;
-    }
-    generateNumberingBusinessRule(table) {
-        return `(function executeRule(current, previous /*null when async*/) {
-    // Generate unique number for ${table.label}
-    if (!current.number) {
-        var prefix = '${table.label.substring(0, 3).toUpperCase()}';
-        var gr = new GlideRecord('${table.name}');
-        gr.orderByDesc('sys_created_on');
-        gr.setLimit(1);
-        gr.query();
-        
-        var lastNumber = 1000;
-        if (gr.next() && gr.number) {
-            var num = parseInt(gr.number.replace(/[^0-9]/g, ''));
-            if (!isNaN(num)) {
-                lastNumber = num;
-            }
-        }
-        
-        current.number = prefix + String(lastNumber + 1).padStart(7, '0');
-    }
-})(current, previous);`;
-    }
-    generateApplicationUI(app) {
-        return {
-            ui_pages: [],
-            ui_macros: [],
-            widgets: [
-                {
-                    name: `${app.scope}_dashboard`,
-                    title: `${app.name} Dashboard`,
-                    template: this.generateDashboardWidget(app),
-                    css: this.generateDashboardCSS(),
-                    server_script: this.generateDashboardServerScript(app),
-                    client_script: this.generateDashboardClientScript()
-                }
-            ]
-        };
-    }
-    generateDashboardWidget(app) {
-        return `<div class="app-dashboard">
-  <div class="dashboard-header">
-    <h2>${app.name} Dashboard</h2>
-  </div>
-  
-  <div class="dashboard-stats">
-    ${app.tables.map(table => `
-    <div class="stat-card">
-      <h3>${table.label}</h3>
-      <div class="stat-value">{{data.${table.name}_count || 0}}</div>
-      <a href="?id=${table.name}_list" class="stat-link">View All</a>
-    </div>
-    `).join('')}
-  </div>
-  
-  <div class="dashboard-charts">
-    <div class="chart-container">
-      <canvas id="main-chart"></canvas>
-    </div>
-  </div>
-</div>`;
-    }
-    generateDashboardCSS() {
-        return `.app-dashboard {
-    padding: 20px;
-}
-
-.dashboard-header {
-    margin-bottom: 30px;
-}
-
-.dashboard-stats {
-    display: grid;
-    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
-    gap: 20px;
-    margin-bottom: 30px;
-}
-
-.stat-card {
-    background: #fff;
-    padding: 20px;
-    border-radius: 8px;
-    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-    text-align: center;
-}
-
-.stat-value {
-    font-size: 36px;
-    font-weight: bold;
-    color: #0078d4;
-    margin: 10px 0;
-}
-
-.stat-link {
-    color: #0078d4;
-    text-decoration: none;
-}
-
-.chart-container {
-    background: #fff;
-    padding: 20px;
-    border-radius: 8px;
-    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-}`;
-    }
-    generateDashboardServerScript(app) {
-        return `(function() {
-    data.tables = [];
-    
-    ${app.tables.map(table => `
-    // Count ${table.label} records
-    var ${table.name}_count = new GlideAggregate('${table.name}');
-    ${table.name}_count.addAggregate('COUNT');
-    ${table.name}_count.query();
-    if (${table.name}_count.next()) {
-        data.${table.name}_count = ${table.name}_count.getAggregate('COUNT');
-    }
-    `).join('\n')}
-})();`;
-    }
-    generateDashboardClientScript() {
-        return `function() {
-    var c = this;
-    
-    c.$onInit = function() {
-        initializeCharts();
-    };
-    
-    function initializeCharts() {
-        // Initialize dashboard charts
-        console.log('Dashboard initialized');
-    }
-}`;
-    }
-    generateApplicationWorkflows(app, analysis) {
-        const workflows = {};
-        if (analysis.features.includes('approval_workflow')) {
-            workflows.approval = {
-                name: `${app.scope}_approval_workflow`,
-                table: app.tables[0]?.name,
-                description: `Approval workflow for ${app.name}`,
-                stages: [
-                    {
-                        name: 'Submit for Approval',
-                        type: 'begin'
-                    },
-                    {
-                        name: 'Manager Approval',
-                        type: 'approval',
-                        approvers: 'current.opened_by.manager'
-                    },
-                    {
-                        name: 'Update Status',
-                        type: 'script',
-                        script: 'current.state = "approved"; current.update();'
-                    },
-                    {
-                        name: 'Send Notification',
-                        type: 'notification',
-                        recipients: 'current.opened_by'
-                    }
-                ]
-            };
-        }
-        return workflows;
-    }
-    generateApplicationCommands(app, appPackage) {
-        const commands = [];
-        const baseDir = `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${app.scope}`;
-        // Create directory structure
-        commands.push(this.generateCommand('Bash', 'create', {
-            command: `mkdir -p ${baseDir}/{sys_app,tables,menus,security,scripts,ui,workflows,docs,export}`,
-            description: 'Create complete application directory structure'
-        }, 'Create directories'));
-        // Generate table files
-        Object.entries(appPackage.tables).forEach(([tableName, tableData]) => {
-            commands.push(this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/tables/${tableName}.json`,
-                content: JSON.stringify(tableData, null, 2)
-            }, `Create table definition: ${tableName}`));
-        });
-        // Generate menu files
-        Object.entries(appPackage.menus).forEach(([menuName, menuData]) => {
-            commands.push(this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/menus/${menuName}.json`,
-                content: JSON.stringify(menuData, null, 2)
-            }, `Create menu definition: ${menuName}`));
-        });
-        // Generate security files
-        commands.push(this.generateCommand('Write', 'create', {
-            file_path: `${baseDir}/security/roles.json`,
-            content: JSON.stringify(appPackage.security.roles, null, 2)
-        }, 'Create security roles'), this.generateCommand('Write', 'create', {
-            file_path: `${baseDir}/security/acls.json`,
-            content: JSON.stringify(appPackage.security.acls, null, 2)
-        }, 'Create access control lists'));
-        // Generate script files
-        if (appPackage.scripts.script_includes.length > 0) {
-            appPackage.scripts.script_includes.forEach((script) => {
-                commands.push(this.generateCommand('Write', 'create', {
-                    file_path: `${baseDir}/scripts/script_includes/${script.api_name}.js`,
-                    content: script.script
-                }, `Create script include: ${script.api_name}`));
-            });
-        }
-        // Generate UI files
-        if (appPackage.ui.widgets.length > 0) {
-            appPackage.ui.widgets.forEach((widget) => {
-                commands.push(this.generateCommand('Write', 'create', {
-                    file_path: `${baseDir}/ui/widgets/${widget.name}.json`,
-                    content: JSON.stringify(widget, null, 2)
-                }, `Create widget: ${widget.name}`));
-            });
-        }
-        // Generate documentation
-        commands.push(this.generateCommand('Write', 'create', {
-            file_path: `${baseDir}/README.md`,
-            content: this.generateApplicationReadme(app)
-        }, 'Create application README'), this.generateCommand('Write', 'create', {
-            file_path: `${baseDir}/docs/developer-guide.md`,
-            content: this.generateDeveloperGuide(app)
-        }, 'Create developer guide'));
-        return commands;
-    }
-    generateComponentCommands(scope, components) {
-        const commands = [];
-        const baseDir = `/Users/nielsvanderwerf/Projects/servicenow_multiagent/output/applications/${scope}`;
-        // Generate commands for tables
-        components.tables.forEach((table) => {
-            commands.push(this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/tables/${table.name}.json`,
-                content: JSON.stringify({
-                    definition: table,
-                    dictionary: this.generateTableDictionary(table),
-                    acls: this.generateTableACLs(table, scope)
-                }, null, 2)
-            }, `Create table: ${table.name}`));
-        });
-        // Generate commands for menus
-        components.menus.forEach((menu) => {
-            commands.push(this.generateCommand('Write', 'create', {
-                file_path: `${baseDir}/menus/${menu.name}.json`,
-                content: JSON.stringify({
-                    definition: menu,
-                    modules: menu.modules
-                }, null, 2)
-            }, `Create menu: ${menu.name}`));
-        });
-        return commands;
-    }
-    createApplicationTable(tableSpec, scope) {
-        return {
-            name: tableSpec.name || `u_${tableSpec.label.toLowerCase().replace(/\s+/g, '_')}`,
-            label: tableSpec.label,
-            parent: tableSpec.extends || 'task',
-            fields: tableSpec.fields?.map((field) => this.createFieldFromSpec(field)) || this.generateDefaultFields()
-        };
-    }
-    createFieldFromSpec(fieldSpec) {
-        return {
-            name: fieldSpec.name || `u_${fieldSpec.label.toLowerCase().replace(/\s+/g, '_')}`,
-            label: fieldSpec.label,
-            type: fieldSpec.type || 'string',
-            max_length: fieldSpec.max_length,
-            reference: fieldSpec.reference,
-            mandatory: fieldSpec.mandatory || false,
-            default_value: fieldSpec.default_value
-        };
-    }
-    createApplicationMenu(menuSpec, scope) {
-        return {
-            name: menuSpec.name || 'custom_menu',
-            label: menuSpec.label,
-            application: menuSpec.application || scope,
-            modules: menuSpec.modules?.map((module, index) => ({
-                name: module.name,
-                label: module.label,
-                table: module.table,
-                view: module.view,
-                filter: module.filter,
-                order: module.order || (index + 1) * 100
-            })) || []
-        };
-    }
-    generateManifest(app) {
-        return {
-            name: app.name,
-            scope: app.scope,
-            version: app.version,
-            vendor: app.vendor,
-            vendor_prefix: app.vendorPrefix,
-            runtime_access_tracking: 'permissive',
-            install_date: new Date().toISOString(),
-            dependencies: [],
-            repository_url: ''
-        };
-    }
-    generateMetadata(app) {
-        return {
-            sys_id: this.generateSysId(),
-            sys_created_on: new Date().toISOString(),
-            sys_created_by: 'admin',
-            sys_updated_on: new Date().toISOString(),
-            sys_updated_by: 'admin',
-            sys_class_name: 'sys_app',
-            sys_scope: app.scope
-        };
-    }
-    generateSysId() {
-        // Generate a mock sys_id (32 character hex string)
-        return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join('');
-    }
-    generateSampleData(app) {
-        const sampleData = {};
-        app.tables.forEach(table => {
-            sampleData[table.name] = this.generateTableSampleData(table);
-        });
-        return sampleData;
-    }
-    generateTableSampleData(table) {
-        const samples = [];
-        for (let i = 1; i <= 5; i++) {
-            const record = {
-                number: `${table.label.substring(0, 3).toUpperCase()}000000${i}`,
-                short_description: `Sample ${table.label} ${i}`,
-                sys_created_on: new Date().toISOString(),
-                sys_created_by: 'admin'
-            };
-            // Add field values
-            table.fields.forEach(field => {
-                if (!record[field.name]) {
-                    record[field.name] = this.generateFieldSampleValue(field, i);
-                }
-            });
-            samples.push(record);
-        }
-        return samples;
-    }
-    generateFieldSampleValue(field, index) {
-        switch (field.type) {
-            case 'string':
-                return `Sample ${field.label} ${index}`;
-            case 'integer':
-                return index;
-            case 'boolean':
-                return index % 2 === 0;
-            case 'reference':
-                return ''; // Empty reference
-            case 'choice':
-                return 'option_' + index;
-            case 'glide_date_time':
-                return new Date().toISOString();
-            case 'currency':
-                return (index * 100).toFixed(2);
-            default:
-                return `Value ${index}`;
-        }
-    }
-    generateXMLExport(appPackage) {
-        let xml = '<?xml version="1.0" encoding="UTF-8"?>\n';
-        xml += '<unload unload_date="' + new Date().toISOString() + '">\n';
-        // Add application record
-        xml += '  <sys_app>\n';
-        xml += '    ' + this.objectToXML(appPackage.manifest) + '\n';
-        xml += '  </sys_app>\n';
-        // Add tables
-        Object.values(appPackage.tables).forEach((table) => {
-            xml += '  <sys_db_object>\n';
-            xml += '    ' + this.objectToXML(table.definition) + '\n';
-            xml += '  </sys_db_object>\n';
-        });
-        xml += '</unload>';
-        return xml;
-    }
-    generateUpdateSetXML(appPackage) {
-        // Simplified update set XML
-        return this.generateXMLExport(appPackage);
-    }
-    objectToXML(obj, indent = '') {
-        let xml = '';
-        Object.entries(obj).forEach(([key, value]) => {
-            if (typeof value === 'object' && !Array.isArray(value)) {
-                xml += `${indent}<${key}>\n${this.objectToXML(value, indent + '  ')}\n${indent}</${key}>`;
-            }
-            else if (Array.isArray(value)) {
-                xml += `${indent}<${key}>${JSON.stringify(value)}</${key}>`;
-            }
-            else {
-                xml += `${indent}<${key}>${value}</${key}>`;
-            }
-        });
-        return xml;
-    }
-    generateInstallationGuide(app) {
-        return `# Installation Guide - ${app.name}
-
-## Prerequisites
-- ServiceNow instance (version Madrid or later)
-- Admin access to the instance
-- Update set or application repository access
-
-## Installation Steps
-
-### Method 1: Update Set Installation
-1. Download the update set file: ${app.scope}_update_set.xml
-2. Log in to your ServiceNow instance as an administrator
-3. Navigate to **System Update Sets > Retrieved Update Sets**
-4. Click **Import Update Set from XML**
-5. Choose the downloaded file and click **Upload**
-6. Preview the update set to check for conflicts
-7. Commit the update set
-
-### Method 2: Application Repository
-1. Navigate to **System Applications > Applications**
-2. Click **New** > **Import from Source Control**
-3. Enter the repository URL (if available)
-4. Follow the import wizard
-
-### Method 3: Manual Installation
-1. Navigate to **System Applications > Studio**
-2. Create a new application with scope: ${app.scope}
-3. Import the application files from the export directory
-
-## Post-Installation Configuration
-
-### 1. Security Setup
-- Navigate to **User Administration > Roles**
-- Verify the following roles were created:
-  - ${app.scope}.user
-  - ${app.scope}.admin
-- Assign roles to appropriate users or groups
-
-### 2. Data Migration (if applicable)
-- If migrating existing data, use the Transform Maps feature
-- Map fields from legacy tables to new application tables
-
-### 3. Integration Setup
-- Configure any required integrations
-- Update REST endpoints if needed
-- Set up scheduled jobs if applicable
-
-## Verification Steps
-
-1. **Check Application Status**
-   - Navigate to **System Applications > Applications**
-   - Verify ${app.name} shows as "Installed"
-
-2. **Test Basic Functionality**
-   - Access the application menu
-   - Create a test record
-   - Verify workflows trigger correctly
-
-3. **Validate Security**
-   - Test with different user roles
-   - Verify access controls work as expected
-
-## Troubleshooting
-
-### Common Issues
-
-**Issue**: Application menu not visible
-- **Solution**: Clear browser cache and refresh, check role assignments
-
-**Issue**: Tables not accessible
-- **Solution**: Verify ACLs are active, check user roles
-
-**Issue**: Workflows not triggering
-- **Solution**: Check workflow status, verify conditions
-
-## Support
-For issues or questions:
-- Check application logs in System Logs
-- Contact your ServiceNow administrator
-- Refer to the developer guide for customization
-
-Generated on: ${new Date().toISOString()}
-`;
-    }
-    generateDeveloperGuide(app) {
-        return `# Developer Guide - ${app.name}
-
-## Application Overview
-- **Scope**: ${app.scope}
-- **Version**: ${app.version}
-- **Tables**: ${app.tables.length}
-- **Menus**: ${app.menus.length}
-
-## Architecture
-
-### Data Model
-${app.tables.map(table => `
-#### ${table.label} (${table.name})
-- **Extends**: ${table.extends}
-- **Purpose**: Primary table for storing ${table.label.toLowerCase()} records
-
-**Fields**:
-${table.fields.map(field => `- **${field.label}** (${field.name}): ${field.type}${field.reference ? ` -> ${field.reference}` : ''}`).join('\n')}
-`).join('\n')}
-
-### Security Model
-- **Roles**:
-  - ${app.scope}.user: Basic user access
-  - ${app.scope}.admin: Administrative access
-- **ACLs**: Table-level access controls for CRUD operations
-
-## Development Guidelines
-
-### Naming Conventions
-- Tables: u_[descriptive_name]
-- Fields: u_[field_name]
-- Script Includes: ${app.vendorPrefix}_[ClassName]
-- Business Rules: [Table] - [Action] - [Description]
-
-### Coding Standards
-\`\`\`javascript
-// Use the application's utility class
-var utils = new ${app.vendorPrefix}_${app.scope}_Utils();
-utils.log('Debug message', 'MethodName');
-
-// Check permissions
-if (!utils.hasRole('${app.scope}.user')) {
-    gs.addErrorMessage('Insufficient permissions');
-    return;
-}
-\`\`\`
-
-### Best Practices
-1. Always use scoped APIs when available
-2. Implement proper error handling
-3. Log important operations for debugging
-4. Follow ServiceNow development best practices
-
-## Extending the Application
-
-### Adding New Tables
-1. Create table extending appropriate base table
-2. Add necessary fields with u_ prefix
-3. Create ACLs for the new table
-4. Update navigation menus
-
-### Creating Business Rules
-\`\`\`javascript
-(function executeRule(current, previous /*null when async*/) {
-    // Your business logic here
-    var utils = new ${app.vendorPrefix}_${app.scope}_Utils();
-    utils.log('Business rule triggered', 'RuleName');
-})(current, previous);
-\`\`\`
-
-### Adding UI Components
-1. Service Portal Widgets: Use provided dashboard widget as template
-2. UI Pages: Follow existing UI page patterns
-3. Client Scripts: Ensure proper form context usage
-
-## API Reference
-
-### ${app.vendorPrefix}_${app.scope}_Utils
-Main utility class for the application.
-
-**Methods**:
-- getAppProperties(): Returns application metadata
-- log(message, source): Logs application messages
-- hasRole(role): Checks user permissions
-
-## Testing
-
-### Unit Testing
-\`\`\`javascript
-// Test script for Script Includes
-var utils = new ${app.vendorPrefix}_${app.scope}_Utils();
-gs.info('Testing utility class: ' + utils.type);
-\`\`\`
-
-### Integration Testing
-1. Test all CRUD operations
-2. Verify workflow execution
-3. Check security controls
-4. Validate UI functionality
-
-## Deployment
-
-### Moving Between Instances
-1. Use Update Sets for controlled deployments
-2. Export application to source control
-3. Use application repository for version control
-
-### Version Management
-- Follow semantic versioning (MAJOR.MINOR.PATCH)
-- Document all changes in release notes
-- Test thoroughly before version updates
-
-Generated by: ServiceNow Multi-Agent Framework
-`;
-    }
-}
-exports.AppCreatorAgent = AppCreatorAgent;
-//# sourceMappingURL=app-creator.agent.js.map