decision_agent 0.1.4 → 0.1.6

data/lib/decision_agent/web/public/app.js

@@ -1,10 +1,63 @@
 // DecisionAgent Rule Builder - Main Application
+
+// Helper function to get the base path for API calls
+// This handles both standalone and Rails-mounted scenarios
+function getBasePath() {
+    // Try to get from <base> tag first
+    const baseTag = document.querySelector('base');
+    if (baseTag && baseTag.href) {
+        try {
+            // Parse the base URL
+            const baseUrl = new URL(baseTag.href, window.location.href);
+            let path = baseUrl.pathname;
+            
+            // Ensure it ends with / for proper path joining
+            if (path && !path.endsWith('/')) {
+                path += '/';
+            }
+            
+            return path;
+        } catch (e) {
+            // If URL parsing fails, try simple string matching
+            // Check if it's an absolute path
+            if (baseTag.href.startsWith('/')) {
+                // Extract path from absolute URL
+                const match = baseTag.href.match(/^(https?:\/\/[^\/]+)?(\/.*?)\/?$/);
+                if (match && match[2]) {
+                    return match[2].endsWith('/') ? match[2] : match[2] + '/';
+                }
+            } else if (baseTag.href.startsWith('./')) {
+                // Relative path - use current location's directory
+                const pathname = window.location.pathname;
+                // Get directory path (remove filename if present)
+                const dirPath = pathname.substring(0, pathname.lastIndexOf('/') + 1);
+                return dirPath;
+            }
+        }
+    }
+    
+    // Fallback: detect from current location
+    // If we're at /decision_agent, use that as base
+    const pathname = window.location.pathname;
+    if (pathname.includes('/decision_agent')) {
+        const match = pathname.match(/^(\/.*?\/decision_agent)\/?/);
+        if (match) {
+            return match[1].endsWith('/') ? match[1] : match[1] + '/';
+        }
+    }
+    
+    // Default: use current directory
+    const dirPath = pathname.substring(0, pathname.lastIndexOf('/') + 1);
+    return dirPath || '/';
+}
+
 class RuleBuilder {
     constructor() {
         this.rules = [];
         this.currentRule = null;
         this.currentRuleIndex = null;
         this.currentCondition = null;
+        this.basePath = getBasePath();
         this.init();
     }
 
@@ -13,6 +66,15 @@ class RuleBuilder {
         this.updateJSONPreview();
     }
 
+    getAuthHeaders() {
+        const token = localStorage.getItem('auth_token');
+        const headers = { 'Content-Type': 'application/json' };
+        if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
+        }
+        return headers;
+    }
+
     bindEvents() {
         // Rule management
         document.getElementById('addRuleBtn').addEventListener('click', () => this.openRuleModal());
@@ -215,11 +277,70 @@ class RuleBuilder {
         const valueInput = selectElement.parentElement.querySelector('.field-value');
         const operator = selectElement.value;
 
+        // Operators that don't need a value
         if (operator === 'present' || operator === 'blank') {
             valueInput.style.display = 'none';
             valueInput.value = '';
+            return;
+        }
+
+        valueInput.style.display = 'block';
+
+        // Set helpful placeholders based on operator
+        const placeholders = {
+            // Basic operators
+            'eq': 'value',
+            'neq': 'value',
+            'gt': '100',
+            'gte': '100',
+            'lt': '100',
+            'lte': '100',
+            'in': '["value1", "value2"]',
+
+            // String operators
+            'contains': 'substring',
+            'starts_with': 'prefix',
+            'ends_with': 'suffix',
+            'matches': '^pattern.*$',
+
+            // Numeric operators
+            'between': '[min, max] or {"min": 0, "max": 100}',
+            'modulo': '[divisor, remainder] or {"divisor": 2, "remainder": 0}',
+
+            // Date/time operators
+            'before_date': '2025-12-31',
+            'after_date': '2024-01-01',
+            'within_days': '7',
+            'day_of_week': 'monday or 1',
+
+            // Collection operators
+            'contains_all': '["item1", "item2"]',
+            'contains_any': '["item1", "item2"]',
+            'intersects': '["item1", "item2"]',
+            'subset_of': '["valid1", "valid2", "valid3"]',
+
+            // Geospatial operators
+            'within_radius': '{"center": {"lat": 40.7128, "lon": -74.0060}, "radius": 10}',
+            'in_polygon': '[{"lat": 40, "lon": -74}, {"lat": 41, "lon": -74}, ...]'
+        };
+
+        valueInput.placeholder = placeholders[operator] || 'value';
+
+        // Add title attribute with helpful hint
+        const hints = {
+            'between': 'Range: [min, max] or {"min": 0, "max": 100}',
+            'modulo': 'Modulo: [divisor, remainder] or {"divisor": 2, "remainder": 0}',
+            'matches': 'Regular expression pattern (e.g., ^user@company\\.com$)',
+            'within_days': 'Number of days from now (e.g., 7 for within a week)',
+            'day_of_week': 'Day name (monday) or number (0=Sunday, 1=Monday, ...)',
+            'within_radius': 'JSON: {"center": {"lat": y, "lon": x}, "radius": km}',
+            'in_polygon': 'Array of coordinates: [{"lat": y, "lon": x}, ...]'
+        };
+
+        if (hints[operator]) {
+            valueInput.title = hints[operator];
         } else {
-            valueInput.style.display = 'block';
+            valueInput.title = '';
         }
     }
 
@@ -404,7 +525,7 @@ class RuleBuilder {
         };
 
         try {
-            const response = await fetch('/api/validate', {
+            const response = await fetch(`${this.basePath}api/validate`, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json'
@@ -526,48 +647,75 @@ class RuleBuilder {
     loadExample() {
         const example = {
             version: '1.0',
-            ruleset: 'example_approval_rules',
+            ruleset: 'example_advanced_rules',
             rules: [
                 {
-                    id: 'high_priority_auto_approve',
+                    id: 'corporate_email_approval',
                     if: {
                         all: [
-                            { field: 'priority', op: 'eq', value: 'high' },
-                            { field: 'user.role', op: 'eq', value: 'admin' }
+                            { field: 'email', op: 'ends_with', value: '@company.com' },
+                            { field: 'age', op: 'between', value: [18, 65] }
                         ]
                     },
                     then: {
                         decision: 'approve',
                         weight: 0.95,
-                        reason: 'High priority request from admin'
+                        reason: 'Corporate email with valid age range'
                     }
                 },
                 {
-                    id: 'low_amount_approve',
+                    id: 'weekend_special_offer',
                     if: {
                         all: [
-                            { field: 'amount', op: 'lt', value: 1000 },
-                            { field: 'status', op: 'eq', value: 'active' }
+                            { field: 'booking_date', op: 'day_of_week', value: 'saturday' },
+                            { field: 'amount', op: 'between', value: [100, 500] }
                         ]
                     },
                     then: {
-                        decision: 'approve',
-                        weight: 0.8,
-                        reason: 'Low amount with active status'
+                        decision: 'apply_discount',
+                        weight: 0.9,
+                        reason: 'Weekend booking discount eligible'
+                    }
+                },
+                {
+                    id: 'local_delivery_zone',
+                    if: {
+                        field: 'delivery.location',
+                        op: 'within_radius',
+                        value: { center: { lat: 40.7128, lon: -74.0060 }, radius: 25 }
+                    },
+                    then: {
+                        decision: 'same_day_delivery',
+                        weight: 0.85,
+                        reason: 'Within local delivery zone'
+                    }
+                },
+                {
+                    id: 'permission_check',
+                    if: {
+                        all: [
+                            { field: 'user.permissions', op: 'contains_all', value: ['read', 'write'] },
+                            { field: 'user.roles', op: 'contains_any', value: ['admin', 'manager'] }
+                        ]
+                    },
+                    then: {
+                        decision: 'grant_access',
+                        weight: 1.0,
+                        reason: 'User has required permissions and role'
                     }
                 },
                 {
-                    id: 'missing_info_reject',
+                    id: 'urgent_recent_account',
                     if: {
-                        any: [
-                            { field: 'description', op: 'blank' },
-                            { field: 'assignee', op: 'blank' }
+                        all: [
+                            { field: 'message', op: 'contains', value: 'urgent' },
+                            { field: 'created_at', op: 'within_days', value: 30 }
                         ]
                     },
                     then: {
-                        decision: 'needs_info',
-                        weight: 0.7,
-                        reason: 'Missing required information'
+                        decision: 'escalate',
+                        weight: 0.9,
+                        reason: 'Urgent message from recent account'
                     }
                 }
             ]
@@ -623,9 +771,9 @@ class RuleBuilder {
         const ruleData = this.getRuleData();
 
         try {
-            const response = await fetch('/api/versions', {
+            const response = await fetch(`${this.basePath}api/versions`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                headers: this.getAuthHeaders(),
                 body: JSON.stringify({
                     rule_id: ruleset,
                     content: ruleData,
@@ -657,7 +805,9 @@ class RuleBuilder {
         }
 
         try {
-            const response = await fetch(`/api/rules/${encodeURIComponent(ruleset)}/history`);
+            const response = await fetch(`${this.basePath}api/rules/${encodeURIComponent(ruleset)}/history`, {
+                headers: this.getAuthHeaders()
+            });
             if (response.ok) {
                 const history = await response.json();
                 this.displayVersionHistory(history);
@@ -740,7 +890,9 @@ class RuleBuilder {
 
     async loadVersion(versionId) {
         try {
-            const response = await fetch(`/api/versions/${encodeURIComponent(versionId)}`);
+            const response = await fetch(`${this.basePath}api/versions/${encodeURIComponent(versionId)}`, {
+                headers: this.getAuthHeaders()
+            });
             if (response.ok) {
                 const version = await response.json();
                 this.loadRulesFromVersion(version.content);
@@ -776,9 +928,9 @@ class RuleBuilder {
             const performedBy = prompt('Enter your name:', 'system');
             if (!performedBy) return;
 
-            const response = await fetch(`/api/versions/${encodeURIComponent(versionId)}/activate`, {
+            const response = await fetch(`${this.basePath}api/versions/${encodeURIComponent(versionId)}/activate`, {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json' },
+                headers: this.getAuthHeaders(),
                 body: JSON.stringify({ performed_by: performedBy })
             });
 
@@ -799,7 +951,10 @@ class RuleBuilder {
     async compareVersions(versionId1, versionId2) {
         try {
             const response = await fetch(
-                `/api/versions/${encodeURIComponent(versionId1)}/compare/${encodeURIComponent(versionId2)}`
+                `${this.basePath}api/versions/${encodeURIComponent(versionId1)}/compare/${encodeURIComponent(versionId2)}`,
+                {
+                    headers: this.getAuthHeaders()
+                }
             );
 
             if (response.ok) {
@@ -867,9 +1022,9 @@ class RuleBuilder {
         }
 
         try {
-            const response = await fetch(`/api/versions/${encodeURIComponent(versionId)}`, {
+            const response = await fetch(`${this.basePath}api/versions/${encodeURIComponent(versionId)}`, {
                 method: 'DELETE',
-                headers: { 'Content-Type': 'application/json' }
+                headers: this.getAuthHeaders()
             });
 
             if (response.ok) {