pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/archive/kotlin-analyzer.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+/**
+ * Kotlin AST Analyzer using Detekt + Pattern Matching
+ * Analiza código Kotlin para detectar violaciones de reglas Android
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+class KotlinAnalyzer {
+  constructor() {
+    this.findings = [];
+  }
+
+  /**
+   * Analiza un archivo Kotlin usando Detekt y pattern matching
+   * @param {string} filePath - Ruta al archivo Kotlin
+   * @returns {Array} - Lista de findings
+   */
+  analyzeFile(filePath) {
+    this.findings = [];
+
+    if (!fs.existsSync(filePath)) {
+      console.error(`File not found: ${filePath}`);
+      return this.findings;
+    }
+
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+
+      this.analyzePatterns(filePath, content);
+
+
+    } catch (error) {
+      console.error(`Error analyzing Kotlin file ${filePath}:`, error.message);
+    }
+
+    return this.findings;
+  }
+
+  /**
+   * Analiza patrones en el código Kotlin
+   */
+  analyzePatterns(filePath, content) {
+    const lines = content.split('\n');
+
+    lines.forEach((line, index) => {
+      const lineNum = index + 1;
+      const trimmed = line.trim();
+
+      if (trimmed.startsWith('public class') || trimmed.startsWith('public interface')) {
+        this.addFinding({
+          rule: 'android.java_code',
+          severity: 'high',
+          message: 'Java code detected - use Kotlin for all new code',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('!!') && !trimmed.startsWith('//')) {
+        this.addFinding({
+          rule: 'android.force_unwrapping',
+          severity: 'high',
+          message: 'Force unwrapping (!!) detected - use safe call (?.) or let instead',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      // XML layouts
+      if (trimmed.includes('setContentView(R.layout.')) {
+        this.addFinding({
+          rule: 'android.xml_layouts',
+          severity: 'high',
+          message: 'XML layout detected - use Jetpack Compose for new code',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('object ') || (trimmed.includes('companion object') && content.includes('val instance'))) {
+        this.addFinding({
+          rule: 'android.singletons',
+          severity: 'medium',
+          message: 'Singleton pattern detected - use Hilt dependency injection instead',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      // Context leaks
+      if (trimmed.includes('= context') || trimmed.includes('= this') && content.includes('Activity')) {
+        this.addFinding({
+          rule: 'android.context_leaks',
+          severity: 'high',
+          message: 'Potential context leak - avoid long-lived references to Activity context',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.startsWith('fun ') && trimmed.includes('()') && content.includes('Column') && !line.includes('@Composable')) {
+        this.addFinding({
+          rule: 'android.missing_composable',
+          severity: 'high',
+          message: 'Function appears to be a Composable but missing @Composable annotation',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (content.includes('@Composable') && (trimmed.includes('viewModelScope.launch') || trimmed.includes('CoroutineScope'))) {
+        this.addFinding({
+          rule: 'android.side_effects_composable',
+          severity: 'medium',
+          message: 'Side effects in Composable - use LaunchedEffect or rememberCoroutineScope',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('var ') && trimmed.includes(': String') && !trimmed.includes('?') && !trimmed.includes('=')) {
+        this.addFinding({
+          rule: 'android.missing_null_safety',
+          severity: 'low',
+          message: 'Non-nullable type without initialization - consider nullable type or lateinit',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      // Missing @Entity
+      if (trimmed.startsWith('data class') && content.includes('@Database') && !line.includes('@Entity')) {
+        this.addFinding({
+          rule: 'android.missing_entity',
+          severity: 'medium',
+          message: 'Data class in database context missing @Entity annotation',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('class ') && trimmed.includes('Activity') && !content.includes('ViewModel')) {
+        this.addFinding({
+          rule: 'android.missing_viewmodel',
+          severity: 'high',
+          message: 'Activity without ViewModel - use MVVM pattern with ViewModel',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('@Test') && content.includes('import org.junit.Test') && !content.includes('org.junit.jupiter')) {
+        this.addFinding({
+          rule: 'android.missing_junit5',
+          severity: 'low',
+          message: 'Using JUnit4 - prefer JUnit5 for new tests',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('apiKey') || trimmed.includes('secret') || trimmed.includes('password')) {
+        if (trimmed.includes('=') && trimmed.includes('"') && !trimmed.includes('BuildConfig')) {
+          this.addFinding({
+            rule: 'android.hardcoded_secrets',
+            severity: 'critical',
+            message: 'Hardcoded secret detected - use BuildConfig or local.properties',
+            file: filePath,
+            line: lineNum
+          });
+        }
+      }
+
+      // findViewById
+      if (trimmed.includes('findViewById')) {
+        this.addFinding({
+          rule: 'android.findviewbyid',
+          severity: 'medium',
+          message: 'findViewById detected - use View Binding or Jetpack Compose',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      // AsyncTask
+      if (trimmed.includes('AsyncTask')) {
+        this.addFinding({
+          rule: 'android.asynctask',
+          severity: 'high',
+          message: 'AsyncTask is deprecated - use Kotlin Coroutines instead',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('startActivity')) {
+        this.addFinding({
+          rule: 'android.startactivity',
+          severity: 'low',
+          message: 'Direct startActivity - consider using Navigation Component',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('SharedPreferences') && !trimmed.includes('Encrypted')) {
+        this.addFinding({
+          rule: 'android.sharedpreferences',
+          severity: 'medium',
+          message: 'SharedPreferences detected - use DataStore (or EncryptedSharedPreferences for sensitive data)',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      if (trimmed.includes('Handler()') && !content.includes('WeakReference')) {
+        this.addFinding({
+          rule: 'android.handler_leak',
+          severity: 'high',
+          message: 'Handler without WeakReference - potential memory leak',
+          file: filePath,
+          line: lineNum
+        });
+      }
+
+      // Raw threads
+      if (trimmed.includes('Thread(') && !trimmed.startsWith('//')) {
+        this.addFinding({
+          rule: 'android.raw_threads',
+          severity: 'medium',
+          message: 'Raw Thread usage - prefer Kotlin Coroutines with Dispatchers',
+          file: filePath,
+          line: lineNum
+        });
+      }
+    });
+
+    this.analyzeBlocks(filePath, content);
+  }
+
+  /**
+   * Analiza bloques de código completos
+   */
+  analyzeBlocks(filePath, content) {
+    const liveDataObservePattern = /\.observe\s*\([^,]+\)/g;
+    let match;
+    while ((match = liveDataObservePattern.exec(content)) !== null) {
+      const line = this.getLineNumber(content, match.index);
+      this.addFinding({
+        rule: 'android.livedata_observe',
+        severity: 'medium',
+        message: 'LiveData observe - ensure lifecycle owner is passed correctly',
+        file: filePath,
+        line: line
+      });
+    }
+
+    const flowCollectPattern = /\.collect\s*\{/g;
+    while ((match = flowCollectPattern.exec(content)) !== null) {
+      const line = this.getLineNumber(content, match.index);
+      if (!content.includes('lifecycleScope') && !content.includes('viewModelScope')) {
+        this.addFinding({
+          rule: 'android.flow_collect',
+          severity: 'high',
+          message: 'Flow collect without proper lifecycle scope - use lifecycleScope or viewModelScope',
+          file: filePath,
+          line: line
+        });
+      }
+    }
+
+    const suspendFunPattern = /suspend\s+fun\s+\w+/g;
+    while ((match = suspendFunPattern.exec(content)) !== null) {
+      const line = this.getLineNumber(content, match.index);
+      this.addFinding({
+        rule: 'android.suspend_scope',
+        severity: 'low',
+        message: 'Suspend function - ensure called from appropriate coroutine scope',
+        file: filePath,
+        line: line
+      });
+    }
+
+    const mutableStatePattern = /val\s+\w+\s*=\s*mutableStateOf/g;
+    while ((match = mutableStatePattern.exec(content)) !== null) {
+      const line = this.getLineNumber(content, match.index);
+      if (!content.includes('private')) {
+        this.addFinding({
+          rule: 'android.mutable_exposure',
+          severity: 'medium',
+          message: 'Mutable state exposed publicly - use private + public read-only accessor',
+          file: filePath,
+          line: line
+        });
+      }
+    }
+  }
+
+  /**
+   * Agrega un finding a la lista
+   */
+  addFinding(finding) {
+    this.findings.push(finding);
+  }
+
+  /**
+   * Obtiene el número de línea dado un offset en el contenido
+   */
+  getLineNumber(content, offset) {
+    return content.substring(0, offset).split('\n').length;
+  }
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+  module.exports = KotlinAnalyzer;
+}
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.length === 0) {
+    console.log('Usage: node kotlin-analyzer.js <kotlin-file>');
+    process.exit(1);
+  }
+
+  const analyzer = new KotlinAnalyzer();
+  const findings = analyzer.analyzeFile(args[0]);
+  console.log(JSON.stringify(findings, null, 2));
+}

package/scripts/hooks-system/infrastructure/ast/archive/kotlin-parser.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+/**
+ * Kotlin/Android AST Parser usando Detekt
+ * Wrapper para integrar Detekt en el sistema de hooks
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const xml2js = require('xml2js');
+const { ConfigurationError } = require('../../../domain/errors');
+
+class KotlinParser {
+  constructor() {
+    this.detektPath = '/opt/homebrew/bin/detekt';
+    this.checkAvailability();
+  }
+
+  checkAvailability() {
+    try {
+      execSync(`${this.detektPath} --version`, { encoding: 'utf-8' });
+    } catch (error) {
+      throw new ConfigurationError('Detekt not found. Install with: brew install detekt', 'detektPath');
+    }
+  }
+
+  /**
+   * Analiza un archivo Kotlin y retorna issues detectados
+   * @param {string} filePath - Ruta al archivo .kt
+   * @returns {Array<Object>} Array de issues encontrados
+   */
+  parseFile(filePath) {
+    try {
+      if (!fs.existsSync(filePath)) {
+        throw new ConfigurationError(`File not found: ${filePath}`);
+      }
+
+      const tmpXml = path.join('/tmp', `detekt-${Date.now()}.xml`);
+
+      try {
+        execSync(
+          `${this.detektPath} --input "${filePath}" --report xml:"${tmpXml}" --all-rules --build-upon-default-config`,
+          { encoding: 'utf-8', stdio: 'pipe' }
+        );
+      } catch (error) {
+      }
+
+      if (!fs.existsSync(tmpXml)) {
+        return [];
+      }
+
+      const xmlContent = fs.readFileSync(tmpXml, 'utf-8');
+      fs.unlinkSync(tmpXml); // Limpiar archivo temporal
+
+      return this.parseDetektXmlSync(xmlContent, filePath);
+    } catch (error) {
+      console.error(`Error parsing Kotlin file ${filePath}:`, error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Parse el XML de Detekt y extrae los issues (versión síncrona)
+   * @param {string} xmlContent - Contenido XML de Detekt
+   * @param {string} filePath - Ruta del archivo analizado
+   * @returns {Array<Object>} Array de issues
+   */
+  parseDetektXmlSync(xmlContent, filePath) {
+    const parser = new xml2js.Parser();
+    const issues = [];
+
+    parser.parseString(xmlContent, (err, result) => {
+      if (err) {
+        console.error('Error parsing Detekt XML:', err.message);
+        return;
+      }
+
+      if (!result || !result.checkstyle || !result.checkstyle.file) {
+        return;
+      }
+
+      const files = Array.isArray(result.checkstyle.file)
+        ? result.checkstyle.file
+        : [result.checkstyle.file];
+
+      files.forEach(file => {
+        if (!file.error) return;
+
+        const errors = Array.isArray(file.error) ? file.error : [file.error];
+
+        errors.forEach(error => {
+          const attrs = error.$;
+          issues.push({
+            file: filePath,
+            line: parseInt(attrs.line) || 0,
+            column: parseInt(attrs.column) || 0,
+            severity: this.mapSeverity(attrs.severity),
+            message: attrs.message,
+            source: attrs.source || 'detekt'
+          });
+        });
+      });
+    });
+
+    return issues;
+  }
+
+  /**
+   * Mapea severidad de Detekt a nuestro sistema
+   * @param {string} severity - Severidad de Detekt
+   * @returns {string} Severidad normalizada
+   */
+  mapSeverity(severity) {
+    const map = {
+      'error': 'high',
+      'warning': 'medium',
+      'info': 'low'
+    };
+    return map[severity?.toLowerCase()] || 'medium';
+  }
+
+  /**
+   * Analiza múltiples archivos Kotlin en un directorio
+   * @param {string} dirPath - Ruta al directorio
+   * @returns {Array<Object>} Array de issues
+   */
+  parseDirectory(dirPath) {
+    const kotlinFiles = this.findKotlinFiles(dirPath);
+    const allIssues = [];
+
+    kotlinFiles.forEach(file => {
+      const issues = this.parseFile(file);
+      allIssues.push(...issues);
+    });
+
+    return allIssues;
+  }
+
+  /**
+   * Encuentra todos los archivos .kt en un directorio recursivamente
+   * @param {string} dirPath - Ruta al directorio
+   * @returns {Array<string>} Array de rutas a archivos .kt
+   */
+  findKotlinFiles(dirPath) {
+    const kotlinFiles = [];
+
+    const traverse = (currentPath) => {
+      if (!fs.existsSync(currentPath)) return;
+
+      const stats = fs.statSync(currentPath);
+      if (stats.isFile() && currentPath.endsWith('.kt')) {
+        kotlinFiles.push(currentPath);
+      } else if (stats.isDirectory()) {
+        const basename = path.basename(currentPath);
+        if (['node_modules', '.git', '.gradle', 'build', '.idea'].includes(basename)) {
+          return;
+        }
+
+        const entries = fs.readdirSync(currentPath);
+        entries.forEach(entry => {
+          traverse(path.join(currentPath, entry));
+        });
+      }
+    };
+
+    traverse(dirPath);
+    return kotlinFiles;
+  }
+
+  /**
+   * Detecta uso de Java en lugar de Kotlin
+   * @param {string} fileContent - Contenido del archivo
+   * @returns {boolean} True si hay código Java
+   */
+  detectJavaCode(fileContent) {
+    const javaPatterns = [
+      /public\s+class\s+\w+\s*{/,  // Java class declaration
+      /System\.out\.println/,       // Java print
+      /new\s+\w+\(/,                // Java constructor
+    ];
+
+    return javaPatterns.some(pattern => pattern.test(fileContent));
+  }
+
+  /**
+   * Detecta falta de null safety en Kotlin
+   * @param {string} fileContent - Contenido del archivo
+   * @returns {Array<Object>} Array de ubicaciones con !!
+   */
+  detectForceUnwrapping(fileContent) {
+    const findings = [];
+    const lines = fileContent.split('\n');
+
+    lines.forEach((line, index) => {
+      const forceUnwrapRegex = /[a-zA-Z0-9_)]+!!/g;
+      let match;
+
+      const commentIndex = line.indexOf('//');
+      const effectiveLine = commentIndex !== -1 ? line.substring(0, commentIndex) : line;
+
+      while ((match = forceUnwrapRegex.exec(effectiveLine)) !== null) {
+        findings.push({
+          line: index + 1,
+          column: match.index,
+          text: match[0]
+        });
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * Detecta XML layouts (anti-pattern en Jetpack Compose)
+   * @param {string} projectPath - Ruta al proyecto
+   * @returns {Array<string>} Array de archivos XML layout encontrados
+   */
+  detectXmlLayouts(projectPath) {
+    const xmlLayouts = [];
+    const layoutDirs = [
+      path.join(projectPath, 'res', 'layout'),
+      path.join(projectPath, 'src', 'main', 'res', 'layout')
+    ];
+
+    layoutDirs.forEach(dir => {
+      if (fs.existsSync(dir)) {
+        const files = fs.readdirSync(dir);
+        files.forEach(file => {
+          if (file.endsWith('.xml')) {
+            xmlLayouts.push(path.join(dir, file));
+          }
+        });
+      }
+    });
+
+    return xmlLayouts;
+  }
+
+  /**
+   * Detecta uso de findViewById (anti-pattern, debería usar View Binding o Compose)
+   * @param {string} fileContent - Contenido del archivo
+   * @returns {boolean} True si usa findViewById
+   */
+  detectFindViewById(fileContent) {
+    return fileContent.includes('findViewById');
+  }
+
+  /**
+   * Detecta uso de AsyncTask (deprecado, debería usar Coroutines)
+   * @param {string} fileContent - Contenido del archivo
+   * @returns {boolean} True si usa AsyncTask
+   */
+  detectAsyncTask(fileContent) {
+    return fileContent.includes('AsyncTask');
+  }
+
+  /**
+   * Detecta falta de @Composable en funciones UI
+   * @param {string} fileContent - Contenido del archivo
+   * @returns {Array<Object>} Array de funciones sin @Composable
+   */
+  detectMissingComposable(fileContent) {
+    const findings = [];
+    const lines = fileContent.split('\n');
+
+    for (let index = 0; index < lines.length; index++) {
+      const line = lines[index];
+
+      if (line.trim().startsWith('fun ') && line.includes('(')) {
+        const prevLine = index > 0 ? lines[index - 1].trim() : '';
+        const hasComposable = prevLine.includes('@Composable');
+
+        let foundComposableUsage = false;
+        const functionName = line.match(/fun\s+(\w+)/)?.[1];
+
+        for (let j = index + 1; j < Math.min(index + 20, lines.length); j++) {
+          const bodyLine = lines[j];
+          if (bodyLine.includes('Column') || bodyLine.includes('Row') ||
+            bodyLine.includes('Text(') || bodyLine.includes('Button(')) {
+            foundComposableUsage = true;
+            break;
+          }
+          if (bodyLine.trim().startsWith('fun ')) {
+            break;
+          }
+        }
+
+        if (foundComposableUsage && !hasComposable) {
+          findings.push({
+            line: index + 1,
+            function: line.trim(),
+            functionName
+          });
+        }
+      }
+    }
+
+    return findings;
+  }
+}
+
+module.exports = KotlinParser;