@trentapps/manager-protocol 1.1.3 → 1.2.0

package/dist/rules/condition-optimizer.js

@@ -0,0 +1,479 @@
+/**
+ * Enterprise Agent Supervisor - Condition Optimizer
+ * Task #34: Optimize Inefficient Condition Logic
+ *
+ * Provides utilities for optimizing rule conditions:
+ * - Use `in` operator instead of multiple `equals`
+ * - Order conditions for short-circuit optimization
+ * - Identify and consolidate redundant conditions
+ */
+// ============================================================================
+// FIELD COST DEFINITIONS
+// ============================================================================
+/**
+ * Default field costs for short-circuit optimization
+ * Lower cost = faster to evaluate = should be first
+ */
+export const DEFAULT_FIELD_COSTS = [
+    // Lowest cost - simple string/boolean comparisons on common fields
+    { field: 'actionCategory', cost: 1, reason: 'Always present, simple enum comparison' },
+    { field: 'environment', cost: 1, reason: 'Always present, simple string comparison' },
+    { field: 'actionName', cost: 2, reason: 'Always present, string comparison' },
+    { field: 'protocol', cost: 2, reason: 'Usually present, simple string comparison' },
+    // Low cost - boolean checks
+    { field: 'authenticated', cost: 3, reason: 'Boolean flag check' },
+    { field: 'sandboxed', cost: 3, reason: 'Boolean flag check' },
+    { field: 'encryptionEnabled', cost: 3, reason: 'Boolean flag check' },
+    // Medium cost - may require lookup
+    { field: 'userRole', cost: 5, reason: 'May require role lookup' },
+    { field: 'dataClassification', cost: 5, reason: 'May require data inspection' },
+    { field: 'dataType', cost: 6, reason: 'May require type inference' },
+    // Higher cost - numeric comparisons that may involve computation
+    { field: 'recordCount', cost: 7, reason: 'May require counting' },
+    { field: 'estimatedCost', cost: 8, reason: 'May require calculation' },
+    { field: 'tokenCount', cost: 8, reason: 'May require counting' },
+    { field: 'sessionActionCount', cost: 7, reason: 'May require lookup' },
+    // Highest cost - regex matching
+    { field: 'query', cost: 10, reason: 'Regex pattern matching' },
+    { field: 'command', cost: 10, reason: 'Regex pattern matching' },
+    { field: 'filePath', cost: 10, reason: 'Regex pattern matching' },
+];
+/**
+ * Get the cost for a field (default cost for unknown fields)
+ */
+function getFieldCost(field) {
+    const knownField = DEFAULT_FIELD_COSTS.find(f => f.field === field);
+    if (knownField)
+        return knownField.cost;
+    // Default costs based on field name patterns
+    if (field.includes('regex') || field.includes('pattern'))
+        return 10;
+    if (field.includes('count') || field.includes('size'))
+        return 7;
+    if (field.startsWith('is') || field.startsWith('has') || field.endsWith('Enabled'))
+        return 3;
+    return 5; // Default middle cost
+}
+/**
+ * Get the cost for an operator
+ */
+function getOperatorCost(operator) {
+    switch (operator) {
+        case 'equals':
+        case 'not_equals':
+            return 1;
+        case 'exists':
+        case 'not_exists':
+            return 1;
+        case 'in':
+        case 'not_in':
+            return 2;
+        case 'contains':
+        case 'not_contains':
+            return 3;
+        case 'greater_than':
+        case 'less_than':
+            return 2;
+        case 'matches_regex':
+            return 8;
+        case 'custom':
+            return 10;
+        default:
+            return 5;
+    }
+}
+// ============================================================================
+// OPTIMIZATION FUNCTIONS
+// ============================================================================
+/**
+ * Combine multiple `equals` conditions on the same field into a single `in` condition
+ *
+ * @example
+ * Before:
+ *   { field: 'env', operator: 'equals', value: 'dev' }
+ *   { field: 'env', operator: 'equals', value: 'staging' }
+ *
+ * After:
+ *   { field: 'env', operator: 'in', value: ['dev', 'staging'] }
+ */
+export function combineEqualsToIn(conditions) {
+    const changes = [];
+    const fieldEqualsMap = new Map();
+    const nonEqualsConditions = [];
+    // Group equals conditions by field
+    for (const condition of conditions) {
+        if (condition.operator === 'equals' && condition.value !== null && typeof condition.value !== 'boolean') {
+            const existing = fieldEqualsMap.get(condition.field) || [];
+            existing.push(condition);
+            fieldEqualsMap.set(condition.field, existing);
+        }
+        else {
+            nonEqualsConditions.push(condition);
+        }
+    }
+    // Convert fields with multiple equals to in
+    const optimizedConditions = [...nonEqualsConditions];
+    for (const [field, equalsConditions] of Array.from(fieldEqualsMap.entries())) {
+        if (equalsConditions.length > 1) {
+            // Combine into single `in` condition
+            const values = equalsConditions.map(c => c.value);
+            const newCondition = {
+                field,
+                operator: 'in',
+                value: values
+            };
+            optimizedConditions.push(newCondition);
+            changes.push({
+                type: 'combined_to_in',
+                description: `Combined ${equalsConditions.length} 'equals' conditions on '${field}' into single 'in' condition`,
+                originalConditions: equalsConditions,
+                newCondition
+            });
+        }
+        else {
+            // Keep single equals as-is
+            optimizedConditions.push(equalsConditions[0]);
+        }
+    }
+    return { conditions: optimizedConditions, changes };
+}
+/**
+ * Reorder conditions for optimal short-circuit evaluation
+ * Cheaper conditions first, more likely to fail conditions first
+ */
+export function reorderForShortCircuit(conditions) {
+    const changes = [];
+    // Calculate total cost for each condition
+    const conditionsWithCost = conditions.map((condition, originalIndex) => ({
+        condition,
+        originalIndex,
+        cost: getFieldCost(condition.field) + getOperatorCost(condition.operator)
+    }));
+    // Sort by cost (ascending - cheapest first)
+    conditionsWithCost.sort((a, b) => a.cost - b.cost);
+    // Check if reordering changed anything
+    const wasReordered = conditionsWithCost.some((item, index) => item.originalIndex !== index);
+    if (wasReordered) {
+        changes.push({
+            type: 'reordered',
+            description: 'Reordered conditions for optimal short-circuit evaluation (cheapest first)',
+            originalConditions: conditions
+        });
+    }
+    return {
+        conditions: conditionsWithCost.map(item => item.condition),
+        changes
+    };
+}
+/**
+ * Remove redundant conditions
+ * - Duplicate conditions
+ * - Conditions that are subsets of others
+ */
+export function removeRedundant(conditions) {
+    const changes = [];
+    const seen = new Set();
+    const unique = [];
+    for (const condition of conditions) {
+        // Create a canonical key for the condition
+        const key = JSON.stringify({
+            field: condition.field,
+            operator: condition.operator,
+            value: condition.value
+        });
+        if (!seen.has(key)) {
+            seen.add(key);
+            unique.push(condition);
+        }
+        else {
+            changes.push({
+                type: 'removed_redundant',
+                description: `Removed duplicate condition on '${condition.field}'`,
+                originalConditions: [condition]
+            });
+        }
+    }
+    // Check for subset conditions (e.g., equals inside in)
+    const result = [];
+    for (const condition of unique) {
+        let isSubset = false;
+        if (condition.operator === 'equals') {
+            // Check if there's an `in` condition on the same field that contains this value
+            const inCondition = unique.find(c => c.field === condition.field &&
+                c.operator === 'in' &&
+                Array.isArray(c.value) &&
+                c.value.includes(condition.value));
+            if (inCondition) {
+                isSubset = true;
+                changes.push({
+                    type: 'removed_redundant',
+                    description: `Removed '${condition.field} equals ${condition.value}' as it's covered by 'in' condition`,
+                    originalConditions: [condition]
+                });
+            }
+        }
+        if (!isSubset) {
+            result.push(condition);
+        }
+    }
+    return { conditions: result, changes };
+}
+/**
+ * Simplify conditions where possible
+ * - Convert single-element `in` to `equals`
+ * - Convert `not_in` with single element to `not_equals`
+ */
+export function simplifyConditions(conditions) {
+    const changes = [];
+    const simplified = [];
+    for (const condition of conditions) {
+        if (condition.operator === 'in' && Array.isArray(condition.value) && condition.value.length === 1) {
+            const newCondition = {
+                field: condition.field,
+                operator: 'equals',
+                value: condition.value[0]
+            };
+            simplified.push(newCondition);
+            changes.push({
+                type: 'simplified',
+                description: `Simplified single-element 'in' to 'equals' on '${condition.field}'`,
+                originalConditions: [condition],
+                newCondition
+            });
+        }
+        else if (condition.operator === 'not_in' && Array.isArray(condition.value) && condition.value.length === 1) {
+            const newCondition = {
+                field: condition.field,
+                operator: 'not_equals',
+                value: condition.value[0]
+            };
+            simplified.push(newCondition);
+            changes.push({
+                type: 'simplified',
+                description: `Simplified single-element 'not_in' to 'not_equals' on '${condition.field}'`,
+                originalConditions: [condition],
+                newCondition
+            });
+        }
+        else {
+            simplified.push(condition);
+        }
+    }
+    return { conditions: simplified, changes };
+}
+// ============================================================================
+// MAIN OPTIMIZATION FUNCTION
+// ============================================================================
+/**
+ * Optimize rule conditions using all available strategies
+ */
+export function optimizeConditions(conditions) {
+    if (!conditions || conditions.length === 0) {
+        return {
+            original: conditions,
+            optimized: conditions,
+            changes: [],
+            wasOptimized: false,
+            estimatedImprovement: 0
+        };
+    }
+    const allChanges = [];
+    let currentConditions = [...conditions];
+    // Step 1: Remove redundant conditions first
+    const redundantResult = removeRedundant(currentConditions);
+    currentConditions = redundantResult.conditions;
+    allChanges.push(...redundantResult.changes);
+    // Step 2: Combine equals to in
+    const combineResult = combineEqualsToIn(currentConditions);
+    currentConditions = combineResult.conditions;
+    allChanges.push(...combineResult.changes);
+    // Step 3: Simplify conditions
+    const simplifyResult = simplifyConditions(currentConditions);
+    currentConditions = simplifyResult.conditions;
+    allChanges.push(...simplifyResult.changes);
+    // Step 4: Reorder for short-circuit optimization
+    const reorderResult = reorderForShortCircuit(currentConditions);
+    currentConditions = reorderResult.conditions;
+    allChanges.push(...reorderResult.changes);
+    // Calculate estimated improvement
+    let improvement = 0;
+    if (allChanges.length > 0) {
+        // Each change type contributes to improvement
+        for (const change of allChanges) {
+            switch (change.type) {
+                case 'combined_to_in':
+                    improvement += 0.1; // 10% per combination
+                    break;
+                case 'removed_redundant':
+                    improvement += 0.15; // 15% per redundant removal
+                    break;
+                case 'reordered':
+                    improvement += 0.05; // 5% for reordering
+                    break;
+                case 'simplified':
+                    improvement += 0.05; // 5% per simplification
+                    break;
+            }
+        }
+        improvement = Math.min(improvement, 1); // Cap at 100%
+    }
+    return {
+        original: conditions,
+        optimized: currentConditions,
+        changes: allChanges,
+        wasOptimized: allChanges.length > 0,
+        estimatedImprovement: improvement
+    };
+}
+/**
+ * Optimize all conditions in a rule
+ */
+export function optimizeRule(rule) {
+    const result = optimizeConditions(rule.conditions);
+    return {
+        rule: {
+            ...rule,
+            conditions: result.optimized
+        },
+        result
+    };
+}
+/**
+ * Optimize all rules and return summary
+ */
+export function optimizeRules(rules) {
+    const optimizedRules = [];
+    const details = [];
+    let totalChanges = 0;
+    let optimizedCount = 0;
+    let totalImprovement = 0;
+    const changesByType = {
+        combined_to_in: 0,
+        reordered: 0,
+        removed_redundant: 0,
+        simplified: 0
+    };
+    for (const rule of rules) {
+        const { rule: optimizedRule, result } = optimizeRule(rule);
+        optimizedRules.push(optimizedRule);
+        if (result.wasOptimized) {
+            optimizedCount++;
+            totalImprovement += result.estimatedImprovement;
+            details.push({
+                ruleId: rule.id,
+                ruleName: rule.name,
+                result
+            });
+            for (const change of result.changes) {
+                totalChanges++;
+                changesByType[change.type] = (changesByType[change.type] || 0) + 1;
+            }
+        }
+    }
+    return {
+        rules: optimizedRules,
+        summary: {
+            totalRules: rules.length,
+            optimizedRules: optimizedCount,
+            totalChanges,
+            changesByType,
+            averageImprovement: optimizedCount > 0 ? totalImprovement / optimizedCount : 0
+        },
+        details
+    };
+}
+// ============================================================================
+// ANALYSIS FUNCTIONS
+// ============================================================================
+/**
+ * Analyze rules for optimization opportunities without modifying them
+ */
+export function analyzeRulesForOptimization(rules) {
+    const opportunities = [];
+    for (const rule of rules) {
+        const issues = [];
+        let potentialImprovement = 0;
+        // Check for multiple equals on same field
+        const fieldEqualsCount = new Map();
+        for (const condition of rule.conditions) {
+            if (condition.operator === 'equals') {
+                fieldEqualsCount.set(condition.field, (fieldEqualsCount.get(condition.field) || 0) + 1);
+            }
+        }
+        for (const [field, count] of Array.from(fieldEqualsCount.entries())) {
+            if (count > 1) {
+                issues.push(`${count} 'equals' conditions on '${field}' could be combined into single 'in'`);
+                potentialImprovement += 0.1;
+            }
+        }
+        // Check for single-element in conditions
+        for (const condition of rule.conditions) {
+            if (condition.operator === 'in' && Array.isArray(condition.value) && condition.value.length === 1) {
+                issues.push(`Single-element 'in' on '${condition.field}' could be simplified to 'equals'`);
+                potentialImprovement += 0.05;
+            }
+        }
+        // Check for suboptimal ordering (regex conditions before simple comparisons)
+        let hasRegexBeforeSimple = false;
+        let foundSimple = false;
+        for (let i = rule.conditions.length - 1; i >= 0; i--) {
+            const cond = rule.conditions[i];
+            if (cond.operator === 'equals' || cond.operator === 'in') {
+                foundSimple = true;
+            }
+            else if (cond.operator === 'matches_regex' && foundSimple) {
+                hasRegexBeforeSimple = true;
+                break;
+            }
+        }
+        if (hasRegexBeforeSimple) {
+            issues.push('Regex conditions before simple comparisons - reorder for short-circuit optimization');
+            potentialImprovement += 0.05;
+        }
+        // Check for duplicate conditions
+        const seen = new Set();
+        for (const condition of rule.conditions) {
+            const key = JSON.stringify({ field: condition.field, operator: condition.operator, value: condition.value });
+            if (seen.has(key)) {
+                issues.push(`Duplicate condition on '${condition.field}'`);
+                potentialImprovement += 0.15;
+            }
+            seen.add(key);
+        }
+        if (issues.length > 0) {
+            opportunities.push({
+                ruleId: rule.id,
+                ruleName: rule.name,
+                issues,
+                potentialImprovement: Math.min(potentialImprovement, 1)
+            });
+        }
+    }
+    return {
+        opportunities,
+        summary: {
+            totalOpportunities: opportunities.reduce((sum, o) => sum + o.issues.length, 0),
+            rulesWithIssues: opportunities.length
+        }
+    };
+}
+// ============================================================================
+// EXPORTS
+// ============================================================================
+export default {
+    // Main optimization functions
+    optimizeConditions,
+    optimizeRule,
+    optimizeRules,
+    // Individual optimization strategies
+    combineEqualsToIn,
+    reorderForShortCircuit,
+    removeRedundant,
+    simplifyConditions,
+    // Analysis
+    analyzeRulesForOptimization,
+    // Cost definitions
+    DEFAULT_FIELD_COSTS,
+    getFieldCost
+};
+//# sourceMappingURL=condition-optimizer.js.map

package/dist/rules/condition-optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition-optimizer.js","sourceRoot":"","sources":["../../src/rules/condition-optimizer.ts"],"names":[],"mappings":"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"}

package/dist/rules/css.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../src/rules/css.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,eAAO,MAAM,QAAQ,EAAE,YAAY,EAytClC,CAAC;AAEF,eAAe,QAAQ,CAAC"}
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../src/rules/css.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,eAAO,MAAM,QAAQ,EAAE,YAAY,EA2vDlC,CAAC;AAEF,eAAe,QAAQ,CAAC"}