pumuki 6.3.357 → 6.3.359

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.357",
+  "version": "6.3.359",
   "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-cause.ts

@@ -7,6 +7,7 @@ import {
   buildNotificationTrackingCauseSummary,
   extractNotificationTrackingContext,
 } from './framework-menu-system-notifications-tracking';
+import { buildLegacySkillCauseSummary } from './framework-menu-system-notifications-legacy-skill-cause';
 
 const BLOCKED_CAUSE_SUMMARY_BY_CODE: Readonly<Record<string, string>> = {
   EVIDENCE_GATE_BLOCKED: 'El gate de evidencia/gobernanza está bloqueado.',
@@ -170,6 +171,10 @@ export const resolveBlockedCauseSummary = (
   if (blockedCausesSummary) {
     return truncateNotificationText(blockedCausesSummary, 72);
   }
+  const legacySkillCauseSummary = buildLegacySkillCauseSummary(event.causeMessage);
+  if (legacySkillCauseSummary) {
+    return legacySkillCauseSummary;
+  }
   const trackingContext = extractNotificationTrackingContext(event.causeMessage);
   const priorityCode = resolvePriorityCauseFromMessage(event.causeMessage);
   if (priorityCode) {

package/scripts/framework-menu-system-notifications-legacy-skill-cause.ts

@@ -0,0 +1,107 @@
+import path from 'node:path';
+
+import { normalizeNotificationText } from './framework-menu-system-notifications-text';
+
+type LegacySkillCause = {
+  readonly ruleId: string;
+  readonly file?: string;
+  readonly line?: string;
+  readonly message?: string;
+  readonly remediation?: string;
+};
+
+const FIELD_NAMES = ['severity', 'file', 'line', 'lines', 'message', 'remediation'] as const;
+
+const RULE_LABELS: Readonly<Record<string, string>> = {
+  'skills.ios.prefer-swift-testing': 'Swift Testing',
+  'skills.ios.no-wait-for-expectations': 'Swift Testing async',
+  'skills.ios.no-xctassert': 'Swift Testing',
+  'skills.ios.no-xctunwrap': 'Swift Testing',
+  'skills.backend.no-empty-catch': 'Backend: no empty catch',
+};
+
+const extractLegacySkillSegment = (message?: string): string | null => {
+  if (!message) {
+    return null;
+  }
+  const markerIndex = message.indexOf('Blocking causes:');
+  if (markerIndex < 0) {
+    return null;
+  }
+  const afterMarker = message.slice(markerIndex);
+  const firstCause = afterMarker.replace(/^Blocking causes:\s*1\)\s*/i, '');
+  const nextCauseIndex = firstCause.search(/\s+\d+\)\s+skills\./);
+  return nextCauseIndex >= 0 ? firstCause.slice(0, nextCauseIndex) : firstCause;
+};
+
+const extractField = (segment: string, fieldName: string): string | undefined => {
+  const nextFields = FIELD_NAMES.filter((name) => name !== fieldName).join('|');
+  const pattern = new RegExp(`(?:^|\\s)${fieldName}=([\\s\\S]*?)(?=\\s(?:${nextFields})=|$)`);
+  const match = segment.match(pattern);
+  const value = match?.[1]?.trim();
+  return value && value.length > 0 ? value : undefined;
+};
+
+const humanizeRuleId = (ruleId: string): string =>
+  RULE_LABELS[ruleId] ??
+  ruleId
+    .replace(/^skills\./, '')
+    .split(/[._-]+/)
+    .filter(Boolean)
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join(' ');
+
+const formatLocation = (cause: LegacySkillCause): string | null => {
+  if (!cause.file) {
+    return null;
+  }
+  const basename = path.basename(cause.file);
+  return cause.line ? `${basename}:${cause.line}` : basename;
+};
+
+export const extractLegacySkillCauseFromMessage = (
+  message?: string
+): LegacySkillCause | null => {
+  const segment = extractLegacySkillSegment(message);
+  if (!segment) {
+    return null;
+  }
+  const ruleId = segment.match(/\bskills\.[a-z0-9_.-]+\b/i)?.[0];
+  if (!ruleId) {
+    return null;
+  }
+  return {
+    ruleId,
+    file: extractField(segment, 'file'),
+    line: extractField(segment, 'lines') ?? extractField(segment, 'line'),
+    message: extractField(segment, 'message'),
+    remediation: extractField(segment, 'remediation'),
+  };
+};
+
+export const buildLegacySkillCauseSummary = (message?: string): string | null => {
+  const cause = extractLegacySkillCauseFromMessage(message);
+  if (!cause) {
+    return null;
+  }
+  const rule = humanizeRuleId(cause.ruleId);
+  const location = formatLocation(cause);
+  return location ? `Skill violada: ${location} · ${rule}` : `Skill violada: ${rule}`;
+};
+
+export const buildLegacySkillCauseRemediation = (message?: string): string | null => {
+  const cause = extractLegacySkillCauseFromMessage(message);
+  if (!cause) {
+    return null;
+  }
+  const rule = humanizeRuleId(cause.ruleId);
+  const location = formatLocation(cause);
+  const failure = cause.message
+    ? ` Falla: ${normalizeNotificationText(cause.message)}.`
+    : '';
+  const remediation = cause.remediation
+    ? normalizeNotificationText(cause.remediation)
+    : 'Corrige esa regla en el fichero afectado y vuelve a intentar el commit.';
+  const file = location ? ` Fichero: ${location}.` : '';
+  return `Regla: ${rule}.${file}${failure} Solución: ${remediation}`;
+};

package/scripts/framework-menu-system-notifications-macos-dialog-payload.ts

@@ -1,5 +1,6 @@
 import type { PumukiCriticalNotificationEvent } from './framework-menu-system-notifications-types';
 import {
+  resolveDisplayBlockingCausesForEvent,
   resolvePrioritizedBlockingCauses,
   resolveBlockedCauseSummary,
   resolveBlockedRemediation,
@@ -332,7 +333,10 @@ const formatBlockingCauseForDialog = (
 ): readonly string[] => {
   const rule = cause.ruleId ?? cause.code;
   const visibleRule = formatVisibleRule(cause);
-  const problem = localizeDeveloperText(stripTechnicalFieldsFromMessage(cause.message) || cause.code);
+  const problem = localizeDeveloperText(
+    extractFieldFromCauseMessage(cause.message, 'message') ??
+    (stripTechnicalFieldsFromMessage(cause.message) || cause.code)
+  );
   const remediation = isGoldenFlowCause(cause)
     ? GOLDEN_FLOW_REMEDIATION
     : isWorktreeHygieneCause(cause)
@@ -418,17 +422,18 @@ export const buildBlockedDialogPayload = (params: {
   env: NodeJS.ProcessEnv;
 }): BlockedDialogPayload => {
   const causeCode = params.event.causeCode ?? 'GATE_BLOCKED';
-  const cause = buildBlockingCausesDetails(params.event.blockingCauses)
+  const displayBlockingCauses = resolveDisplayBlockingCausesForEvent(params.event);
+  const cause = buildBlockingCausesDetails(displayBlockingCauses)
     ?? resolveBlockedCauseSummary(params.event, causeCode);
-  const remediation = hasOnlyWorktreeHygieneCauses(params.event.blockingCauses)
+  const remediation = hasOnlyWorktreeHygieneCauses(displayBlockingCauses)
     ? WORKTREE_HYGIENE_REMEDIATION
-    : hasOnlyGoldenFlowCauses(params.event.blockingCauses)
-    ? resolveGoldenFlowDialogRemediation(params.event.blockingCauses)
-    : hasOnlyBddScenarioMissingCauses(params.event.blockingCauses)
+    : hasOnlyGoldenFlowCauses(displayBlockingCauses)
+    ? resolveGoldenFlowDialogRemediation(displayBlockingCauses)
+    : hasOnlyBddScenarioMissingCauses(displayBlockingCauses)
     ? 'Crea el fichero .feature esperado para la slice activa o corrige la referencia de tarea. Después vuelve a intentar el commit.'
-    : hasOnlySkillsContractCauses(params.event.blockingCauses)
+    : hasOnlySkillsContractCauses(displayBlockingCauses)
     ? SKILLS_CONTRACT_DIALOG_REMEDIATION
-    : params.event.blockingCauses && params.event.blockingCauses.length > 0
+    : displayBlockingCauses.length > 0
     ? 'Corrige las violaciones listadas y vuelve a intentar el commit.'
     : resolveBlockedRemediation(params.event, causeCode);
   const projectLabel = resolveProjectLabel({

package/scripts/framework-menu-system-notifications-payloads-blocked.ts

@@ -275,6 +275,25 @@ const normalizeDisplayCause = (cause: BlockedCause): BlockedCause => {
   };
 };
 
+export const resolveDisplayBlockingCausesForEvent = (
+  event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>
+): ReadonlyArray<BlockedCause> => {
+  if (event.blockingCauses && event.blockingCauses.length > 0) {
+    return event.blockingCauses;
+  }
+  if (!event.causeMessage || !/\bBlocking causes:\s*1\)\s*skills\./iu.test(event.causeMessage)) {
+    return [];
+  }
+  return [
+    {
+      code: event.causeCode ?? 'EVIDENCE_GATE_BLOCKED',
+      ruleId: 'ai_gate.repo_policy',
+      message: event.causeMessage,
+      remediation: event.remediation,
+    },
+  ];
+};
+
 export const resolvePrioritizedBlockingCauses = (
   causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
 ): ReadonlyArray<BlockedCause> => {
@@ -376,12 +395,13 @@ export const buildGateBlockedPayload = (
   projectPrefix: string
 ): SystemNotificationPayload => {
   const causeCode = event.causeCode ?? 'GATE_BLOCKED';
+  const displayBlockingCauses = resolveDisplayBlockingCausesForEvent(event);
   const causeSummary = truncateNotificationText(
-    buildBlockingCausesSummary(event.blockingCauses) ?? resolveBlockedCauseSummary(event, causeCode),
+    buildBlockingCausesSummary(displayBlockingCauses) ?? resolveBlockedCauseSummary(event, causeCode),
     96
   );
   const remediation =
-    buildBlockingCausesRemediation(event.blockingCauses) ?? resolveBlockedRemediation(event, causeCode);
+    buildBlockingCausesRemediation(displayBlockingCauses) ?? resolveBlockedRemediation(event, causeCode);
   return {
     title: '🔴 Pumuki bloqueado',
     subtitle: `${projectPrefix}${event.stage} · ${causeSummary}`,

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

@@ -27,6 +27,7 @@ export {
 } from './framework-menu-system-notifications-payloads-audit';
 export {
   buildGateBlockedPayload,
+  resolveDisplayBlockingCausesForEvent,
   resolvePrioritizedBlockingCauses,
 } from './framework-menu-system-notifications-payloads-blocked';
 export {

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

@@ -8,6 +8,7 @@ import {
   extractNotificationTrackingContext,
   TRACKING_BLOCKED_REMEDIATION,
 } from './framework-menu-system-notifications-tracking';
+import { buildLegacySkillCauseRemediation } from './framework-menu-system-notifications-legacy-skill-cause';
 
 type BlockedRemediationVariant = 'banner' | 'dialog';
 
@@ -224,6 +225,10 @@ export const resolveBlockedRemediation = (
   if (trackingContext) {
     return truncateNotificationText(buildNotificationTrackingRemediation(trackingContext), maxLength);
   }
+  const legacySkillCauseRemediation = buildLegacySkillCauseRemediation(event.causeMessage);
+  if (legacySkillCauseRemediation) {
+    return truncateNotificationText(legacySkillCauseRemediation, maxLength);
+  }
   if (fromEvent.length > 0) {
     if (
       causeCode === 'EVIDENCE_GATE_BLOCKED' &&