pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSForbiddenLiteralsAnalyzer.js

@@ -0,0 +1,261 @@
+const { SyntaxKind } = require('../../ast-core');
+
+const FORBIDDEN_STRING_LITERALS = [
+    'unknown',
+    'null',
+    'undefined',
+    'any',
+    'void',
+    'never',
+];
+
+const FORBIDDEN_STATUS_LITERALS = [
+    'active',
+    'inactive',
+    'pending',
+    'completed',
+    'failed',
+    'success',
+    'error',
+];
+
+const MAGIC_NUMBERS = [0, 1];
+
+class iOSForbiddenLiteralsAnalyzer {
+    analyze(sf, findings, pushFinding) {
+        if (!sf || typeof sf.getFilePath !== 'function') {
+            return;
+        }
+        const stringLiterals = sf.getDescendantsOfKind(SyntaxKind.StringLiteral);
+        const numericLiterals = sf.getDescendantsOfKind(SyntaxKind.NumericLiteral);
+        const asExpressions = sf.getDescendantsOfKind(SyntaxKind.AsExpression);
+        const nullishCoalescing = sf.getDescendantsOfKind(SyntaxKind.NullishCoalescingExpression);
+        const conditionalExpressions = sf.getDescendantsOfKind(SyntaxKind.ConditionalExpression);
+        const objectLiteralExpressions = sf.getDescendantsOfKind(SyntaxKind.ObjectLiteralExpression);
+
+        this.analyzeStringLiterals(stringLiterals, sf, findings, pushFinding);
+        this.analyzeNumericLiterals(numericLiterals, sf, findings, pushFinding);
+        this.analyzeTypeCasts(asExpressions, sf, findings, pushFinding);
+        this.analyzeNullishCoalescing(nullishCoalescing, sf, findings, pushFinding);
+        this.analyzeConditionalExpressions(conditionalExpressions, sf, findings, pushFinding);
+        this.analyzeObjectLiterals(objectLiteralExpressions, sf, findings, pushFinding);
+    }
+
+    analyzeStringLiterals(stringLiterals, sf, findings, pushFinding) {
+        stringLiterals.forEach((literal) => {
+            const value = literal.getLiteralValue();
+            const parent = literal.getParent();
+
+            if (!parent) return;
+
+            const isInTypeDefinition = parent.getKind && (
+                parent.getKind() === SyntaxKind.UnionType ||
+                parent.getKind() === SyntaxKind.TypeLiteral ||
+                parent.getKind() === SyntaxKind.PropertySignature
+            );
+
+            if (isInTypeDefinition) return;
+
+            const isInImport = parent.getKind && (
+                parent.getKind() === SyntaxKind.ImportDeclaration ||
+                parent.getKind() === SyntaxKind.ImportSpecifier
+            );
+
+            if (isInImport) return;
+
+            const isInComment = parent.getKind && parent.getKind() === SyntaxKind.JSDocComment;
+            if (isInComment) return;
+
+            const fullText = sf.getFullText();
+            const literalText = literal.getText();
+            const literalIndex = literal.getStart();
+            const lineStart = fullText.lastIndexOf('\n', literalIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', literalIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInStringTemplate = /`[^`]*${literalText}[^`]*`/.test(fullLine);
+            const isInConsoleLog = /console\.(log|error|warn|info)/i.test(fullLine);
+            const isInTestFile = /\.(spec|test)\.(swift)$/i.test(sf.getFilePath());
+
+            if (isInStringTemplate || isInConsoleLog || isInTestFile) return;
+
+            if (FORBIDDEN_STRING_LITERALS.includes(value)) {
+                pushFinding(
+                    'ios.types.forbidden_literal',
+                    'critical',
+                    literal,
+                    sf,
+                    `Forbidden string literal '${value}' detected. Use enums, constants, or type-safe alternatives instead of magic strings.`,
+                    findings
+                );
+            }
+
+            const isStatusContext = /status|state|role|type|kind|category/i.test(fullLine) &&
+                !/enum|const|type|interface|Record<.*Status/i.test(fullLine);
+
+            if (isStatusContext && FORBIDDEN_STATUS_LITERALS.includes(value)) {
+                pushFinding(
+                    'ios.types.forbidden_status_literal',
+                    'high',
+                    literal,
+                    sf,
+                    `Forbidden status literal '${value}' detected. Use enums or constants instead of string literals for status/state values.`,
+                    findings
+                );
+            }
+        });
+    }
+
+    analyzeNumericLiterals(numericLiterals, sf, findings, pushFinding) {
+        numericLiterals.forEach((literal) => {
+            const value = parseFloat(literal.getText());
+            const parent = literal.getParent();
+
+            if (!parent) return;
+
+            const isInTypeDefinition = parent.getKind && (
+                parent.getKind() === SyntaxKind.UnionType ||
+                parent.getKind() === SyntaxKind.TypeLiteral ||
+                parent.getKind() === SyntaxKind.PropertySignature
+            );
+
+            if (isInTypeDefinition) return;
+
+            const fullText = sf.getFullText();
+            const literalIndex = literal.getStart();
+            const lineStart = fullText.lastIndexOf('\n', literalIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', literalIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInArrayIndex = /\[\s*\d+\s*\]/.test(fullLine);
+            const isInTestFile = /\.(spec|test)\.(swift)$/i.test(sf.getFilePath());
+            const isInEnumValue = /=\s*\d+/.test(fullLine) && /enum/.test(fullText.substring(0, literalIndex));
+
+            if (isInArrayIndex || isInTestFile || isInEnumValue) return;
+
+            if (MAGIC_NUMBERS.includes(value) && !isInEnumValue) {
+                const context = fullLine.trim();
+                const isIncrement = /\+\+\s*$|=\s*\w+\s*\+\s*1|=\s*\w+\s*\+\s*\d+\s*\+/.test(context);
+                const isInitialization = /=\s*0\s*[,;]/.test(context);
+
+                if (isIncrement || isInitialization) {
+                    pushFinding(
+                        'ios.types.magic_number',
+                        'high',
+                        literal,
+                        sf,
+                        `Magic number ${value} detected. Use named constants (e.g., INITIAL_COUNT, INCREMENT_VALUE) instead of magic numbers.`,
+                        findings
+                    );
+                }
+            }
+        });
+    }
+
+    analyzeTypeCasts(asExpressions, sf, findings, pushFinding) {
+        if (!sf || typeof sf.getFilePath !== 'function') return;
+        asExpressions.forEach((expr) => {
+            const fullText = sf.getFullText();
+            const exprIndex = expr.getStart();
+            const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', exprIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(swift)$/i.test(sf.getFilePath());
+            const isTypeAssertion = /as\s+(UserRole|OrderStatus|UserStatus|AlertStatus)/i.test(fullLine);
+
+            if (isInTestFile || isTypeAssertion) return;
+
+            pushFinding(
+                'ios.types.forbidden_type_cast',
+                'high',
+                sf,
+                expr,
+                `Type casting with 'as' detected. Use type guards, mappers, or proper type narrowing instead of type assertions.`,
+                findings
+            );
+        });
+    }
+
+    analyzeNullishCoalescing(nullishCoalescing, sf, findings, pushFinding) {
+        nullishCoalescing.forEach((expr) => {
+            const fullText = sf.getFullText();
+            const exprIndex = expr.getStart();
+            const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', exprIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(swift)$/i.test(sf.getFilePath());
+            const hasNull = /nil/.test(fullLine);
+            const hasUndefined = /undefined/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNull || hasUndefined) {
+                pushFinding(
+                    'ios.types.forbidden_nullish_coalescing',
+                    'critical',
+                    expr,
+                    sf,
+                    `Nullish coalescing with nil/undefined detected. Use optional properties (name: String?) instead of force unwrapping. Eliminate nil/undefined from codebase.`,
+                    findings
+                );
+            }
+        });
+    }
+
+    analyzeConditionalExpressions(conditionalExpressions, sf, findings, pushFinding) {
+        conditionalExpressions.forEach((expr) => {
+            const fullText = sf.getFullText();
+            const exprIndex = expr.getStart();
+            const lineStart = fullText.lastIndexOf('\n', exprIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', exprIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(swift)$/i.test(sf.getFilePath());
+            const hasNull = /\?\s*nil\s*:/.test(fullLine);
+            const hasUndefined = /\?\s*undefined\s*:/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNull || hasUndefined) {
+                pushFinding(
+                    'ios.types.forbidden_ternary_null_undefined',
+                    'critical',
+                    expr,
+                    sf,
+                    `Ternary operator with nil detected. Use optional properties (prop: String?) and conditional initialization. Only include properties when they have values. Use struct initializers with optional parameters.`,
+                    findings
+                );
+            }
+        });
+    }
+
+    analyzeObjectLiterals(objectLiteralExpressions, sf, findings, pushFinding) {
+        objectLiteralExpressions.forEach((obj) => {
+            const fullText = sf.getFullText();
+            const objIndex = obj.getStart();
+            const lineStart = fullText.lastIndexOf('\n', objIndex) + 1;
+            const lineEnd = fullText.indexOf('\n', objIndex);
+            const fullLine = fullText.substring(lineStart, lineEnd === -1 ? undefined : lineEnd);
+
+            const isInTestFile = /\.(spec|test)\.(swift)$/i.test(sf.getFilePath());
+            const hasNilAssignment = /:\s*nil/.test(fullLine);
+
+            if (isInTestFile) return;
+
+            if (hasNilAssignment) {
+                pushFinding(
+                    'ios.types.forbidden_nil_assignment',
+                    'critical',
+                    obj,
+                    sf,
+                    `Direct nil assignment in object detected. Use optional properties and conditional initialization. Only include properties when they have values. Use struct initializers with optional parameters (prop: String?).`,
+                    findings
+                );
+            }
+        });
+    }
+}
+
+module.exports = { iOSForbiddenLiteralsAnalyzer };

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSNetworkingAdvancedRules.js

@@ -0,0 +1,177 @@
+/**
+ * iOS Networking Advanced Rules
+ * - GraphQL specific rules
+ * - WebSocket handling
+ * - Offline queue management
+ * - Network layer architecture
+ */
+
+const { pushFinding } = require('../../ast-core');
+const fs = require('fs');
+const glob = require('glob');
+
+class iOSNetworkingAdvancedRules {
+  constructor(findings, projectRoot) {
+    this.findings = findings;
+    this.projectRoot = projectRoot;
+  }
+
+  analyze() {
+    const swiftFiles = glob.sync('**/*.swift', {
+      cwd: this.projectRoot,
+      ignore: ['**/Pods/**', '**/Build/**', '**/.build/**'],
+      absolute: true
+    });
+
+    swiftFiles.forEach(file => {
+      const content = fs.readFileSync(file, 'utf-8');
+
+      this.checkGraphQLImplementation(file, content);
+      this.checkWebSocketHandling(file, content);
+      this.checkOfflineQueueManagement(file, content);
+      this.checkNetworkLayerArchitecture(file, content);
+      this.checkRetryMechanism(file, content);
+      this.checkCaching(file, content);
+      this.checkErrorRecovery(file, content);
+    });
+  }
+
+  checkGraphQLImplementation(file, content) {
+    const hasGraphQL = content.includes('GraphQL') || content.includes('Apollo');
+
+    if (hasGraphQL) {
+      if (!content.includes('query') && !content.includes('mutation')) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.networking.graphql_without_operations',
+          severity: 'medium',
+          message: 'GraphQL client sin queries/mutations definidas.',
+          filePath: file,
+          line: 1
+        });
+      }
+
+      if (content.includes('GraphQL') && !content.includes('cache')) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.networking.graphql_missing_cache',
+          severity: 'medium',
+          message: 'GraphQL sin configuración de cache. Implementar para mejor performance.',
+          filePath: file,
+          line: 1
+        });
+      }
+    }
+  }
+
+  checkWebSocketHandling(file, content) {
+    const hasWebSocket = content.includes('WebSocket') || content.includes('URLSessionWebSocketTask');
+
+    if (hasWebSocket) {
+      if (!content.includes('reconnect')) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.networking.websocket_no_reconnect',
+          severity: 'high',
+          message: 'WebSocket sin lógica de reconnect. Implementar para resiliencia.',
+          filePath: file,
+          line: 1,
+          suggestion: 'Implementar exponential backoff para reconnect automático'
+        });
+      }
+
+      if (!content.includes('ping') && !content.includes('heartbeat')) {
+        pushFinding(this.findings, {
+          ruleId: 'ios.networking.websocket_no_heartbeat',
+          severity: 'medium',
+          message: 'WebSocket sin heartbeat/ping. Conexión puede morir silenciosamente.',
+          filePath: file,
+          line: 1
+        });
+      }
+    }
+  }
+
+  checkOfflineQueueManagement(file, content) {
+    const hasNetworking = content.includes('URLSession') || content.includes('Alamofire');
+    const hasOfflineQueue = content.includes('OfflineQueue') || content.includes('PendingRequests');
+
+    if (hasNetworking && content.includes('POST') && !hasOfflineQueue) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.networking.missing_offline_queue',
+        severity: 'low',
+        message: 'POST requests sin offline queue. Considerar queue para operaciones críticas.',
+        filePath: file,
+        line: 1,
+        suggestion: 'Implementar queue para almacenar requests fallidos y retry cuando vuelva conexión'
+      });
+    }
+  }
+
+  checkNetworkLayerArchitecture(file, content) {
+    const hasURLSession = content.includes('URLSession');
+
+    if (hasURLSession && !file.includes('Network') && !file.includes('API') && !file.includes('Service')) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.networking.network_logic_scattered',
+        severity: 'medium',
+        message: 'Lógica de networking fuera de capa Network/API/Service. Centralizar.',
+        filePath: file,
+        line: 1,
+        suggestion: 'Crear NetworkService o APIClient para encapsular toda la lógica de red'
+      });
+    }
+  }
+
+  checkRetryMechanism(file, content) {
+    const hasNetworking = content.includes('URLSession');
+    const hasRetry = content.includes('retry') || content.includes('maxRetries');
+
+    if (hasNetworking && !hasRetry) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.networking.missing_retry_mechanism',
+        severity: 'medium',
+        message: 'Networking sin retry mechanism. Implementar para resiliencia.',
+        filePath: file,
+        line: 1
+      });
+    }
+  }
+
+  checkCaching(file, content) {
+    const hasNetworking = content.includes('URLSession');
+    const hasCache = content.includes('URLCache') || content.includes('NSCache');
+
+    if (hasNetworking && !hasCache && file.includes('Service')) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.networking.missing_response_cache',
+        severity: 'low',
+        message: 'Network service sin caching. Implementar URLCache para reducir requests.',
+        filePath: file,
+        line: 1
+      });
+    }
+  }
+
+  checkErrorRecovery(file, content) {
+    const hasNetworking = content.includes('URLSession');
+    const hasErrorHandling = content.includes('catch') || content.includes('Result<');
+
+    if (hasNetworking && !hasErrorHandling) {
+      pushFinding(this.findings, {
+        ruleId: 'ios.networking.missing_error_recovery',
+        severity: 'high',
+        message: 'Networking sin error handling. Implementar Result<T> o throws.',
+        filePath: file,
+        line: 1
+      });
+    }
+  }
+
+  findTestFiles() {
+    return glob.sync('**/*Tests.swift', {
+      cwd: this.projectRoot,
+      ignore: ['**/Pods/**', '**/Build/**'],
+      absolute: true
+    });
+  }
+}
+
+module.exports = { iOSNetworkingAdvancedRules };

package/scripts/hooks-system/infrastructure/ast/ios/analyzers/iOSPerformanceRules.js

@@ -0,0 +1,11 @@
+class iOSPerformanceRules {
+  constructor(findings) {
+    this.findings = findings;
+  }
+
+  analyzeFile(filePath, content) {
+    return;
+  }
+}
+
+module.exports = { iOSPerformanceRules };