@memberjunction/react-test-harness 2.82.0 → 2.84.0

package/dist/lib/component-linter.js

@@ -64,12 +64,23 @@ class ComponentLinter {
                 const dataViolations = this.validateDataRequirements(ast, componentSpec);
                 violations.push(...dataViolations);
             }
+            // Deduplicate violations - keep only unique rule+message combinations
+            const uniqueViolations = this.deduplicateViolations(violations);
+            // Count violations by severity
+            const criticalCount = uniqueViolations.filter(v => v.severity === 'critical').length;
+            const highCount = uniqueViolations.filter(v => v.severity === 'high').length;
+            const mediumCount = uniqueViolations.filter(v => v.severity === 'medium').length;
+            const lowCount = uniqueViolations.filter(v => v.severity === 'low').length;
             // Generate fix suggestions
-            const suggestions = this.generateFixSuggestions(violations);
+            const suggestions = this.generateFixSuggestions(uniqueViolations);
             return {
-                success: violations.filter(v => v.severity === 'error').length === 0,
-                violations,
-                suggestions
+                success: criticalCount === 0 && highCount === 0, // Only fail on critical/high
+                violations: uniqueViolations,
+                suggestions,
+                criticalCount,
+                highCount,
+                mediumCount,
+                lowCount
             };
         }
         catch (error) {
@@ -78,7 +89,7 @@ class ComponentLinter {
                 success: false,
                 violations: [{
                         rule: 'parse-error',
-                        severity: 'error',
+                        severity: 'critical',
                         line: 0,
                         column: 0,
                         message: `Failed to parse component: ${error instanceof Error ? error.message : 'Unknown error'}`
@@ -183,7 +194,7 @@ class ComponentLinter {
                                             usedEntity.toLowerCase().includes(e.toLowerCase()));
                                         violations.push({
                                             rule: 'entity-name-mismatch',
-                                            severity: 'error',
+                                            severity: 'critical',
                                             line: prop.value.loc?.start.line || 0,
                                             column: prop.value.loc?.start.column || 0,
                                             message: `Entity "${usedEntity}" not found in dataRequirements. ${possibleMatches.length > 0
@@ -206,7 +217,7 @@ class ComponentLinter {
                                                         if (/COUNT\s*\(|SUM\s*\(|AVG\s*\(|MAX\s*\(|MIN\s*\(/i.test(fieldName)) {
                                                             violations.push({
                                                                 rule: 'runview-sql-function',
-                                                                severity: 'error',
+                                                                severity: 'critical',
                                                                 line: fieldElement.loc?.start.line || 0,
                                                                 column: fieldElement.loc?.start.column || 0,
                                                                 message: `RunView does not support SQL aggregations. Use RunQuery for aggregations or fetch raw data and aggregate in JavaScript.`,
@@ -221,7 +232,7 @@ class ComponentLinter {
                                                             if (!isAllowed) {
                                                                 violations.push({
                                                                     rule: 'field-not-in-requirements',
-                                                                    severity: 'error',
+                                                                    severity: 'critical',
                                                                     line: fieldElement.loc?.start.line || 0,
                                                                     column: fieldElement.loc?.start.column || 0,
                                                                     message: `Field "${fieldName}" not found in dataRequirements for entity "${usedEntity}". Available fields: ${[...entityFields.displayFields, ...entityFields.filterFields, ...entityFields.sortFields].join(', ')}`,
@@ -241,7 +252,7 @@ class ComponentLinter {
                                                 if (!entityFields.sortFields.has(orderByField)) {
                                                     violations.push({
                                                         rule: 'orderby-field-not-sortable',
-                                                        severity: 'error',
+                                                        severity: 'critical',
                                                         line: orderByProperty.value.loc?.start.line || 0,
                                                         column: orderByProperty.value.loc?.start.column || 0,
                                                         message: `OrderBy field "${orderByField}" not in sortFields for entity "${usedEntity}". Available sort fields: ${[...entityFields.sortFields].join(', ')}`,
@@ -282,7 +293,7 @@ class ComponentLinter {
                                         usedQuery.toLowerCase().includes(q.toLowerCase()));
                                     violations.push({
                                         rule: 'query-name-mismatch',
-                                        severity: 'error',
+                                        severity: 'critical',
                                         line: prop.value.loc?.start.line || 0,
                                         column: prop.value.loc?.start.column || 0,
                                         message: `Query "${usedQuery}" not found in dataRequirements. ${possibleMatches.length > 0
@@ -323,6 +334,27 @@ class ComponentLinter {
         }
         return null;
     }
+    static deduplicateViolations(violations) {
+        const seen = new Set();
+        const unique = [];
+        for (const violation of violations) {
+            // Create a key from the complete violation details (case-insensitive for message)
+            const key = `${violation.rule}:${violation.severity}:${violation.line}:${violation.column}:${violation.message.toLowerCase()}`;
+            if (!seen.has(key)) {
+                seen.add(key);
+                unique.push(violation);
+            }
+        }
+        // Sort by severity (critical > high > medium > low) and then by line number
+        const severityOrder = { critical: 0, high: 1, medium: 2, low: 3 };
+        unique.sort((a, b) => {
+            const severityDiff = severityOrder[a.severity] - severityOrder[b.severity];
+            if (severityDiff !== 0)
+                return severityDiff;
+            return a.line - b.line;
+        });
+        return unique;
+    }
     static generateFixSuggestions(violations) {
         const suggestions = [];
         for (const violation of violations) {
@@ -330,36 +362,66 @@ class ComponentLinter {
                 case 'full-state-ownership':
                     suggestions.push({
                         violation: violation.rule,
-                        suggestion: 'Components must manage ALL their own state internally. No state props allowed.',
-                        example: `// ❌ WRONG - Expecting state from props:
-function Component({ selectedId, filters, sortBy, onStateChange }) {
-  // This component expects parent to manage its state - WRONG!
+                        suggestion: 'Components must manage ALL their own state internally. Use proper naming conventions for initialization.',
+                        example: `// ❌ WRONG - Controlled state props:
+function PaginationControls({ currentPage, filters, sortBy, onPageChange }) {
+  // These props suggest parent controls the state - WRONG!
 }
 
-// ✅ CORRECT - Component owns ALL its state:
-function Component({ data, savedUserSettings, onSaveUserSettings }) {
-  // Component manages ALL its own state internally
-  const [selectedId, setSelectedId] = useState(
-    savedUserSettings?.selectedId || null
-  );
-  const [filters, setFilters] = useState(
-    savedUserSettings?.filters || {}
-  );
-  const [sortBy, setSortBy] = useState(
-    savedUserSettings?.sortBy || 'name'
+// ❌ WRONG - State props without handlers (still controlled):
+function Component({ selectedId, activeTab }) {
+  // Parent is managing this component's state
+}
+
+// ✅ CORRECT - Using initialization props:
+function PaginationControls({ initialPage, defaultPageSize, onPageChange, savedUserSettings, onSaveUserSettings }) {
+  // Component owns ALL its state, initialized from props
+  const [currentPage, setCurrentPage] = useState(
+    savedUserSettings?.currentPage || initialPage || 1
   );
+  const [pageSize] = useState(defaultPageSize || 10);
   
-  // Handle selection
-  const handleSelect = (id) => {
-    setSelectedId(id);  // Update internal state
+  const handlePageChange = (page) => {
+    setCurrentPage(page);  // Update internal state
+    onPageChange?.(page);  // Notify parent if needed
     onSaveUserSettings?.({
       ...savedUserSettings,
-      selectedId: id
+      currentPage: page
     });
   };
-  
-  // Each component is generated separately - it must be self-contained
-}`
+}
+
+// ✅ CORRECT - Configuration props are allowed:
+function DataTable({ 
+  items,              // Data prop - allowed
+  pageSize,           // Configuration - allowed
+  maxItems,           // Configuration - allowed
+  initialSortBy,      // Initialization - allowed
+  defaultFilters,     // Initialization - allowed
+  onSelectionChange,  // Event handler - allowed
+  savedUserSettings,
+  onSaveUserSettings 
+}) {
+  // Component manages its own state
+  const [sortBy, setSortBy] = useState(initialSortBy || 'name');
+  const [filters, setFilters] = useState(defaultFilters || {});
+  const [selectedItems, setSelectedItems] = useState(
+    savedUserSettings?.selectedItems || []
+  );
+}
+
+// Naming conventions:
+// ✅ ALLOWED props:
+// - initial* (initialPage, initialValue, initialSelection)
+// - default* (defaultTab, defaultSortBy, defaultFilters)  
+// - Configuration (pageSize, maxItems, minValue, disabled)
+// - Data props (items, options, data, rows, columns)
+// - Event handlers (onChange, onSelect, onPageChange)
+
+// ❌ DISALLOWED props (suggest controlled component):
+// - Direct state names (currentPage, selectedId, activeTab)
+// - State without 'initial'/'default' prefix (sortBy, filters, searchTerm)
+// - Controlled patterns (value + onChange, checked + onChange)`
                     });
                     break;
                 case 'no-use-reducer':
@@ -862,6 +924,40 @@ const sortedData = useMemo(() => {
 }, [data, sortBy, sortDirection]);`
                     });
                     break;
+                case 'runview-runquery-valid-properties':
+                    suggestions.push({
+                        violation: violation.rule,
+                        suggestion: 'Use only valid properties for RunView/RunViews and RunQuery',
+                        example: `// ❌ WRONG - Invalid properties on RunView:
+await utilities.rv.RunView({
+  EntityName: 'MJ: AI Prompt Runs',
+  Parameters: { startDate, endDate },  // INVALID!
+  GroupBy: 'Status'                    // INVALID!
+});
+
+// ✅ CORRECT - Use ExtraFilter for WHERE clauses:
+await utilities.rv.RunView({
+  EntityName: 'MJ: AI Prompt Runs',
+  ExtraFilter: \`RunAt >= '\${startDate.toISOString()}' AND RunAt <= '\${endDate.toISOString()}'\`,
+  OrderBy: 'RunAt DESC',
+  Fields: ['RunAt', 'Status', 'Success']
+});
+
+// ✅ For aggregations, use RunQuery with a pre-defined query:
+await utilities.rq.RunQuery({
+  QueryName: 'Prompt Run Summary',
+  Parameters: { startDate, endDate }  // Parameters ARE valid for RunQuery
+});
+
+// Valid RunView properties:
+// - EntityName (required)
+// - ExtraFilter, OrderBy, Fields, MaxRows, StartRow, ResultType (optional)
+
+// Valid RunQuery properties:
+// - QueryName (required)
+// - CategoryName, CategoryID, Parameters (optional)`
+                    });
+                    break;
                 case 'root-component-props-restriction':
                     suggestions.push({
                         violation: violation.rule,
@@ -913,11 +1009,11 @@ ComponentLinter.universalComponentRules = [
         appliesTo: 'all',
         test: (ast, componentName) => {
             const violations = [];
-            let hasStateFromProps = false;
-            let hasSavedUserSettings = false;
-            let usesUseState = false;
-            const stateProps = [];
-            // First pass: check if component expects state from props and uses useState
+            const controlledStateProps = [];
+            const initializationProps = [];
+            const eventHandlers = [];
+            const acceptedProps = new Map();
+            // First pass: collect all props
             (0, traverse_1.default)(ast, {
                 FunctionDeclaration(path) {
                     if (path.node.id && path.node.id.name === componentName && path.node.params[0]) {
@@ -926,14 +1022,13 @@ ComponentLinter.universalComponentRules = [
                             for (const prop of param.properties) {
                                 if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
                                     const propName = prop.key.name;
-                                    // Check for state-like props
-                                    const statePatterns = ['selectedId', 'selectedItemId', 'filters', 'sortBy', 'sortField', 'currentPage', 'activeTab'];
-                                    if (statePatterns.some(pattern => propName.includes(pattern))) {
-                                        hasStateFromProps = true;
-                                        stateProps.push(propName);
-                                    }
-                                    if (propName === 'savedUserSettings') {
-                                        hasSavedUserSettings = true;
+                                    acceptedProps.set(propName, {
+                                        line: prop.loc?.start.line || 0,
+                                        column: prop.loc?.start.column || 0
+                                    });
+                                    // Categorize props
+                                    if (/^on[A-Z]/.test(propName) && propName !== 'onSaveUserSettings') {
+                                        eventHandlers.push(propName);
                                     }
                                 }
                             }
@@ -950,42 +1045,119 @@ ComponentLinter.universalComponentRules = [
                                 for (const prop of param.properties) {
                                     if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
                                         const propName = prop.key.name;
-                                        const statePatterns = ['selectedId', 'selectedItemId', 'filters', 'sortBy', 'sortField', 'currentPage', 'activeTab'];
-                                        if (statePatterns.some(pattern => propName.includes(pattern))) {
-                                            hasStateFromProps = true;
-                                            stateProps.push(propName);
-                                        }
-                                        if (propName === 'savedUserSettings') {
-                                            hasSavedUserSettings = true;
+                                        acceptedProps.set(propName, {
+                                            line: prop.loc?.start.line || 0,
+                                            column: prop.loc?.start.column || 0
+                                        });
+                                        // Categorize props
+                                        if (/^on[A-Z]/.test(propName) && propName !== 'onSaveUserSettings') {
+                                            eventHandlers.push(propName);
                                         }
                                     }
                                 }
                             }
                         }
                     }
-                },
-                // Check for useState usage
-                CallExpression(path) {
-                    const callee = path.node.callee;
-                    if ((t.isIdentifier(callee) && callee.name === 'useState') ||
-                        (t.isMemberExpression(callee) &&
-                            t.isIdentifier(callee.object) && callee.object.name === 'React' &&
-                            t.isIdentifier(callee.property) && callee.property.name === 'useState')) {
-                        usesUseState = true;
-                    }
                 }
             });
-            // CRITICAL: Components must manage ALL their own state
-            // State props are NOT allowed - each component is generated separately
-            if (hasStateFromProps) {
+            // Analyze props for controlled component patterns
+            const controlledPatterns = [
+                { stateProp: 'value', handler: 'onChange' },
+                { stateProp: 'checked', handler: 'onChange' },
+                { stateProp: 'selectedId', handler: 'onSelect' },
+                { stateProp: 'selectedIds', handler: 'onSelectionChange' },
+                { stateProp: 'selectedItems', handler: 'onSelectionChange' },
+                { stateProp: 'activeTab', handler: 'onTabChange' },
+                { stateProp: 'currentPage', handler: 'onPageChange' },
+                { stateProp: 'expanded', handler: 'onExpand' },
+                { stateProp: 'collapsed', handler: 'onCollapse' },
+                { stateProp: 'open', handler: 'onOpenChange' },
+                { stateProp: 'visible', handler: 'onVisibilityChange' }
+            ];
+            // Check each accepted prop
+            for (const [propName, location] of acceptedProps) {
+                // Skip standard props
+                if (['utilities', 'styles', 'components', 'callbacks', 'savedUserSettings', 'onSaveUserSettings'].includes(propName)) {
+                    continue;
+                }
+                // Skip data props (arrays, objects that are clearly data)
+                if (propName.endsWith('Data') || propName === 'items' || propName === 'options' ||
+                    propName === 'rows' || propName === 'columns' || propName === 'records') {
+                    continue;
+                }
+                // Check if it's an initialization prop (allowed)
+                if (propName.startsWith('initial') || propName.startsWith('default')) {
+                    initializationProps.push(propName);
+                    continue;
+                }
+                // Check if it's a configuration prop (allowed)
+                // Be generous - configuration props are those that configure behavior, not manage state
+                if (propName.endsWith('Config') || propName.endsWith('Settings') || propName.endsWith('Options') ||
+                    propName === 'pageSize' || propName === 'maxItems' || propName === 'minValue' || propName === 'maxValue' ||
+                    propName === 'placeholder' || propName === 'label' || propName === 'title' || propName === 'disabled' ||
+                    propName === 'readonly' || propName === 'required' || propName === 'className' || propName === 'style' ||
+                    // Sort/filter configuration when not paired with state management handlers
+                    ((propName.includes('sort') || propName.includes('Sort') ||
+                        propName.includes('filter') || propName.includes('Filter') ||
+                        propName === 'orderBy' || propName === 'groupBy') &&
+                        !acceptedProps.has('onSortChange') && !acceptedProps.has('onFilterChange') &&
+                        !acceptedProps.has('onChange'))) {
+                    continue;
+                }
+                // Check for controlled component pattern (both state prop and handler present)
+                let isControlled = false;
+                for (const pattern of controlledPatterns) {
+                    if (propName === pattern.stateProp) {
+                        // Check if the corresponding handler exists
+                        if (acceptedProps.has(pattern.handler) || eventHandlers.includes(pattern.handler)) {
+                            controlledStateProps.push(propName);
+                            isControlled = true;
+                            break;
+                        }
+                        // If state prop exists without handler, it's still problematic
+                        // unless it's clearly for initialization
+                        if (!propName.startsWith('initial') && !propName.startsWith('default')) {
+                            controlledStateProps.push(propName);
+                            isControlled = true;
+                            break;
+                        }
+                    }
+                }
+                // Check for state-like props that aren't initialization
+                if (!isControlled) {
+                    const statePatterns = [
+                        'selectedId', 'selectedItemId', 'selectedItem', 'selection',
+                        'filters', 'sortBy', 'sortField', 'sortDirection', 'orderBy',
+                        'currentPage', 'pageNumber', 'page',
+                        'activeTab', 'activeIndex', 'activeKey',
+                        'expandedItems', 'collapsedItems',
+                        'searchTerm', 'searchQuery', 'query',
+                        'formData', 'formValues', 'values'
+                    ];
+                    for (const pattern of statePatterns) {
+                        if (propName === pattern || propName.toLowerCase() === pattern.toLowerCase()) {
+                            // This is a state prop without proper initialization naming
+                            controlledStateProps.push(propName);
+                            break;
+                        }
+                    }
+                }
+            }
+            // Generate violations for controlled state props
+            if (controlledStateProps.length > 0) {
                 violations.push({
                     rule: 'full-state-ownership',
-                    severity: 'error',
+                    severity: 'critical', // This is critical as it breaks the architecture
                     line: 1,
                     column: 0,
-                    message: `Component "${componentName}" expects state from props (${stateProps.join(', ')}) instead of managing internally. Each component is generated separately and MUST manage ALL its own state.`
+                    message: `Component "${componentName}" accepts controlled state props (${controlledStateProps.join(', ')}) instead of managing state internally. Use 'initial*' or 'default*' prefixes for initialization props (e.g., 'initialPage' instead of 'currentPage'). Each component must manage ALL its own state.`
                 });
             }
+            // Add warning for initialization props (informational)
+            if (initializationProps.length > 0 && violations.length === 0) {
+                // This is actually OK, but we can log it for awareness
+                // Don't create a violation, just note it's using the correct pattern
+            }
             return violations;
         }
     },
@@ -1003,7 +1175,7 @@ ComponentLinter.universalComponentRules = [
                             t.isIdentifier(callee.property) && callee.property.name === 'useReducer')) {
                         violations.push({
                             rule: 'no-use-reducer',
-                            severity: 'error',
+                            severity: 'high', // High but not critical - it's a pattern violation
                             line: path.node.loc?.start.line || 0,
                             column: path.node.loc?.start.column || 0,
                             message: `Component "${componentName}" uses useReducer at line ${path.node.loc?.start.line}. Components should manage state with useState and persist important settings with onSaveUserSettings.`,
@@ -1031,7 +1203,7 @@ ComponentLinter.universalComponentRules = [
                                 if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'data') {
                                     violations.push({
                                         rule: 'no-data-prop',
-                                        severity: 'error',
+                                        severity: 'medium', // It's a pattern issue, not critical
                                         line: prop.loc?.start.line || 0,
                                         column: prop.loc?.start.column || 0,
                                         message: `Component "${componentName}" accepts generic 'data' prop. Use specific props like 'items', 'customers', etc. instead.`,
@@ -1053,7 +1225,7 @@ ComponentLinter.universalComponentRules = [
                                     if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'data') {
                                         violations.push({
                                             rule: 'no-data-prop',
-                                            severity: 'error',
+                                            severity: 'critical',
                                             line: prop.loc?.start.line || 0,
                                             column: prop.loc?.start.column || 0,
                                             message: `Component "${componentName}" accepts generic 'data' prop. Use specific props like 'items', 'customers', etc. instead.`,
@@ -1092,7 +1264,7 @@ ComponentLinter.universalComponentRules = [
                                         if (ephemeralPatterns.some(pattern => key.toLowerCase().includes(pattern))) {
                                             violations.push({
                                                 rule: 'saved-user-settings-pattern',
-                                                severity: 'warning',
+                                                severity: 'medium', // Pattern issue but not breaking
                                                 line: prop.loc?.start.line || 0,
                                                 column: prop.loc?.start.column || 0,
                                                 message: `Saving ephemeral UI state "${key}" to savedUserSettings. Only save important user preferences.`
@@ -1133,7 +1305,7 @@ ComponentLinter.universalComponentRules = [
                             // Only report if some props are passed (to avoid false positives on non-component JSX)
                             violations.push({
                                 rule: 'pass-standard-props',
-                                severity: 'error',
+                                severity: 'critical',
                                 line: openingElement.loc?.start.line || 0,
                                 column: openingElement.loc?.start.column || 0,
                                 message: `Component "${componentBeingCalled}" is missing required props: ${missingProps.join(', ')}. All components must receive styles, utilities, and components props.`,
@@ -1167,7 +1339,7 @@ ComponentLinter.universalComponentRules = [
             if (componentFunctions.length > 0) {
                 violations.push({
                     rule: 'no-child-implementation',
-                    severity: 'error',
+                    severity: 'critical',
                     line: 1,
                     column: 0,
                     message: `Root component file contains child component implementations: ${componentFunctions.join(', ')}. Root should only reference child components, not implement them.`,
@@ -1239,7 +1411,7 @@ ComponentLinter.universalComponentRules = [
                 if (unusedComponents.length > 0) {
                     violations.push({
                         rule: 'undefined-component-usage',
-                        severity: 'warning',
+                        severity: 'low',
                         line: 1,
                         column: 0,
                         message: `Component destructures ${unusedComponents.join(', ')} from components prop but never uses them. These may be missing from the component spec's dependencies array.`
@@ -1267,7 +1439,7 @@ ComponentLinter.universalComponentRules = [
                             if (/\[\d+\]\.\w+/.test(code)) {
                                 violations.push({
                                     rule: 'unsafe-array-access',
-                                    severity: 'error',
+                                    severity: 'critical',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
                                     message: `Unsafe array access: ${code}. Check array bounds before accessing elements.`,
@@ -1300,7 +1472,7 @@ ComponentLinter.universalComponentRules = [
                         if (!hasInitialValue) {
                             violations.push({
                                 rule: 'array-reduce-safety',
-                                severity: 'warning',
+                                severity: 'low',
                                 line: path.node.loc?.start.line || 0,
                                 column: path.node.loc?.start.column || 0,
                                 message: `reduce() without initial value may fail on empty arrays: ${code}`,
@@ -1313,7 +1485,7 @@ ComponentLinter.universalComponentRules = [
                                 (t.isIdentifier(arrayExpression.property) && arrayExpression.computed))) {
                             violations.push({
                                 rule: 'array-reduce-safety',
-                                severity: 'error',
+                                severity: 'critical',
                                 line: path.node.loc?.start.line || 0,
                                 column: path.node.loc?.start.column || 0,
                                 message: `reduce() on array element access is unsafe: ${code}`,
@@ -1448,7 +1620,7 @@ ComponentLinter.universalComponentRules = [
                     if (relatedHandlers.length > 0) {
                         violations.push({
                             rule: 'parent-event-callback-usage',
-                            severity: 'error',
+                            severity: 'critical',
                             line: location.line,
                             column: location.column,
                             message: `Component receives '${callbackName}' event callback but never invokes it. Found state updates in ${relatedHandlers.join(', ')} but parent is not notified.`,
@@ -1565,7 +1737,7 @@ ComponentLinter.universalComponentRules = [
                                 const transformedName = Array.from(transformation.transformedProps).find(t => t.toLowerCase() === accessedProp.toLowerCase());
                                 violations.push({
                                     rule: 'property-name-consistency',
-                                    severity: 'error',
+                                    severity: 'critical',
                                     line: transformation.location.line,
                                     column: transformation.location.column,
                                     message: `Property name mismatch: data transformed with different casing. Accessing '${accessedProp}' but property was transformed to '${transformedName || 'different name'}'`,
@@ -1603,7 +1775,7 @@ ComponentLinter.universalComponentRules = [
                                     if (!hasDebounce && !hasTimeout) {
                                         violations.push({
                                             rule: 'noisy-settings-updates',
-                                            severity: 'error',
+                                            severity: 'critical',
                                             line: path.node.loc?.start.line || 0,
                                             column: path.node.loc?.start.column || 0,
                                             message: `Saving settings on every change/keystroke. Save on blur, submit, or after debouncing.`
@@ -1639,7 +1811,7 @@ ComponentLinter.universalComponentRules = [
                             if (hasSetState && hasPropDeps && !bodyString.includes('async')) {
                                 violations.push({
                                     rule: 'prop-state-sync',
-                                    severity: 'error',
+                                    severity: 'critical',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
                                     message: 'Syncing props to internal state with useEffect creates dual state management',
@@ -1693,7 +1865,7 @@ ComponentLinter.universalComponentRules = [
                                         if (!funcName || funcName === componentName) {
                                             violations.push({
                                                 rule: 'performance-memoization',
-                                                severity: 'warning',
+                                                severity: 'low', // Just a suggestion, not mandatory
                                                 line: path.node.loc?.start.line || 0,
                                                 column: path.node.loc?.start.column || 0,
                                                 message: `Expensive ${method} operation without memoization. Consider using useMemo.`,
@@ -1717,7 +1889,7 @@ ComponentLinter.universalComponentRules = [
                             if (!hasVariables || hasVariables.length < 3) { // Allow some property names
                                 violations.push({
                                     rule: 'performance-memoization',
-                                    severity: 'warning',
+                                    severity: 'low', // Just a suggestion
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
                                     message: 'Static array/object recreated on every render. Consider using useMemo.',
@@ -1755,7 +1927,7 @@ ComponentLinter.universalComponentRules = [
                                 if (childPatterns.some(pattern => pattern.test(stateName))) {
                                     violations.push({
                                         rule: 'child-state-management',
-                                        severity: 'error',
+                                        severity: 'critical',
                                         line: path.node.loc?.start.line || 0,
                                         column: path.node.loc?.start.column || 0,
                                         message: `Component trying to manage child component state: ${stateName}. Child components manage their own state!`,
@@ -1790,7 +1962,7 @@ ComponentLinter.universalComponentRules = [
                                     funcName.includes('handleSort') || funcName.includes('handleFilter'))) {
                                 violations.push({
                                     rule: 'server-reload-on-client-operation',
-                                    severity: 'error',
+                                    severity: 'critical',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
                                     message: 'Reloading data from server on sort/filter. Use useMemo for client-side operations.',
@@ -1804,6 +1976,130 @@ ComponentLinter.universalComponentRules = [
             return violations;
         }
     },
+    {
+        name: 'runview-runquery-valid-properties',
+        appliesTo: 'all',
+        test: (ast, componentName) => {
+            const violations = [];
+            // Valid properties for RunView/RunViews
+            const validRunViewProps = new Set([
+                'EntityName', 'ExtraFilter', 'OrderBy', 'Fields',
+                'MaxRows', 'StartRow', 'ResultType'
+            ]);
+            // Valid properties for RunQuery
+            const validRunQueryProps = new Set([
+                'QueryName', 'CategoryName', 'CategoryID', 'Parameters'
+            ]);
+            (0, traverse_1.default)(ast, {
+                CallExpression(path) {
+                    const callee = path.node.callee;
+                    // Check for utilities.rv.RunView or utilities.rv.RunViews
+                    if (t.isMemberExpression(callee) &&
+                        t.isMemberExpression(callee.object) &&
+                        t.isIdentifier(callee.object.object) &&
+                        callee.object.object.name === 'utilities' &&
+                        t.isIdentifier(callee.object.property) &&
+                        callee.object.property.name === 'rv' &&
+                        t.isIdentifier(callee.property)) {
+                        const methodName = callee.property.name;
+                        if (methodName === 'RunView' || methodName === 'RunViews') {
+                            // Get the config object(s)
+                            let configs = [];
+                            if (methodName === 'RunViews' && path.node.arguments[0]) {
+                                // RunViews takes an array of configs
+                                if (t.isArrayExpression(path.node.arguments[0])) {
+                                    configs = path.node.arguments[0].elements
+                                        .filter((e) => t.isObjectExpression(e));
+                                }
+                            }
+                            else if (methodName === 'RunView' && path.node.arguments[0]) {
+                                // RunView takes a single config
+                                if (t.isObjectExpression(path.node.arguments[0])) {
+                                    configs = [path.node.arguments[0]];
+                                }
+                            }
+                            // Check each config for invalid properties
+                            for (const config of configs) {
+                                for (const prop of config.properties) {
+                                    if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                                        const propName = prop.key.name;
+                                        if (!validRunViewProps.has(propName)) {
+                                            // Special error messages for common mistakes
+                                            let message = `Invalid property '${propName}' on ${methodName}. Valid properties: ${Array.from(validRunViewProps).join(', ')}`;
+                                            let fix = `Remove '${propName}' property`;
+                                            if (propName === 'Parameters') {
+                                                message = `${methodName} does not support 'Parameters'. Use 'ExtraFilter' for WHERE clauses.`;
+                                                fix = `Replace 'Parameters' with 'ExtraFilter' and format as SQL WHERE clause`;
+                                            }
+                                            else if (propName === 'GroupBy') {
+                                                message = `${methodName} does not support 'GroupBy'. Use RunQuery with a pre-defined query for aggregations.`;
+                                                fix = `Remove 'GroupBy' and use RunQuery instead for aggregated data`;
+                                            }
+                                            else if (propName === 'Having') {
+                                                message = `${methodName} does not support 'Having'. Use RunQuery with a pre-defined query.`;
+                                                fix = `Remove 'Having' and use RunQuery instead`;
+                                            }
+                                            violations.push({
+                                                rule: 'runview-runquery-valid-properties',
+                                                severity: 'critical',
+                                                line: prop.loc?.start.line || 0,
+                                                column: prop.loc?.start.column || 0,
+                                                message,
+                                                code: `${propName}: ...`
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Check for utilities.rq.RunQuery
+                    if (t.isMemberExpression(callee) &&
+                        t.isMemberExpression(callee.object) &&
+                        t.isIdentifier(callee.object.object) &&
+                        callee.object.object.name === 'utilities' &&
+                        t.isIdentifier(callee.object.property) &&
+                        callee.object.property.name === 'rq' &&
+                        t.isIdentifier(callee.property) &&
+                        callee.property.name === 'RunQuery') {
+                        if (path.node.arguments[0] && t.isObjectExpression(path.node.arguments[0])) {
+                            const config = path.node.arguments[0];
+                            for (const prop of config.properties) {
+                                if (t.isObjectProperty(prop) && t.isIdentifier(prop.key)) {
+                                    const propName = prop.key.name;
+                                    if (!validRunQueryProps.has(propName)) {
+                                        let message = `Invalid property '${propName}' on RunQuery. Valid properties: ${Array.from(validRunQueryProps).join(', ')}`;
+                                        let fix = `Remove '${propName}' property`;
+                                        if (propName === 'ExtraFilter') {
+                                            message = `RunQuery does not support 'ExtraFilter'. WHERE clauses should be in the pre-defined query or passed as Parameters.`;
+                                            fix = `Remove 'ExtraFilter'. Add WHERE logic to the query definition or pass as Parameters`;
+                                        }
+                                        else if (propName === 'Fields') {
+                                            message = `RunQuery does not support 'Fields'. The query definition determines returned fields.`;
+                                            fix = `Remove 'Fields'. Modify the query definition to return desired fields`;
+                                        }
+                                        else if (propName === 'OrderBy') {
+                                            message = `RunQuery does not support 'OrderBy'. ORDER BY should be in the query definition.`;
+                                            fix = `Remove 'OrderBy'. Add ORDER BY to the query definition`;
+                                        }
+                                        violations.push({
+                                            rule: 'runview-runquery-valid-properties',
+                                            severity: 'critical',
+                                            line: prop.loc?.start.line || 0,
+                                            column: prop.loc?.start.column || 0,
+                                            message,
+                                            code: `${propName}: ...`
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            });
+            return violations;
+        }
+    },
     {
         name: 'root-component-props-restriction',
         appliesTo: 'root',
@@ -1834,7 +2130,7 @@ ComponentLinter.universalComponentRules = [
                             if (invalidProps.length > 0) {
                                 violations.push({
                                     rule: 'root-component-props-restriction',
-                                    severity: 'error',
+                                    severity: 'critical',
                                     line: path.node.loc?.start.line || 0,
                                     column: path.node.loc?.start.column || 0,
                                     message: `Component "${componentName}" accepts non-standard props: ${invalidProps.join(', ')}. Root components can only accept standard props: ${Array.from(standardProps).join(', ')}. Load data internally using utilities.rv.RunView().`
@@ -1864,7 +2160,7 @@ ComponentLinter.universalComponentRules = [
                                 if (invalidProps.length > 0) {
                                     violations.push({
                                         rule: 'root-component-props-restriction',
-                                        severity: 'error',
+                                        severity: 'critical',
                                         line: path.node.loc?.start.line || 0,
                                         column: path.node.loc?.start.column || 0,
                                         message: `Component "${componentName}" accepts non-standard props: ${invalidProps.join(', ')}. Root components can only accept standard props: ${Array.from(standardProps).join(', ')}. Load data internally using utilities.rv.RunView().`