pumuki-ast-hooks 6.2.1 → 6.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki-ast-hooks",
-  "version": "6.2.1",
+  "version": "6.2.2",
   "description": "Enterprise-grade AST Intelligence System with multi-platform support (iOS, Android, Backend, Frontend) and Feature-First + DDD + Clean Architecture enforcement. Includes dynamic violations API for intelligent querying.",
   "main": "index.js",
   "bin": {
@@ -136,4 +136,4 @@
     "./skills": "./skills/skill-rules.json",
     "./hooks": "./hooks/index.js"
   }
-}
+}

package/scripts/hooks-system/infrastructure/ast/common/ast-common.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const fs = require('fs');
+const { execSync } = require('child_process');
 const { pushFinding, SyntaxKind, platformOf, getRepoRoot } = require(path.join(__dirname, '../ast-core'));
 const { BDDTDDWorkflowRules } = require(path.join(__dirname, 'BDDTDDWorkflowRules'));
 
@@ -71,6 +72,56 @@ function hasTrackForMemoryLeaksEvidence(content) {
   return hasTrackForMemoryLeaks(content) || hasMakeSUT(content);
 }
 
+function loadTestFileContent(filePath) {
+  try {
+    const diskContent = fs.readFileSync(filePath, 'utf8');
+    if (diskContent && diskContent.trim().length > 0) {
+      return diskContent;
+    }
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.debug(`[ast-common] Failed to read test file content for ${filePath}: ${error.message}`);
+    }
+  }
+  return null;
+}
+
+function resolveTestFileContent(filePath, currentContent) {
+  const diskContent = loadTestFileContent(filePath);
+  if (diskContent) {
+    return diskContent;
+  }
+
+  const repoRoot = getRepoRoot();
+  const resolvedPath = path.isAbsolute(filePath) ? filePath : path.join(repoRoot, filePath);
+  if (resolvedPath !== filePath) {
+    const resolvedContent = loadTestFileContent(resolvedPath);
+    if (resolvedContent) {
+      return resolvedContent;
+    }
+  }
+
+  try {
+    const relPath = path.relative(repoRoot, resolvedPath).replace(/\\/g, '/');
+    if (relPath && !relPath.startsWith('..')) {
+      const stagedContent = execSync(`git show :${relPath}`, {
+        encoding: 'utf8',
+        cwd: repoRoot,
+        stdio: ['ignore', 'pipe', 'ignore']
+      });
+      if (stagedContent && stagedContent.trim().length > 0) {
+        return stagedContent;
+      }
+    }
+  } catch (error) {
+    if (process.env.DEBUG) {
+      console.debug(`[ast-common] Failed to read staged content for ${filePath}: ${error.message}`);
+    }
+  }
+
+  return currentContent;
+}
+
 /**
  * Detect if a test file is a simple value type test that doesn't need makeSUT/trackForMemoryLeaks.
  * Simple tests typically:
@@ -275,16 +326,7 @@ function runCommonIntelligence(project, findings) {
       const isSwiftOrKotlinTest = ext === '.swift' || ext === '.kt' || ext === '.kts';
 
       if (isSwiftOrKotlinTest) {
-        try {
-          const diskContent = fs.readFileSync(filePath, 'utf8');
-          if (diskContent && diskContent.trim().length > 0) {
-            content = diskContent;
-          }
-        } catch (error) {
-          if (process.env.DEBUG) {
-            console.debug(`[ast-common] Failed to read test file content for ${filePath}: ${error.message}`);
-          }
-        }
+        content = resolveTestFileContent(filePath, content);
       }
 
       if (isSwiftOrKotlinTest) {

package/scripts/hooks-system/infrastructure/ast/common/rules/WorkflowRules.js

@@ -76,7 +76,7 @@ class WorkflowRules {
             const featureName = this.extractFeatureName(content);
 
             if (featureName) {
-                const testFiles = glob.sync(`**/*${featureName}*.{test,spec}.{ts,tsx,swift,kt}`, {
+                let testFiles = glob.sync(`**/*${featureName}*.{test,spec}.{ts,tsx,swift,kt}`, {
                     cwd: this.projectRoot,
                     absolute: true,
                     nocase: true
@@ -89,6 +89,17 @@ class WorkflowRules {
                     nocase: true
                 });
 
+                if (testFiles.length === 0) {
+                    const tokens = this.splitFeatureName(featureName);
+                    if (tokens.length > 1) {
+                        testFiles = tokens.flatMap(token => glob.sync(`**/*${token}*.{test,spec}.{ts,tsx,swift,kt}`, {
+                            cwd: this.projectRoot,
+                            absolute: true,
+                            nocase: true
+                        }));
+                    }
+                }
+
                 if (testFiles.length === 0) {
                     pushFileFinding(
                         'workflow.triad.feature_without_tests',
@@ -128,6 +139,15 @@ class WorkflowRules {
         });
     }
 
+    splitFeatureName(name) {
+        const parts = String(name).split(/And|&|_/).map(part => part.trim()).filter(Boolean);
+        if (parts.length > 1) {
+            return parts;
+        }
+        const camelParts = String(name).match(/[A-Z][a-z0-9]+/g) || [name];
+        return camelParts.length > 0 ? camelParts : [name];
+    }
+
     extractFeatureName(content) {
         const match = content.match(/Feature:\s*(.+)/);
         return match ? match[1].trim().replace(/\s+/g, '') : null;

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

@@ -146,7 +146,7 @@ function analyzeMemoryManagement({ content, filePath, addFinding }) {
 }
 
 function analyzeOptionals({ content, filePath, addFinding }) {
-    const forceUnwraps = content.match(/(\w+)\s*!/g);
+    const forceUnwraps = content.match(/\b\w+!/g);
     if (forceUnwraps && forceUnwraps.length > 0) {
         const nonIBOutlets = forceUnwraps.filter(match => !content.includes(`@IBOutlet`));
         if (nonIBOutlets.length > 0) {

package/scripts/hooks-system/infrastructure/ast/ios/detectors/ios-ast-intelligent-strategies.js

@@ -451,7 +451,7 @@ function analyzeFunctionAST(analyzer, node, filePath) {
     const ifStatements = countStatementsOfType(substructure, 'stmt.if');
     const guardStatements = countStatementsOfType(substructure, 'stmt.guard');
 
-    const hasEarlyReturns = (analyzer.fileContent || '').includes('return') && guardStatements > 0;
+    const hasEarlyReturns = guardStatements > 0;
     const nestingLevel = calculateNestingDepth(substructure);
 
     if (nestingLevel >= 3 && !hasEarlyReturns) {
@@ -496,8 +496,6 @@ function analyzePropertyAST(analyzer, node, filePath) {
 }
 
 function analyzeClosuresAST(analyzer, filePath) {
-    const isStruct = analyzer.structs.length > 0;
-
     for (const closure of analyzer.closures) {
         const closureText = analyzer.safeStringify(closure);
         const hasSelfReference = closureText.includes('"self"') || closureText.includes('key.name":"self');
@@ -505,7 +503,13 @@ function analyzeClosuresAST(analyzer, filePath) {
         const parentFunc = closure._parent;
         const isEscaping = parentFunc && (parentFunc['key.typename'] || '').includes('@escaping');
 
-        if (hasSelfReference && isEscaping && !isStruct) {
+        let container = closure._parent;
+        while (container && !['source.lang.swift.decl.class', 'source.lang.swift.decl.struct'].includes(container['key.kind'])) {
+            container = container._parent;
+        }
+        const isContainerStruct = container && container['key.kind'] === 'source.lang.swift.decl.struct';
+
+        if (hasSelfReference && isEscaping && !isContainerStruct) {
             const offset = closure['key.offset'] || 0;
             const length = closure['key.length'] || 100;
             const closureCode = (analyzer.fileContent || '').substring(offset, offset + length);

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

@@ -0,0 +1,57 @@
+const { startPollingLoops } = require('./ast-intelligence-automation');
+const { getCompositionRoot } = require('../../../application/composition-root');
+
+jest.mock('../../../application/composition-root');
+
+describe('Polling Loops', () => {
+    let mockEvidenceMonitor;
+
+    beforeEach(() => {
+        mockEvidenceMonitor = {
+            start: jest.fn(),
+            refresh: jest.fn(),
+            isStale: jest.fn().mockReturnValue(true)
+        };
+
+        getCompositionRoot.mockReturnValue({
+            getEvidenceMonitor: () => mockEvidenceMonitor,
+            getGitFlowService: jest.fn(),
+            getGitQueryAdapter: jest.fn(),
+            getOrchestrator: jest.fn()
+        });
+    });
+
+    it('should configure evidence monitor refresh interval to 3 minutes', () => {
+        const originalSetInterval = setInterval;
+        let intervalCallback;
+        let intervalTime;
+
+        global.setInterval = (callback, time) => {
+            intervalCallback = callback;
+            intervalTime = time;
+            return originalSetInterval(callback, time);
+        };
+
+        startPollingLoops();
+
+        expect(intervalTime).toBe(180000);
+        expect(mockEvidenceMonitor.start).toHaveBeenCalled();
+
+        intervalCallback();
+        expect(mockEvidenceMonitor.refresh).toHaveBeenCalled();
+
+        global.setInterval = originalSetInterval;
+    });
+
+    it('should handle evidence refresh errors with retry', () => {
+        mockEvidenceMonitor.refresh.mockRejectedValue(new Error('Refresh failed'));
+
+        startPollingLoops();
+
+        const intervalCallback = setInterval.mock.calls[0][0];
+        intervalCallback();
+
+        expect(mockEvidenceMonitor.refresh).toHaveBeenCalled();
+        expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), 30000);
+    });
+});