snow-flow 1.1.0

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

@@ -0,0 +1,1292 @@
+"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