pumuki-ast-hooks 5.5.51 → 5.5.52

package/scripts/hooks-system/infrastructure/ast/ios/parsers/SourceKittenParser.js

@@ -1,12 +1,10 @@
 
 
-const { exec } = require('child_process');
-const util = require('util');
 const fs = require('fs').promises;
 const path = require('path');
 const { DomainError } = require('../../../../domain/errors');
-
-const execPromise = util.promisify(exec);
+const SourceKittenRunner = require('./SourceKittenRunner');
+const SourceKittenExtractor = require('./SourceKittenExtractor');
 
 /**
  * SourceKittenParser
@@ -17,9 +15,11 @@ const execPromise = util.promisify(exec);
  * @see https://github.com/jpsim/SourceKitten
  */
 class SourceKittenParser {
-  constructor() {
-    this.sourceKittenPath = '/opt/homebrew/bin/sourcekitten';
-    this.timeout = 30000;
+  constructor({ runner = null, timeout = 30000 } = {}) {
+    this.runner = runner || new SourceKittenRunner({ defaultTimeoutMs: timeout });
+    this.sourceKittenPath = this.runner.binaryPath;
+    this.timeout = timeout;
+    this.extractor = new SourceKittenExtractor();
   }
 
   /**
@@ -28,10 +28,8 @@ class SourceKittenParser {
    */
   async isInstalled() {
     try {
-      const { stdout } = await execPromise(`${this.sourceKittenPath} version`, {
-        timeout: 5000,
-      });
-      return stdout.includes('SourceKitten');
+      const { stdout } = await this.runner.version();
+      return Boolean(stdout) && stdout.includes('SourceKitten');
     } catch (error) {
       console.error('[SourceKitten] Not installed. Run: brew install sourcekitten');
       return false;
@@ -49,16 +47,13 @@ class SourceKittenParser {
 
       await fs.access(absolutePath);
 
-      const { stdout, stderr } = await execPromise(
-        `${this.sourceKittenPath} structure --file "${absolutePath}"`,
-        { timeout: this.timeout }
-      );
+      const { stdout, stderr } = await this.runner.structure(absolutePath);
 
       if (stderr && stderr.includes('error')) {
         throw new DomainError(`SourceKitten parse error: ${stderr}`, 'PARSE_ERROR');
       }
 
-      const ast = JSON.parse(stdout);
+      const ast = stdout;
 
       return {
         filePath: absolutePath,
@@ -89,18 +84,14 @@ class SourceKittenParser {
   async parseProject(projectPath, moduleName, scheme) {
     try {
       const isWorkspace = projectPath.endsWith('.xcworkspace');
-      const projectFlag = isWorkspace ? '-workspace' : '-project';
 
-      const { stdout, stderr } = await execPromise(
-        `${this.sourceKittenPath} doc ${projectFlag} "${projectPath}" -scheme "${scheme}"`,
-        { timeout: 120000 }
-      );
+      const { stdout, stderr } = await this.runner.projectDoc(projectPath, scheme, isWorkspace);
 
       if (stderr && stderr.includes('error')) {
         throw new DomainError(`SourceKitten project parse error: ${stderr}`, 'PARSE_ERROR');
       }
 
-      const projectAST = JSON.parse(stdout);
+      const projectAST = stdout;
 
       return {
         projectPath,
@@ -132,12 +123,8 @@ class SourceKittenParser {
     try {
       const absolutePath = path.resolve(filePath);
 
-      const { stdout } = await execPromise(
-        `${this.sourceKittenPath} syntax --file "${absolutePath}"`,
-        { timeout: this.timeout }
-      );
-
-      const syntaxMap = JSON.parse(stdout);
+      const { stdout } = await this.runner.syntax(absolutePath);
+      const syntaxMap = stdout;
 
       return {
         filePath: absolutePath,
@@ -175,33 +162,7 @@ class SourceKittenParser {
    * @returns {ClassNode[]}
    */
   extractClasses(ast) {
-    const classes = [];
-
-    const traverse = (nodes) => {
-      if (!Array.isArray(nodes)) return;
-
-      nodes.forEach(node => {
-        const kind = node['key.kind'];
-
-        if (kind === 'source.lang.swift.decl.class') {
-          classes.push({
-            name: node['key.name'],
-            line: node['key.line'],
-            column: node['key.column'],
-            accessibility: node['key.accessibility'],
-            inheritedTypes: node['key.inheritedtypes'] || [],
-            substructure: node['key.substructure'] || [],
-          });
-        }
-
-        if (node['key.substructure']) {
-          traverse(node['key.substructure']);
-        }
-      });
-    };
-
-    traverse(ast.substructure);
-    return classes;
+    return this.extractor.extractClasses(ast);
   }
 
   /**
@@ -210,39 +171,7 @@ class SourceKittenParser {
    * @returns {FunctionNode[]}
    */
   extractFunctions(ast) {
-    const functions = [];
-
-    const traverse = (nodes) => {
-      if (!Array.isArray(nodes)) return;
-
-      nodes.forEach(node => {
-        const kind = node['key.kind'];
-
-        if (kind === 'source.lang.swift.decl.function.method.instance' ||
-          kind === 'source.lang.swift.decl.function.method.class' ||
-          kind === 'source.lang.swift.decl.function.method.static' ||
-          kind === 'source.lang.swift.decl.function.free') {
-
-          functions.push({
-            name: node['key.name'],
-            line: node['key.line'],
-            column: node['key.column'],
-            kind,
-            accessibility: node['key.accessibility'],
-            typename: node['key.typename'],
-            length: node['key.length'],
-            bodyLength: node['key.bodylength'],
-          });
-        }
-
-        if (node['key.substructure']) {
-          traverse(node['key.substructure']);
-        }
-      });
-    };
-
-    traverse(ast.substructure);
-    return functions;
+    return this.extractor.extractFunctions(ast);
   }
 
   /**
@@ -251,36 +180,7 @@ class SourceKittenParser {
    * @returns {PropertyNode[]}
    */
   extractProperties(ast) {
-    const properties = [];
-
-    const traverse = (nodes) => {
-      if (!Array.isArray(nodes)) return;
-
-      nodes.forEach(node => {
-        const kind = node['key.kind'];
-
-        if (kind === 'source.lang.swift.decl.var.instance' ||
-          kind === 'source.lang.swift.decl.var.class' ||
-          kind === 'source.lang.swift.decl.var.static') {
-
-          properties.push({
-            name: node['key.name'],
-            line: node['key.line'],
-            column: node['key.column'],
-            kind,
-            typename: node['key.typename'],
-            accessibility: node['key.accessibility'],
-          });
-        }
-
-        if (node['key.substructure']) {
-          traverse(node['key.substructure']);
-        }
-      });
-    };
-
-    traverse(ast.substructure);
-    return properties;
+    return this.extractor.extractProperties(ast);
   }
 
   /**
@@ -289,33 +189,7 @@ class SourceKittenParser {
    * @returns {ProtocolNode[]}
    */
   extractProtocols(ast) {
-    const protocols = [];
-
-    const traverse = (nodes) => {
-      if (!Array.isArray(nodes)) return;
-
-      nodes.forEach(node => {
-        const kind = node['key.kind'];
-
-        if (kind === 'source.lang.swift.decl.protocol') {
-          protocols.push({
-            name: node['key.name'],
-            line: node['key.line'],
-            column: node['key.column'],
-            accessibility: node['key.accessibility'],
-            inheritedTypes: node['key.inheritedtypes'] || [],
-            substructure: node['key.substructure'] || [],
-          });
-        }
-
-        if (node['key.substructure']) {
-          traverse(node['key.substructure']);
-        }
-      });
-    };
-
-    traverse(ast.substructure);
-    return protocols;
+    return this.extractor.extractProtocols(ast);
   }
 
   /**
@@ -324,19 +198,7 @@ class SourceKittenParser {
    * @returns {boolean}
    */
   usesSwiftUI(ast) {
-    const hasViewProtocol = (nodes) => {
-      if (!Array.isArray(nodes)) return false;
-
-      return nodes.some(node => {
-        const inheritedTypes = node['key.inheritedtypes'] || [];
-        if (inheritedTypes.some(t => t['key.name'] === 'View')) {
-          return true;
-        }
-        return hasViewProtocol(node['key.substructure'] || []);
-      });
-    };
-
-    return hasViewProtocol(ast.substructure);
+    return this.extractor.usesSwiftUI(ast);
   }
 
   /**
@@ -345,22 +207,7 @@ class SourceKittenParser {
    * @returns {boolean}
    */
   usesUIKit(ast) {
-    const hasUIKitBase = (nodes) => {
-      if (!Array.isArray(nodes)) return false;
-
-      return nodes.some(node => {
-        const inheritedTypes = node['key.inheritedtypes'] || [];
-        if (inheritedTypes.some(t =>
-          t['key.name'] === 'UIViewController' ||
-          t['key.name'] === 'UIView'
-        )) {
-          return true;
-        }
-        return hasUIKitBase(node['key.substructure'] || []);
-      });
-    };
-
-    return hasUIKitBase(ast.substructure);
+    return this.extractor.usesUIKit(ast);
   }
 
   /**
@@ -370,22 +217,7 @@ class SourceKittenParser {
    * @returns {ForceUnwrap[]}
    */
   detectForceUnwraps(syntaxMap, fileContent) {
-    const forceUnwraps = [];
-    const lines = fileContent.split('\n');
-
-    lines.forEach((line, index) => {
-      const matches = [...line.matchAll(/(\w+)\s*!/g)];
-      matches.forEach(match => {
-        forceUnwraps.push({
-          line: index + 1,
-          column: match.index + 1,
-          variable: match[1],
-          context: line.trim(),
-        });
-      });
-    });
-
-    return forceUnwraps;
+    return this.extractor.detectForceUnwraps(syntaxMap, fileContent);
   }
 }
 

package/scripts/hooks-system/infrastructure/ast/ios/parsers/SourceKittenRunner.js

@@ -0,0 +1,62 @@
+const { exec } = require('child_process');
+const util = require('util');
+const path = require('path');
+
+const execPromise = util.promisify(exec);
+
+class SourceKittenRunner {
+    constructor({
+        binaryPath = '/opt/homebrew/bin/sourcekitten',
+        defaultTimeoutMs = 30000,
+        logger = console
+    } = {}) {
+        this.binaryPath = binaryPath;
+        this.defaultTimeoutMs = defaultTimeoutMs;
+        this.logger = logger;
+    }
+
+    async version() {
+        return this.execRaw(`${this.binaryPath} version`, 5000);
+    }
+
+    async structure(filePath) {
+        const cmd = `${this.binaryPath} structure --file "${path.resolve(filePath)}"`;
+        return this.execJson(cmd, this.defaultTimeoutMs);
+    }
+
+    async syntax(filePath) {
+        const cmd = `${this.binaryPath} syntax --file "${path.resolve(filePath)}"`;
+        return this.execJson(cmd, this.defaultTimeoutMs);
+    }
+
+    async projectDoc(projectPath, scheme, isWorkspace = false) {
+        const projectFlag = isWorkspace ? '-workspace' : '-project';
+        const cmd = `${this.binaryPath} doc ${projectFlag} "${projectPath}" -scheme "${scheme}"`;
+        return this.execJson(cmd, 120000);
+    }
+
+    async execJson(command, timeoutMs) {
+        const { stdout, stderr } = await this.execRaw(command, timeoutMs);
+        return { stdout: this.safeJson(stdout), stderr };
+    }
+
+    async execRaw(command, timeoutMs) {
+        try {
+            return await execPromise(command, { timeout: timeoutMs });
+        } catch (error) {
+            const msg = error && error.message ? error.message : String(error);
+            this.logger?.debug?.('[SourceKittenRunner] exec error', { command, error: msg });
+            throw error;
+        }
+    }
+
+    safeJson(text) {
+        try {
+            return JSON.parse(text);
+        } catch {
+            return null;
+        }
+    }
+}
+
+module.exports = SourceKittenRunner;

package/scripts/hooks-system/infrastructure/mcp/ast-intelligence-automation.js

@@ -967,7 +967,6 @@ async function aiGateCheck() {
             }
         }
 
-        let mandatoryRules = null;
         let detectedPlatforms = [];
         try {
             const orchestrator = getCompositionRoot().getOrchestrator();
@@ -975,63 +974,66 @@ async function aiGateCheck() {
             if (contextDecision && contextDecision.platforms) {
                 detectedPlatforms = contextDecision.platforms.map(p => p.platform || p);
             }
-            const fallbackPlatforms = ['backend', 'frontend', 'ios', 'android'];
-            const platformsForRules = (detectedPlatforms.length > 0 ? detectedPlatforms : fallbackPlatforms)
-                .filter(Boolean);
-            const normalizedPlatforms = Array.from(new Set(platformsForRules));
-            const rulesData = await loadPlatformRules(normalizedPlatforms);
-            const rulesSample = rulesData.criticalRules.slice(0, 5).map(r => r.rule || r);
-            const rulesCount = rulesData.criticalRules.length;
+        } catch (err) {
+            if (process.env.DEBUG) {
+                process.stderr.write(`[MCP] analyzeContext failed, using fallback: ${err.message}\n`);
+            }
+        }
+
+        if (detectedPlatforms.length === 0) {
+            try {
+                const PlatformDetectionService = require('../../application/services/PlatformDetectionService');
+                const detector = new PlatformDetectionService();
+                detectedPlatforms = await detector.detectPlatforms(REPO_ROOT);
+            } catch (err) {
+                if (process.env.DEBUG) {
+                    process.stderr.write(`[MCP] PlatformDetectionService failed: ${err.message}\n`);
+                }
+            }
+        }
+
+        const platformsToLoad = detectedPlatforms.length > 0
+            ? detectedPlatforms.map(p => String(p).toLowerCase())
+            : ['backend', 'frontend', 'ios', 'android'];
+
+        let mandatoryRules = null;
+        try {
+            const rulesData = await loadPlatformRules(platformsToLoad);
             mandatoryRules = {
-                platforms: normalizedPlatforms,
-                criticalRules: rulesData.criticalRules,
-                rulesLoaded: Object.keys(rulesData.rules),
-                totalRulesCount: rulesCount,
-                rulesSample: rulesSample,
-                proofOfRead: `✅ VERIFIED: ${rulesCount} critical rules loaded from ${Object.keys(rulesData.rules).join(', ')}`
+                platforms: platformsToLoad,
+                criticalRules: rulesData.criticalRules || [],
+                rulesLoaded: Object.keys(rulesData.rules || {}),
+                warning: '⚠️ AI MUST read and follow these rules before ANY code generation or modification'
             };
-        } catch (error) {
+        } catch (err) {
             if (process.env.DEBUG) {
-                process.stderr.write(`[MCP] Failed to load mandatory rules: ${error.message}\n`);
+                process.stderr.write(`[MCP] loadPlatformRules failed: ${err.message}\n`);
             }
-
-            const fallbackPlatforms = ['backend', 'frontend', 'ios', 'android'];
-            const normalizedPlatforms = Array.from(new Set((detectedPlatforms.length > 0 ? detectedPlatforms : fallbackPlatforms).filter(Boolean)));
             mandatoryRules = {
-                platforms: normalizedPlatforms,
+                platforms: platformsToLoad,
                 criticalRules: [],
                 rulesLoaded: [],
-                status: 'FAILED_TO_LOAD',
-                error: `Failed to load rules content: ${error && error.message ? error.message : String(error)}`
+                warning: '⚠️ Rules loading failed but AI MUST still follow project conventions',
+                error: err.message
             };
         }
 
-        const rulesLoadedSuccessfully = mandatoryRules &&
-            mandatoryRules.criticalRules &&
-            mandatoryRules.criticalRules.length > 0;
-
-        if (!rulesLoadedSuccessfully) {
-            violations.push('❌ RULES_NOT_LOADED: Critical platform rules could not be loaded. AI cannot proceed without reading mandatory rules.');
-        }
-
-        const finalBlocked = isBlocked || !rulesLoadedSuccessfully;
-
         return {
-            status: finalBlocked ? 'BLOCKED' : 'ALLOWED',
+            status: isBlocked ? 'BLOCKED' : 'ALLOWED',
             timestamp: new Date().toISOString(),
             branch: currentBranch,
             violations,
             warnings,
             autoFixes,
-            mandatory_rules: rulesLoadedSuccessfully
-                ? { ...mandatoryRules, status: 'LOADED_OK' }
-                : mandatoryRules,
-            summary: finalBlocked
+            mandatory_rules: mandatoryRules,
+            summary: isBlocked
                 ? `🚫 BLOCKED: ${violations.length} violation(s). Fix before proceeding.`
-                : `🚦 ALLOWED: Gate passed. ${mandatoryRules.totalRulesCount} critical rules loaded and verified.`,
-            instructions: finalBlocked
+                : `🚦 ALLOWED: Gate passed.${warnings.length > 0 ? ` ${warnings.length} warning(s).` : ''}`,
+            instructions: isBlocked
                 ? 'DO NOT proceed with user task. Announce violations and fix them first.'
-                : `✅ ${mandatoryRules.totalRulesCount} RULES LOADED. Sample: ${mandatoryRules.rulesSample.slice(0, 2).join(' | ')}... Review ALL rules in mandatory_rules.criticalRules before ANY code generation.`
+                : mandatoryRules
+                    ? `You may proceed with user task. CRITICAL: Review mandatory_rules.criticalRules BEFORE generating ANY code.`
+                    : 'You may proceed with user task.'
         };
     };
 
@@ -1048,13 +1050,6 @@ async function aiGateCheck() {
         violations: ['❌ GATE_TIMEOUT: AI gate check timed out. Retry or run ai-start manually.'],
         warnings: [],
         autoFixes: [],
-        mandatory_rules: {
-            platforms: ['backend', 'frontend', 'ios', 'android'],
-            criticalRules: [],
-            rulesLoaded: [],
-            warning: '⚠️ AI MUST read and follow these rules before ANY code generation or modification',
-            error: 'Rules could not be loaded due to timeout'
-        },
         summary: '🚫 BLOCKED: Gate check timed out.',
         instructions: 'DO NOT proceed with user task. Retry the gate check.'
     };

package/scripts/hooks-system/infrastructure/orchestration/__tests__/intelligent-audit.spec.js

@@ -11,22 +11,6 @@ describe('intelligent-audit', () => {
     const mod = require('../intelligent-audit');
     expect(typeof mod.runIntelligentAudit).toBe('function');
   });
-
-  it('should filter staged violations strictly (no substring matches, no .audit_tmp)', () => {
-    const mod = require('../intelligent-audit');
-
-    expect(typeof mod.isViolationInStagedFiles).toBe('function');
-
-    const stagedSet = new Set([
-      'apps/ios/Application/AppCoordinator.swift'
-    ]);
-
-    expect(mod.isViolationInStagedFiles('apps/ios/Application/AppCoordinator.swift', stagedSet)).toBe(true);
-    expect(mod.isViolationInStagedFiles('apps/ios/Application/AppCoordinator.swift.backup', stagedSet)).toBe(false);
-    expect(mod.isViolationInStagedFiles('.audit_tmp/AppCoordinator.123.staged.swift', stagedSet)).toBe(false);
-    expect(mod.isViolationInStagedFiles('some/dir/.audit_tmp/AppCoordinator.123.staged.swift', stagedSet)).toBe(false);
-    expect(mod.isViolationInStagedFiles('apps/ios/Application/AppCoordinator', stagedSet)).toBe(false);
-  });
 });
 
 describe('AI_EVIDENCE.json structure validation', () => {

package/scripts/hooks-system/infrastructure/orchestration/intelligent-audit.js

@@ -235,28 +235,6 @@ function toRepoRelativePath(filePath) {
   return normalized;
 }
 
-function isAuditTmpPath(repoRelativePath) {
-  const normalized = normalizePathForMatch(repoRelativePath);
-  return normalized.startsWith('.audit_tmp/') || normalized.includes('/.audit_tmp/');
-}
-
-function isViolationInStagedFiles(violationPath, stagedSet) {
-  if (!violationPath) {
-    return false;
-  }
-
-  const repoRelative = toRepoRelativePath(violationPath);
-  if (!repoRelative) {
-    return false;
-  }
-
-  if (isAuditTmpPath(repoRelative)) {
-    return false;
-  }
-
-  return stagedSet.has(repoRelative);
-}
-
 function resolveAuditTmpDir() {
   const configured = (env.get('AUDIT_TMP', '') || '').trim();
   if (configured.length > 0) {
@@ -295,7 +273,18 @@ async function runIntelligentAudit() {
 
       const stagedViolations = rawViolations.filter(v => {
         const violationPath = toRepoRelativePath(v.filePath || v.file || '');
-        return isViolationInStagedFiles(violationPath, stagedSet);
+        if (!violationPath) {
+          return false;
+        }
+        if (stagedSet.has(violationPath)) {
+          return true;
+        }
+        for (const sf of stagedSet) {
+          if (sf && (violationPath === sf || violationPath.endsWith('/' + sf) || violationPath.includes('/' + sf))) {
+            return true;
+          }
+        }
+        return false;
       });
 
       console.log(`[Intelligent Audit] Gate scope: STAGING (${stagedFiles.length} files)`);
@@ -561,7 +550,7 @@ async function updateAIEvidence(violations, gateResult, tokenUsage) {
           file: v.filePath || v.file || 'unknown',
           line: v.line || null,
           severity: v.severity,
-          rule_id: ruleId,
+          rule: ruleId,
           message: v.message || v.description || '',
           category: v.category || deriveCategoryFromRuleId(ruleId),
           intelligent_evaluation: v.intelligentEvaluation || false,
@@ -694,4 +683,4 @@ if (require.main === module) {
   });
 }
 
-module.exports = { runIntelligentAudit, isViolationInStagedFiles, toRepoRelativePath };
+module.exports = { runIntelligentAudit };

package/scripts/hooks-system/infrastructure/shell/gitflow/gitflow-enforcer.sh

@@ -198,16 +198,6 @@ verify_atomic_commit() {
   done
 
   if (( root_count > 1 )); then
-    local has_scripts=0
-    local has_tests=0
-    for root in $roots_list; do
-      [[ "$root" == "scripts" ]] && has_scripts=1
-      [[ "$root" == "tests" ]] && has_tests=1
-    done
-    if [[ $has_scripts -eq 1 && $has_tests -eq 1 && $root_count -eq 2 ]]; then
-      printf "${GREEN}✅ Commit %s toca scripts + tests (permitido para bugfixes/features con tests).${NC}\n" "$commit"
-      return 0
-    fi
     printf "${RED}❌ Commit %s toca múltiples raíces (%s). Divide los cambios en commits atómicos.${NC}\n" "$commit" "$roots_list"
     return 1
   fi