pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/android/clean-architecture-analyzer.js

@@ -0,0 +1,115 @@
+const LAYER_ANALYZERS = {
+  domain: {
+    validateImports: (importPath, filePath, index, findings, pushFileFinding) => {
+      const forbiddenImports = [
+        'android.',
+        'androidx.',
+        'com.google.android',
+        '.data.',
+        '.presentation.'
+      ];
+
+      const violation = forbiddenImports.find(forbidden =>
+        importPath.includes(forbidden)
+      );
+
+      if (violation) {
+        pushFileFinding(
+          'android.clean.domain_dependency_violation',
+          'critical',
+          filePath,
+          index + 1,
+          1,
+          `Domain layer importing ${violation} - Domain must be framework-agnostic.`,
+          findings
+        );
+      }
+    },
+    validateStructure: (filePath, findings, pushFileFinding) => {
+      const hasCorrectStructure =
+        filePath.includes('/model/') ||
+        filePath.includes('/repository/') ||
+        filePath.includes('/usecase/');
+
+      if (!hasCorrectStructure) {
+        pushFileFinding(
+          'android.clean.domain_structure',
+          'medium',
+          filePath,
+          1,
+          1,
+          `File in domain/ without correct structure. Use: model/, repository/, usecase/`,
+          findings
+        );
+      }
+    }
+  },
+  data: {
+    validateImports: (importPath, filePath, index, findings, pushFileFinding, targetLayer) => {
+      if (targetLayer === 'presentation') {
+        pushFileFinding(
+          'android.clean.data_presentation_violation',
+          'critical',
+          filePath,
+          index + 1,
+          1,
+          `Data layer importing from Presentation - violates dependency direction.`,
+          findings
+        );
+      }
+    },
+    validateStructure: () => {}
+  },
+  presentation: {
+    validateImports: () => {},
+    validateStructure: () => {}
+  }
+};
+
+function analyzeCleanArchitecture(filePath, fileContent, findings, pushFileFinding) {
+  const layer = detectLayer(filePath);
+  if (!layer) return;
+
+  const layerAnalyzer = LAYER_ANALYZERS[layer];
+  if (!layerAnalyzer) return;
+
+  const importRegex = /^import\s+([^\s;]+)/gm;
+  const imports = [];
+  let match;
+
+  while ((match = importRegex.exec(fileContent)) !== null) {
+    imports.push(match[1]);
+  }
+
+  imports.forEach((importPath, index) => {
+    const targetLayer = detectLayerFromImport(importPath);
+    layerAnalyzer.validateImports(importPath, filePath, index, findings, pushFileFinding, targetLayer);
+  });
+
+  layerAnalyzer.validateStructure(filePath, findings, pushFileFinding);
+}
+
+function detectLayer(filePath) {
+  const normalized = filePath.toLowerCase().replace(/\\/g, '/');
+
+  if (normalized.includes('/domain/')) return 'domain';
+  if (normalized.includes('/data/')) return 'data';
+  if (normalized.includes('/presentation/')) return 'presentation';
+
+  if (normalized.match(/\/(model|repository|usecase)\//)) return 'domain';
+  if (normalized.match(/\/(remote|local|mapper)\//)) return 'data';
+  if (normalized.match(/\/(ui|viewmodel|screen|theme)\//)) return 'presentation';
+
+  return null;
+}
+
+function detectLayerFromImport(importPath) {
+  if (importPath.includes('.domain.')) return 'domain';
+  if (importPath.includes('.data.')) return 'data';
+  if (importPath.includes('.presentation.')) return 'presentation';
+  return null;
+}
+
+module.exports = {
+  analyzeCleanArchitecture
+};

package/scripts/hooks-system/infrastructure/ast/android/ddd-analyzer.js

@@ -0,0 +1,70 @@
+function analyzeDDD(filePath, fileContent, findings, pushFileFinding) {
+  analyzeRepositoryPattern(filePath, fileContent, findings, pushFileFinding);
+
+  analyzeUseCases(filePath, fileContent, findings, pushFileFinding);
+
+  analyzeMappers(filePath, fileContent, findings, pushFileFinding);
+}
+
+function analyzeRepositoryPattern(filePath, fileContent, findings, pushFileFinding) {
+  if (/infrastructure\/ast\/|analyzers\/|detectors\//.test(filePath)) return;
+  const isInterface = fileContent.includes('interface ') && /Repository/i.test(fileContent);
+  const isClass = fileContent.includes('class ') && /Repository/i.test(fileContent);
+
+  if (isInterface && !filePath.includes('/domain/')) {
+    pushFileFinding(
+      'android.ddd.repository_interface_wrong_layer',
+      'critical',
+      filePath,
+      1,
+      1,
+      `Repository interface must be in domain/repository/, not data/.`,
+      findings
+    );
+  }
+
+  if (isClass && /Repository.*Impl|.*RepositoryImpl/.test(fileContent) &&
+      !filePath.includes('/data/')) {
+    pushFileFinding(
+      'android.ddd.repository_impl_wrong_layer',
+      'critical',
+      filePath,
+      1,
+      1,
+      `Repository implementation must be in data/repository/, not domain/.`,
+      findings
+    );
+  }
+}
+
+function analyzeUseCases(filePath, fileContent, findings, pushFileFinding) {
+  if (/UseCase/.test(filePath) && !filePath.includes('/usecase/')) {
+    pushFileFinding(
+      'android.ddd.usecase_wrong_location',
+      'medium',
+      filePath,
+      1,
+      1,
+      `Use Case should be in domain/usecase/ directory.`,
+      findings
+    );
+  }
+}
+
+function analyzeMappers(filePath, fileContent, findings, pushFileFinding) {
+  if (/Mapper/.test(filePath) && !filePath.includes('/mapper/')) {
+    pushFileFinding(
+      'android.ddd.mapper_wrong_location',
+      'low',
+      filePath,
+      1,
+      1,
+      `Mapper should be in data/mapper/ directory for DTO ↔ Domain conversion.`,
+      findings
+    );
+  }
+}
+
+module.exports = {
+  analyzeDDD
+};

package/scripts/hooks-system/infrastructure/ast/android/detekt-runner.js

@@ -0,0 +1,81 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { getRepoRoot } = require('../ast-core');
+
+const REPO_ROOT = getRepoRoot();
+const CUSTOM_RULES_DIR = path.join(REPO_ROOT, 'custom-rules');
+const DETEKT_REPORT = path.join(CUSTOM_RULES_DIR, 'build/reports/detekt/detekt.json');
+
+function analyzeAndroidFiles(kotlinFiles) {
+    if (!kotlinFiles || kotlinFiles.length === 0) {
+        return [];
+    }
+
+    try {
+        console.error('[detekt-runner] Running Detekt analysis on', kotlinFiles.length, 'Kotlin files...');
+
+        const command = `cd ${CUSTOM_RULES_DIR} && ./gradlew detekt --quiet`;
+
+        try {
+            execSync(command, {
+                encoding: 'utf-8',
+                stdio: 'pipe'
+            });
+        } catch (detektError) {
+            console.error('[detekt-runner] Detekt found violations (exit code non-zero)');
+        }
+
+        if (!fs.existsSync(DETEKT_REPORT)) {
+            console.error('[detekt-runner] Detekt report not found at:', DETEKT_REPORT);
+            return [];
+        }
+
+        const reportContent = fs.readFileSync(DETEKT_REPORT, 'utf-8');
+        const detektResults = JSON.parse(reportContent);
+
+        const findings = [];
+
+        if (!detektResults.findings) {
+            console.error('[detekt-runner] No findings in Detekt report');
+            return findings;
+        }
+
+        for (const [category, issues] of Object.entries(detektResults.findings)) {
+            for (const issue of issues) {
+                const issueFile = issue.location?.file || '';
+                if (/infrastructure\/ast\/|analyzers\/|detectors\//.test(issueFile)) {
+                    continue;
+                }
+                findings.push({
+                    rule_id: issue.rule || 'detekt-unknown',
+                    severity: mapDetektSeverity(issue.severity || 'warning'),
+                    file: issue.location?.file || 'unknown',
+                    line: issue.location?.position?.start?.line || 0,
+                    column: issue.location?.position?.start?.column || 0,
+                    message: issue.message || 'Detekt violation',
+                    category: category || 'detekt',
+                    debt: issue.debt || '10min'
+                });
+            }
+        }
+
+        console.error('[detekt-runner] Detekt analysis complete:', findings.length, 'findings');
+        return findings;
+
+    } catch (error) {
+        console.error('[detekt-runner] Error running Detekt:', error.message);
+        return [];
+    }
+}
+
+function mapDetektSeverity(detektSeverity) {
+    const mapping = {
+        'error': 'CRITICAL',
+        'warning': 'MEDIUM',
+        'info': 'LOW'
+    };
+    return mapping[detektSeverity.toLowerCase()] || 'MEDIUM';
+}
+
+module.exports = { analyzeAndroidFiles };

package/scripts/hooks-system/infrastructure/ast/android/feature-first-analyzer.js

@@ -0,0 +1,53 @@
+function analyzeFeatureFirst(filePath, fileContent, findings, pushFileFinding) {
+  const feature = detectFeature(filePath);
+  if (!feature) return;
+
+  const importRegex = /^import\s+([^\s;]+)/gm;
+  const imports = [];
+  let match;
+
+  while ((match = importRegex.exec(fileContent)) !== null) {
+    imports.push(match[1]);
+  }
+
+  imports.forEach((importPath, index) => {
+    const targetFeature = detectFeatureFromImport(importPath);
+
+    if (targetFeature && targetFeature !== feature) {
+      const isCoreModule = importPath.includes('.core.');
+
+      if (!isCoreModule) {
+        pushFileFinding(
+          'android.feature.cross_feature_import',
+          'high',
+          filePath,
+          index + 1,
+          1,
+          `Feature '${feature}' importing from '${targetFeature}' - features must be independent. Use core modules.`,
+          findings
+        );
+      }
+    }
+  });
+}
+
+function detectFeature(filePath) {
+  const match = filePath.match(/\/feature\/([^\/]+)/);
+  if (match) return match[1];
+
+  const match2 = filePath.match(/\/feature-([^\/]+)/);
+  if (match2) return match2[1];
+
+  return null;
+}
+
+function detectFeatureFromImport(importPath) {
+  const match = importPath.match(/\.feature\.([^.]+)\./);
+  if (match) return match[1];
+
+  return null;
+}
+
+module.exports = {
+  analyzeFeatureFirst
+};

package/scripts/hooks-system/infrastructure/ast/android/native-bridge.js

@@ -0,0 +1,119 @@
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const { pushFileFinding } = require('../ast-core');
+
+async function runDetektNative(findings) {
+  try {
+    const { getRepoRoot } = require('../ast-core');
+    const projectRoot = getRepoRoot();
+    const customRulesPath = path.join(projectRoot, 'custom-rules');
+
+    if (!fs.existsSync(customRulesPath)) {
+      console.log('[Detekt Native] custom-rules module not found - skipping');
+      return;
+    }
+
+    console.log('[Detekt Native] Building custom-rules...');
+
+    try {
+      execSync('./gradlew :custom-rules:build', {
+        cwd: projectRoot,
+        stdio: 'pipe',
+        timeout: 60000
+      });
+    } catch (buildError) {
+      console.log('[Detekt Native] Build skipped (not critical)');
+      return;
+    }
+
+    console.log('[Detekt Native] Running Detekt with custom rules...');
+
+    const detektConfig = path.join(projectRoot, 'detekt.yml');
+    const hasConfig = fs.existsSync(detektConfig);
+
+    const configArg = hasConfig ? `--config ${detektConfig}` : '';
+    const customRulesJar = path.join(customRulesPath, 'build/libs/custom-rules.jar');
+
+    const cmd = `./gradlew detekt ${configArg} --plugins ${customRulesJar}`;
+
+    const result = execSync(cmd, {
+      cwd: projectRoot,
+      encoding: 'utf8',
+      timeout: 120000
+    });
+
+    parseDetektOutput(result, findings);
+
+    console.log('[Detekt Native] ✅ Custom rules executed');
+
+  } catch (error) {
+    if (error.stdout) {
+      parseDetektOutput(error.stdout, findings);
+    }
+    console.log('[Detekt Native] Completed with violations');
+  }
+}
+
+function parseDetektOutput(output, findings) {
+  const lines = output.split('\n');
+
+  for (const line of lines) {
+    const match = line.match(/(.+\.kt):(\d+):(\d+):\s*(.+?)\s*\[(.+?)\]/);
+    if (match) {
+      const [, filePath, lineNum, col, message, ruleId] = match;
+
+      const level = determineSeverity(ruleId);
+      const mappedRuleId = mapDetektRuleId(ruleId);
+
+      pushFileFinding(
+        mappedRuleId,
+        level,
+        filePath,
+        parseInt(lineNum),
+        parseInt(col),
+        message,
+        findings
+      );
+    }
+  }
+}
+
+function determineSeverity(ruleId) {
+  if (ruleId.includes('SRP') || ruleId.includes('Singleton') || ruleId.includes('InstallIn')) {
+    return 'high';
+  }
+  if (ruleId.includes('OCP') || ruleId.includes('Layer') || ruleId.includes('Encrypted')) {
+    return 'high';
+  }
+  return 'medium';
+}
+
+const DETEKT_RULE_MAPPING = {
+  'SRP': 'srp_cohesion',
+  'OCP': 'ocp_when',
+  'LSP': 'lsp_contract',
+  'ISP': 'isp_interface',
+  'DIP': 'dip_hilt',
+  'Layer': 'layer_validator',
+  'Feature': 'feature_first',
+  'Anemic': 'ddd_anemic',
+  'Command': 'cqrs',
+  'Query': 'cqrs',
+  'Singleton': 'singleton',
+  'ForceUnwrap': 'force_unwrap'
+};
+
+function mapDetektRuleId(ruleId) {
+  const prefix = 'android.native.';
+  
+  for (const [key, value] of Object.entries(DETEKT_RULE_MAPPING)) {
+    if (ruleId.includes(key)) {
+      return prefix + value;
+    }
+  }
+
+  return prefix + ruleId.toLowerCase().replace(/[^a-z0-9]/g, '_');
+}
+
+module.exports = { runDetektNative };

package/scripts/hooks-system/infrastructure/ast/archive/README.md

@@ -0,0 +1,18 @@
+# Archive - Archivos Históricos
+
+Esta carpeta contiene implementaciones anteriores y archivos obsoletos del sistema AST Intelligence que han sido reemplazados por la arquitectura modular actual.
+
+## Archivos
+
+- `ast-intelligence.ts` - Versión TypeScript anterior del coordinador (reemplazado por `ast-intelligence.js`)
+- `ios-rules.js` - Implementación anterior de reglas iOS usando SourceKitten
+- `kotlin-analyzer.js` - Analizador Kotlin anterior usando Detekt
+- `kotlin-parser.js` - Parser Kotlin anterior usando Detekt
+- `swift-analyzer.js` - Analizador Swift anterior usando SourceKitten
+
+## Nota
+
+Estos archivos se mantienen por referencia histórica y no deben usarse en el código actual. El sistema actual utiliza la arquitectura modular en:
+- `ast-core.js` - Utilidades compartidas
+- `ast-intelligence.js` - Coordinador principal
+- `{platform}/ast-{platform}.js` - Módulos específicos por plataforma