pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/infrastructure/ast/archive/ast-intelligence.ts

@@ -0,0 +1,276 @@
+import { Project, SourceFile, Node, SyntaxKind } from "ts-morph";
+import path from "path";
+import fs from "fs";
+
+type Severity = "error" | "warning" | "info";
+
+type Finding = {
+  ruleId: string;
+  severity: Severity;
+  filePath: string;
+  line: number;
+  column: number;
+  message: string;
+};
+
+type Rule = {
+  id: string;
+  description: string;
+  severity: Severity;
+  check: (sf: SourceFile) => Finding[];
+};
+
+function getRepoRoot(): string {
+  return process.cwd();
+}
+
+function shouldIgnore(file: string): boolean {
+  const p = file.replace(/\\/g, "/");
+  if (p.includes("node_modules/")) return true;
+  if (p.includes("/.next/")) return true;
+  if (p.includes("/dist/")) return true;
+  if (p.includes("/.turbo/")) return true;
+  if (p.includes("/.vercel/")) return true;
+  if (p.includes("/coverage/")) return true;
+  if (p.includes("/build/")) return true;
+  if (p.includes("/out/")) return true;
+  if (p.endsWith(".d.ts")) return true;
+  if (p.endsWith(".map")) return true;
+  if (/\.min\./.test(p)) return true;
+  return false;
+}
+
+function listSourceFiles(root: string): string[] {
+  const exts = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+  const result: string[] = [];
+  const stack: string[] = [root];
+  while (stack.length) {
+    const dir = stack.pop() as string;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      const norm = full.replace(/\\/g, "/");
+      if (e.isDirectory()) {
+        if (shouldIgnore(norm + "/")) continue;
+        stack.push(full);
+      } else {
+        const ext = path.extname(e.name);
+        if (exts.has(ext) && !shouldIgnore(norm)) result.push(full);
+      }
+    }
+  }
+  return result;
+}
+
+function positionOf(node: Node, sf: SourceFile): { line: number; column: number } {
+  const pos = sf.getLineAndColumnAtPos(node.getStart());
+  return { line: pos.line, column: pos.column };
+}
+
+function ruleAnyType(): Rule {
+  return {
+    id: "types.any",
+    description: "Disallow explicit any",
+    severity: "error",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      sf.forEachDescendant((n) => {
+        if (n.getKind() === SyntaxKind.AnyKeyword) {
+          const { line, column } = positionOf(n, sf);
+          findings.push({ ruleId: "types.any", severity: "error", filePath: sf.getFilePath(), line, column, message: "Explicit any" });
+        }
+      });
+      return findings;
+    },
+  };
+}
+
+function ruleConsoleLog(): Rule {
+  return {
+    id: "debug.console",
+    description: "Disallow console.*",
+    severity: "warning",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+        const expr = call.getExpression().getText();
+        if (/^console\.(log|debug|warn)\b/.test(expr)) {
+          const { line, column } = positionOf(call, sf);
+          findings.push({ ruleId: "debug.console", severity: "warning", filePath: sf.getFilePath(), line, column, message: expr });
+        }
+      });
+      return findings;
+    },
+  };
+}
+
+function ruleHardcodedSecrets(): Rule {
+  return {
+    id: "security.secret",
+    description: "Hardcoded secret patterns",
+    severity: "error",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      const literals = sf.getDescendantsOfKind(SyntaxKind.StringLiteral);
+      for (const lit of literals) {
+        const v = lit.getLiteralValue();
+        if (/(API_KEY|SECRET|TOKEN|PASSWORD)\s*[:=]?\s*[A-Za-z0-9_\-]{8,}/i.test(v)) {
+          const { line, column } = positionOf(lit, sf);
+          findings.push({ ruleId: "security.secret", severity: "error", filePath: sf.getFilePath(), line, column, message: v.slice(0, 50) });
+        }
+      }
+      return findings;
+    },
+  };
+}
+
+function ruleRawSQLInStrings(): Rule {
+  return {
+    id: "security.sql.raw",
+    description: "Raw SQL keywords in strings",
+    severity: "error",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      const literals = sf.getDescendantsOfKind(SyntaxKind.StringLiteral);
+      for (const lit of literals) {
+        const v = lit.getLiteralValue();
+        if (/(SELECT |INSERT |UPDATE |DELETE |DROP |ALTER |TRUNCATE )/i.test(v)) {
+          const { line, column } = positionOf(lit, sf);
+          findings.push({ ruleId: "security.sql.raw", severity: "error", filePath: sf.getFilePath(), line, column, message: v.slice(0, 60) });
+        }
+      }
+      return findings;
+    },
+  };
+}
+
+function ruleSupabaseNoPagination(): Rule {
+  return {
+    id: "performance.pagination",
+    description: "Select without pagination",
+    severity: "warning",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      sf.getDescendantsOfKind(SyntaxKind.CallExpression).forEach((call) => {
+        const text = call.getExpression().getText();
+        if (/\bsupabase\b.*\.from\(/.test(text)) {
+          const chain = call.getFirstAncestorByKind(SyntaxKind.ExpressionStatement)?.getText() || call.getText();
+          const hasRange = /\.range\(/.test(chain) || /\.limit\(/.test(chain);
+          if (!hasRange) {
+            const { line, column } = positionOf(call, sf);
+            findings.push({ ruleId: "performance.pagination", severity: "warning", filePath: sf.getFilePath(), line, column, message: "Missing pagination on query" });
+          }
+        }
+      });
+      return findings;
+    },
+  };
+}
+
+function ruleInLoopQueries(): Rule {
+  return {
+    id: "performance.nplus1",
+    description: "Query inside loop",
+    severity: "warning",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      const loops = [
+        ...sf.getDescendantsOfKind(SyntaxKind.ForStatement),
+        ...sf.getDescendantsOfKind(SyntaxKind.ForOfStatement),
+        ...sf.getDescendantsOfKind(SyntaxKind.ForInStatement),
+        ...sf.getDescendantsOfKind(SyntaxKind.WhileStatement),
+      ];
+      for (const lp of loops) {
+        const innerCalls = lp.getDescendantsOfKind(SyntaxKind.CallExpression);
+        for (const call of innerCalls) {
+          const t = call.getExpression().getText();
+          if (/\bsupabase\b.*\.from\(/.test(t)) {
+            const { line, column } = positionOf(call, sf);
+            findings.push({ ruleId: "performance.nplus1", severity: "warning", filePath: sf.getFilePath(), line, column, message: "Query in loop" });
+          }
+        }
+      }
+      return findings;
+    },
+  };
+}
+
+function ruleLayeringImports(): Rule {
+  return {
+    id: "architecture.layering",
+    description: "Wrong direction imports",
+    severity: "error",
+    check: (sf) => {
+      const findings: Finding[] = [];
+      const p = sf.getFilePath().replace(/\\/g, "/");
+      const imports = sf.getImportDeclarations();
+      for (const imp of imports) {
+        const spec = imp.getModuleSpecifierValue();
+        if (/domain\//.test(p) && (/infrastructure\//.test(spec) || /application\//.test(spec))) {
+          const { line, column } = positionOf(imp, sf);
+          findings.push({ ruleId: "architecture.layering", severity: "error", filePath: p, line, column, message: `domain->${spec}` });
+        }
+        if (/application\//.test(p) && /infrastructure\//.test(spec)) {
+          const { line, column } = positionOf(imp, sf);
+          findings.push({ ruleId: "architecture.layering", severity: "error", filePath: p, line, column, message: `application->${spec}` });
+        }
+      }
+      return findings;
+    },
+  };
+}
+
+function run(): void {
+  const root = getRepoRoot();
+  const files = listSourceFiles(root);
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  files.forEach((f) => project.addSourceFileAtPathIfExists(f) || project.addSourceFileAtPath(f));
+  const rules: Rule[] = [
+    ruleAnyType(),
+    ruleConsoleLog(),
+    ruleHardcodedSecrets(),
+    ruleRawSQLInStrings(),
+    ruleSupabaseNoPagination(),
+    ruleInLoopQueries(),
+    ruleLayeringImports(),
+  ];
+
+  const findings: Finding[] = [];
+  for (const sf of project.getSourceFiles()) {
+    for (const rule of rules) {
+      const res = rule.check(sf);
+      findings.push(...res);
+    }
+  }
+
+  const totals = findings.reduce(
+    (acc, f) => {
+      if (f.severity === "error") acc.errors += 1;
+      else if (f.severity === "warning") acc.warnings += 1;
+      else acc.infos += 1;
+      return acc;
+    },
+    { errors: 0, warnings: 0, infos: 0 }
+  );
+
+  const grouped: Record<string, number> = {};
+  for (const f of findings) grouped[f.ruleId] = (grouped[f.ruleId] || 0) + 1;
+
+  const green = "\x1b[32m";
+  const yellow = "\x1b[33m";
+  const red = "\x1b[31m";
+  const nc = "\x1b[0m";
+
+  process.stdout.write(`${yellow}AST Intelligence running on ${files.length} files${nc}\n`);
+  Object.entries(grouped)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 20)
+    .forEach(([k, v]) => {
+      const sev = rules.find((r) => r.id === k)?.severity || "info";
+      const emoji = sev === "error" ? "🔴" : sev === "warning" ? "🟡" : "🔵";
+      process.stdout.write(`${emoji} ${k}:${v}\n`);
+    });
+  process.stdout.write(`${green}AST Totals: errors=${totals.errors} warnings=${totals.warnings} infos=${totals.infos}${nc}\n`);
+}
+
+run();

package/scripts/hooks-system/infrastructure/ast/archive/ios-rules.js

@@ -0,0 +1,329 @@
+#!/usr/bin/env node
+
+/**
+ * iOS/Swift AST Rules usando SourceKitten
+ * Reglas robustas para análisis de código Swift
+ */
+
+const SwiftParser = require('./swift-parser');
+const fs = require('fs');
+const path = require('path');
+
+class iOSRules {
+  constructor() {
+    this.parser = null;
+    try {
+      this.parser = new SwiftParser();
+    } catch (error) {
+      console.warn('SwiftParser not available:', error.message);
+    }
+  }
+
+  /**
+   * Analiza un archivo Swift y retorna findings
+   * @param {string} filePath - Ruta al archivo Swift
+   * @param {boolean} isTest - Si es un archivo de test
+   * @returns {Array<Object>} Array de findings
+   */
+  analyzeFile(filePath, isTest = false) {
+    if (!this.parser) return [];
+
+    const findings = [];
+    const ast = this.parser.parseFile(filePath);
+    if (!ast) return findings;
+
+    const fileContent = fs.readFileSync(filePath, 'utf-8');
+
+    findings.push(...this.checkForceUnwrapping(filePath, fileContent, ast));
+    findings.push(...this.checkCompletionHandlers(filePath, ast));
+    findings.push(...this.checkMassiveViewControllers(filePath, ast));
+    findings.push(...this.checkSingletons(filePath, ast, fileContent));
+    findings.push(...this.checkWeakSelf(filePath, fileContent));
+    findings.push(...this.checkStoryboards(filePath));
+    findings.push(...this.checkUIKitUnnecessary(filePath, fileContent));
+    findings.push(...this.checkMissingState(filePath, ast));
+    findings.push(...this.checkStructDefault(filePath, ast));
+    findings.push(...this.checkImmutability(filePath, ast));
+
+    if (isTest) {
+      findings.push(...this.checkMakeSUT(filePath, ast, fileContent));
+    }
+
+    return findings;
+  }
+
+  /**
+   * ios.force_unwrapping - Detección de force unwrapping (!)
+   * Detecta uso de ! excepto en @IBOutlet
+   */
+  checkForceUnwrapping(filePath, fileContent, ast) {
+    const findings = [];
+    const forceUnwraps = this.parser.detectForceUnwrapping(fileContent);
+
+    forceUnwraps.forEach(fu => {
+      findings.push({
+        ruleId: 'ios.force_unwrapping',
+        severity: 'high',
+        filePath,
+        line: fu.line,
+        column: fu.column,
+        message: `Force unwrapping (!) detected: ${fu.text.trim()} - use if let or guard let instead`
+      });
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.completion_handlers - Detección de completion handlers
+   * Sugiere usar async/await en lugar de completion handlers
+   */
+  checkCompletionHandlers(filePath, ast) {
+    const findings = [];
+    const handlers = this.parser.detectCompletionHandlers(ast);
+
+    handlers.forEach(handler => {
+      findings.push({
+        ruleId: 'ios.completion_handlers',
+        severity: 'medium',
+        filePath,
+        line: handler.node['key.offset'] || 0,
+        column: 0,
+        message: `Completion handler detected in ${handler.function} - consider using async/await instead`
+      });
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.massive_viewcontrollers - ViewControllers >300 líneas
+   */
+  checkMassiveViewControllers(filePath, ast) {
+    const findings = [];
+    const types = this.parser.extractTypes(ast);
+
+    types.classes.forEach(cls => {
+      const name = cls.name;
+      if (name && (name.includes('ViewController') || name.includes('Controller'))) {
+        const length = cls.node['key.bodylength'];
+        if (length && length > 300) {
+          findings.push({
+            ruleId: 'ios.massive_viewcontrollers',
+            severity: 'high',
+            filePath,
+            line: cls.node['key.offset'] || 0,
+            column: 0,
+            message: `Massive ViewController detected: ${name} (${length} lines) - break down into smaller components`
+          });
+        }
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.singletons - Detección de Singleton pattern
+   */
+  checkSingletons(filePath, ast, fileContent) {
+    const findings = [];
+
+    const singletonRegex = /static\s+let\s+(?:shared|instance|default|sharedInstance)\s*=/gi;
+    const lines = fileContent.split('\n');
+
+    lines.forEach((line, index) => {
+      if (singletonRegex.test(line)) {
+        findings.push({
+          ruleId: 'ios.singletons',
+          severity: 'medium',
+          filePath,
+          line: index + 1,
+          column: 0,
+          message: 'Singleton pattern detected - consider dependency injection instead'
+        });
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.weak_self - Closures sin [weak self]
+   */
+  checkWeakSelf(filePath, fileContent) {
+    const findings = [];
+    const lines = fileContent.split('\n');
+
+    lines.forEach((line, index) => {
+      if (line.includes('{') && (line.includes('self.') || line.match(/\bself\b/))) {
+        const contextStart = Math.max(0, index - 2);
+        const contextLines = lines.slice(contextStart, index + 1).join(' ');
+
+        if (!contextLines.includes('[weak self]') && !contextLines.includes('[unowned self]')) {
+          if (!line.includes('func ') && (line.includes(') in') || line.includes('})'))) {
+            findings.push({
+              ruleId: 'ios.weak_self',
+              severity: 'medium',
+              filePath,
+              line: index + 1,
+              column: 0,
+              message: 'Closure captures self without weak/unowned reference - potential retain cycle'
+            });
+          }
+        }
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.storyboards - Detección de Storyboards/XIBs
+   */
+  checkStoryboards(filePath) {
+    const findings = [];
+    if (filePath.endsWith('.storyboard') || filePath.endsWith('.xib')) {
+      findings.push({
+        ruleId: 'ios.storyboards',
+        severity: 'high',
+        filePath,
+        line: 1,
+        column: 0,
+        message: 'Storyboard/XIB detected - use programmatic UI for better version control'
+      });
+    }
+    return findings;
+  }
+
+  /**
+   * ios.uikit_unnecessary - UIKit y SwiftUI mezclados
+   */
+  checkUIKitUnnecessary(filePath, fileContent) {
+    const findings = [];
+    const hasUIKit = fileContent.includes('import UIKit');
+    const hasSwiftUI = fileContent.includes('import SwiftUI');
+
+    if (hasUIKit && hasSwiftUI) {
+      findings.push({
+        ruleId: 'ios.uikit_unnecessary',
+        severity: 'low',
+        filePath,
+        line: 1,
+        column: 0,
+        message: 'Both UIKit and SwiftUI imported - prefer SwiftUI for new code'
+      });
+    }
+
+    return findings;
+  }
+
+  /**
+   * ios.missing_state - Variables locales sin @State
+   */
+  checkMissingState(filePath, ast) {
+    const findings = [];
+    const variables = this.parser.extractVariables(ast);
+
+    variables.forEach(v => {
+      if (v.kind === 'source.lang.swift.decl.var.instance' && v.name && !v.name.startsWith('_')) {
+        const attrs = v.node['key.attributes'];
+        if (!attrs || !attrs.some(attr => attr['key.attribute']?.includes('State'))) {
+          const typename = v.node['key.typename'];
+          if (typename && !typename.includes('?') && !typename.includes('@')) {
+            findings.push({
+              ruleId: 'ios.missing_state',
+              severity: 'medium',
+              filePath,
+              line: v.node['key.offset'] || 0,
+              column: 0,
+              message: `Local state variable ${v.name} without @State - use @State for view-local state`
+            });
+          }
+        }
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.struct_default - Class cuando struct sería suficiente
+   */
+  checkStructDefault(filePath, ast) {
+    const findings = [];
+    const types = this.parser.extractTypes(ast);
+
+    types.classes.forEach(cls => {
+      const inheritance = cls.node['key.inheritedtypes'];
+      if (!inheritance || inheritance.length === 0) {
+        findings.push({
+          ruleId: 'ios.struct_default',
+          severity: 'medium',
+          filePath,
+          line: cls.node['key.offset'] || 0,
+          column: 0,
+          message: `Class ${cls.name} without inheritance - consider using struct for value types unless you need reference semantics`
+        });
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.inmutabilidad_missing - Uso de var cuando let sería suficiente
+   */
+  checkImmutability(filePath, ast) {
+    const findings = [];
+    const variables = this.parser.extractVariables(ast);
+
+    variables.forEach(v => {
+      if (v.name && v.node['key.setter_accessibility'] === 'source.lang.swift.accessibility.private') {
+        findings.push({
+          ruleId: 'ios.inmutabilidad_missing',
+          severity: 'low',
+          filePath,
+          line: v.node['key.offset'] || 0,
+          column: 0,
+          message: `Mutable variable ${v.name} - prefer let for immutability where possible`
+        });
+      }
+    });
+
+    return findings;
+  }
+
+  /**
+   * ios.missing_makesut - Tests sin makeSUT pattern
+   */
+  checkMakeSUT(filePath, ast, fileContent) {
+    const findings = [];
+
+    if (!fileContent.includes('XCTest') && !fileContent.includes('Quick') && !fileContent.includes('import XCTest')) {
+      return findings;
+    }
+
+    const functions = this.parser.extractFunctions(ast);
+    const testFunctions = functions.filter(fn =>
+      fn.name && (fn.name.startsWith('test') || fn.name.includes('_should_'))
+    );
+
+    const hasMakeSUT = fileContent.includes('makeSUT') || fileContent.includes('make_sut');
+
+    if (testFunctions.length > 0 && !hasMakeSUT) {
+      findings.push({
+        ruleId: 'ios.missing_makesut',
+        severity: 'low',
+        filePath,
+        line: testFunctions[0].node['key.offset'] || 0,
+        column: 0,
+        message: 'Test function without makeSUT pattern - consider factory method for System Under Test'
+      });
+    }
+
+    return findings;
+  }
+}
+
+module.exports = iOSRules;