pumuki 6.3.157 → 6.3.159

package/core/facts/detectors/text/ios.test.ts

@@ -659,17 +659,28 @@ let text = "XCTUnwrap(optionalValue)"
 });
 
 test('hasSwiftWaitForExpectationsUsage detecta waits legacy y excluye await fulfillment', () => {
-  const legacyWait = `
+  const legacyAsyncWait = `
+func testLegacyAsync() async {
 let expectation = expectation(description: "Done")
 wait(for: [expectation], timeout: 1)
 waitForExpectations(timeout: 1)
+}
+`;
+  const legacySyncWait = `
+func testLegacySync() {
+let expectation = expectation(description: "Done")
+wait(for: [expectation], timeout: 1)
+}
 `;
   const modernWait = `
+func testModernAsync() async {
 let expectation = expectation(description: "Done")
 await fulfillment(of: [expectation], timeout: 1)
+}
 `;
 
-  assert.equal(hasSwiftWaitForExpectationsUsage(legacyWait), true);
+  assert.equal(hasSwiftWaitForExpectationsUsage(legacyAsyncWait), true);
+  assert.equal(hasSwiftWaitForExpectationsUsage(legacySyncWait), false);
   assert.equal(hasSwiftWaitForExpectationsUsage(modernWait), false);
 });
 

package/core/facts/detectors/text/ios.ts

@@ -100,6 +100,63 @@ const hasSwiftSanitizedRegexMatch = (source: string, regex: RegExp): boolean =>
   return regex.test(sanitizeSwiftSourceForMultilineRegex(source));
 };
 
+type SwiftFunctionDeclaration = {
+  signature: string;
+  body: string;
+};
+
+const collectSwiftFunctionDeclarations = (source: string): readonly SwiftFunctionDeclaration[] => {
+  const lines = source.split(/\r?\n/);
+  const functions: SwiftFunctionDeclaration[] = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const firstLine = stripSwiftLineForSemanticScan(lines[index] ?? '');
+    if (!/\bfunc\b/.test(firstLine)) {
+      continue;
+    }
+
+    const signatureLines: string[] = [];
+    let cursor = index;
+    let openingLineIndex = -1;
+    for (; cursor < lines.length && cursor < index + 24; cursor += 1) {
+      const line = stripSwiftLineForSemanticScan(lines[cursor] ?? '');
+      signatureLines.push(line);
+      if (line.includes('{')) {
+        openingLineIndex = cursor;
+        break;
+      }
+      if (line.includes('}')) {
+        break;
+      }
+    }
+
+    if (openingLineIndex < 0) {
+      continue;
+    }
+
+    const bodyLines: string[] = [];
+    let braceDepth = 0;
+    for (let bodyCursor = openingLineIndex; bodyCursor < lines.length; bodyCursor += 1) {
+      const line = stripSwiftLineForSemanticScan(lines[bodyCursor] ?? '');
+      braceDepth += countTokenOccurrences(line, '{');
+      braceDepth -= countTokenOccurrences(line, '}');
+      bodyLines.push(line);
+      if (bodyCursor > openingLineIndex && braceDepth <= 0) {
+        cursor = bodyCursor;
+        break;
+      }
+    }
+
+    functions.push({
+      signature: signatureLines.join('\n'),
+      body: bodyLines.join('\n'),
+    });
+    index = cursor;
+  }
+
+  return functions;
+};
+
 const hasSwiftUiModernizationSnapshotMatch = (source: string, entryId: string): boolean => {
   const entry = getIosSwiftUiModernizationEntry(entryId);
   if (!entry) {
@@ -855,10 +912,14 @@ const hasSwiftConfirmationUsage = (source: string): boolean => {
 };
 
 export const hasSwiftWaitForExpectationsUsage = (source: string): boolean => {
-  return hasSwiftSanitizedRegexMatch(
-    source,
-    /\bwait\s*\(\s*for\s*:|\bwaitForExpectations\s*\(/
-  );
+  const legacyWaitPattern = /\bwait\s*\(\s*for\s*:|\bwaitForExpectations\s*\(/;
+  return collectSwiftFunctionDeclarations(source).some((declaration) => {
+    if (!/\basync\b/.test(declaration.signature)) {
+      return false;
+    }
+    legacyWaitPattern.lastIndex = 0;
+    return legacyWaitPattern.test(declaration.body);
+  });
 };
 
 export const hasSwiftLegacyExpectationDescriptionUsage = (source: string): boolean => {

package/integrations/git/runPlatformGate.ts

@@ -461,7 +461,7 @@ const isSkillsEnforcementRemediationDiff = (
     return false;
   }
 
-  const normalizedPaths = paths.map((path) => toNormalizedPath(path));
+  const normalizedPaths = paths.map((path) => toNormalizedPath(path).toLowerCase());
   const touchesDetectorSurface = normalizedPaths.some((path) =>
     path.startsWith('core/facts/') ||
     path.startsWith('core/rules/presets/heuristics/') ||
@@ -1494,17 +1494,30 @@ export async function runPlatformGate(params: {
         stagedCodePathSet
       )
     : [];
+  const previousIosTestsQualityFinding =
+    previousFactsForStagedPaths.length > 0 &&
+    iosTestsQualityFinding === undefined &&
+    isStrictEnforcementStage(params.policy.stage)
+      ? toIosTestsQualityBlockingFinding({
+          stage: params.policy.stage,
+          facts: previousFactsForStagedPaths,
+        })
+      : undefined;
+  const previousRemediationBlockingFindings = [
+    ...previousBlockingFindingsForStagedPaths,
+    ...(previousIosTestsQualityFinding ? [previousIosTestsQualityFinding] : []),
+  ];
   const remediationProgressFinding =
-    previousBlockingFindingsForStagedPaths.length > currentBlockingFindingsForStagedPaths.length &&
+    previousRemediationBlockingFindings.length > currentBlockingFindingsForStagedPaths.length &&
     currentBlockingFindingsForStagedPaths.length === 0
       ? toRemediationProgressAllowedFinding({
           stage: params.policy.stage as Exclude<GateStage, 'STAGED'>,
           currentBlockingCount: currentBlockingFindingsForStagedPaths.length,
-          previousBlockingCount: previousBlockingFindingsForStagedPaths.length,
+          previousBlockingCount: previousRemediationBlockingFindings.length,
           paths: stagedCodePaths,
           ruleIds: [
             ...new Set(
-              previousBlockingFindingsForStagedPaths.map((finding) => finding.ruleId)
+              previousRemediationBlockingFindings.map((finding) => finding.ruleId)
             ),
           ].sort(),
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.157",
+  "version": "6.3.159",
   "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": {

package/scripts/framework-menu-system-notifications-env.ts

@@ -5,3 +5,11 @@ export const isTruthyEnvValue = (value?: string): boolean => {
   const normalized = value.trim().toLowerCase();
   return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
 };
+
+export const isFalsyEnvValue = (value?: string): boolean => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === '0' || normalized === 'false' || normalized === 'no' || normalized === 'off';
+};

package/scripts/framework-menu-system-notifications-gate.ts

@@ -3,14 +3,21 @@ import type {
   SystemNotificationEmitResult,
   SystemNotificationsConfig,
 } from './framework-menu-system-notifications-types';
-import { isTruthyEnvValue } from './framework-menu-system-notifications-env';
+import {
+  isFalsyEnvValue,
+  isTruthyEnvValue,
+} from './framework-menu-system-notifications-env';
 
 export const resolveSystemNotificationGate = (params: {
   config: SystemNotificationsConfig;
   nowMs: number;
   env?: NodeJS.ProcessEnv;
 }): SystemNotificationEmitResult | null => {
-  if (isTruthyEnvValue(params.env?.PUMUKI_DISABLE_SYSTEM_NOTIFICATIONS)) {
+  if (
+    isTruthyEnvValue(params.env?.PUMUKI_DISABLE_SYSTEM_NOTIFICATIONS) ||
+    isFalsyEnvValue(params.env?.PUMUKI_SYSTEM_NOTIFICATIONS) ||
+    isFalsyEnvValue(params.env?.PUMUKI_NOTIFICATIONS)
+  ) {
     return { delivered: false, reason: 'disabled' };
   }
   if (!params.config.enabled) {