pumuki 6.3.312 → 6.3.313

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pumuki",
-  "version": "6.3.312",
+  "version": "6.3.313",
   "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-macos-dialog-payload.ts

@@ -52,6 +52,10 @@ const stripTechnicalFieldsFromMessage = (message: string): string => {
     .replace(/\blines?=[0-9][0-9,\-\s]*/gi, '')
     .replace(/\bmessage=/gi, '')
     .replace(/\bremediation=/gi, '')
+    .replace(/\bmissing=\[[^\]]*\]/gi, '')
+    .replace(/\bsnippet=.+$/gi, '')
+    .replace(/\bnode=.+$/gi, '')
+    .replace(/\bprimary_node=.+$/gi, '')
     .replace(/\s+/g, ' ')
     .trim();
 };
@@ -98,6 +102,47 @@ const formatLocation = (cause: NonNullable<Extract<PumukiCriticalNotificationEve
   return line ? `${cause.file}:${line}` : cause.file;
 };
 
+const humanizeRuleId = (ruleId: string): string => {
+  const knownRules: Record<string, string> = {
+    'prefer-swift-testing': 'Swift Testing',
+    'no-xctassert': 'XCTest assertions',
+    'no-wait-for-expectations': 'waitForExpectations en XCTest',
+    'ios-test-quality': 'calidad de tests iOS',
+    'dynamic-type-font-scaling-automatico': 'Dynamic Type',
+    'dynamic-type-fuentes-escalables-y-layouts-adaptativos': 'fuentes escalables y layouts adaptativos',
+    'use-relative-layout-over-hard-coded-constants': 'layout relativo en vez de constantes fijas',
+    'magic-numbers-usar-constantes-con-nombres': 'números mágicos sin constantes con nombre',
+    'prefer-static-member-lookup-blue-vs-color-blue': 'colores semánticos en SwiftUI',
+  };
+  const normalized = ruleId
+    .replace(/^skills\./u, '')
+    .replace(/^governance\./u, '')
+    .replace(/^ai_gate\./u, '')
+    .replace(/_/gu, '-');
+  const parts = normalized.split('.').filter(Boolean);
+  const leaf = parts.at(-1) ?? normalized;
+  if (knownRules[leaf]) {
+    return knownRules[leaf];
+  }
+  return leaf
+    .replace(/-/gu, ' ')
+    .replace(/\bios\b/giu, 'iOS')
+    .replace(/\bui\b/giu, 'UI')
+    .replace(/\bapi\b/giu, 'API')
+    .replace(/\btdd\b/giu, 'TDD')
+    .replace(/\bsdd\b/giu, 'SDD')
+    .replace(/\bguard\b/giu, 'guard')
+    .trim();
+};
+
+const formatVisibleRule = (
+  cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
+): string => {
+  const ruleId = cause.ruleId ?? cause.code;
+  const readable = humanizeRuleId(ruleId);
+  return readable.length > 0 ? readable : ruleId;
+};
+
 const isWorktreeHygieneCause = (
   cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
 ): boolean =>
@@ -105,16 +150,78 @@ const isWorktreeHygieneCause = (
   cause.code === 'EVIDENCE_PREWRITE_WORKTREE_OVER_LIMIT' ||
   (cause.ruleId ?? '').includes('EVIDENCE_PREWRITE_WORKTREE');
 
+const isGoldenFlowCause = (
+  cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
+): boolean =>
+  cause.code.startsWith('GOLDEN_FLOW_') ||
+  cause.code.startsWith('TDD_') ||
+  (cause.ruleId ?? '').includes('golden_flow') ||
+  (cause.ruleId ?? '').startsWith('generic_tdd_') ||
+  (cause.ruleId ?? '').startsWith('generic_red_green_refactor');
+
+const isSkillCause = (
+  cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number]
+): boolean =>
+  (cause.ruleId ?? '').startsWith('skills.') ||
+  cause.code.startsWith('SKILLS_');
+
 const WORKTREE_HYGIENE_REMEDIATION =
   'Reduce el worktree pendiente a un slice atómico: stagea solo la tarea activa o guarda el resto en stash nombrado, y reejecuta PRE_WRITE.';
 
+const GOLDEN_FLOW_REMEDIATION =
+  'Ejecuta los tests de la implementación. Si están en verde, haz un commit atómico de los cambios.';
+
+const normalizeGoldenFlowMissingToken = (message: string): string => {
+  const missing = (extractMissingContractFromCauseMessage(message) ?? 'VERIFY passed')
+    .replace(/^Falta:\s*/u, '');
+  return missing.toUpperCase();
+};
+
+const formatGoldenFlowMissing = (message: string): string => {
+  const missing = normalizeGoldenFlowMissingToken(message);
+  if (missing.includes('RED')) {
+    return 'fase RED del ciclo TDD sin implementar';
+  }
+  if (missing.includes('GREEN')) {
+    return 'fase GREEN del ciclo TDD sin implementar';
+  }
+  if (missing.includes('REFACTOR')) {
+    return 'fase REFACTOR del ciclo TDD sin implementar';
+  }
+  if (missing.includes('VERIFY')) {
+    return 'tests finales en verde sin ejecutar antes del commit';
+  }
+  return missing.toLowerCase();
+};
+
+const formatGoldenFlowRemediation = (message: string): string => {
+  const missing = normalizeGoldenFlowMissingToken(message);
+  if (missing.includes('RED')) {
+    return 'Implementa la fase RED antes de continuar. Las fases del ciclo TDD (RED, GREEN, REFACTOR) deben completarse para desbloquear.';
+  }
+  if (missing.includes('GREEN')) {
+    return 'Implementa la fase GREEN antes de continuar. Haz el cambio mínimo para que el test pase y continúa el ciclo TDD.';
+  }
+  if (missing.includes('REFACTOR')) {
+    return 'Implementa la fase REFACTOR antes de continuar. Limpia la solución manteniendo los tests en verde.';
+  }
+  if (missing.includes('VERIFY')) {
+    return GOLDEN_FLOW_REMEDIATION;
+  }
+  return 'Completa el ciclo TDD en orden: RED, GREEN, REFACTOR y tests finales en verde antes del commit.';
+};
+
+
 const formatBlockingCauseForDialog = (
   cause: NonNullable<Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']>[number],
   index: number
 ): readonly string[] => {
   const rule = cause.ruleId ?? cause.code;
+  const visibleRule = formatVisibleRule(cause);
   const problem = stripTechnicalFieldsFromMessage(cause.message) || cause.code;
-  const remediation = isWorktreeHygieneCause(cause)
+  const remediation = isGoldenFlowCause(cause)
+    ? GOLDEN_FLOW_REMEDIATION
+    : isWorktreeHygieneCause(cause)
     ? WORKTREE_HYGIENE_REMEDIATION
     : cause.remediation
     ? normalizeNotificationText(cause.remediation)
@@ -127,9 +234,17 @@ const formatBlockingCauseForDialog = (
       `   Solución: ${truncateNotificationText(WORKTREE_HYGIENE_REMEDIATION, 180)}`,
     ];
   }
+  if (isGoldenFlowCause(cause)) {
+    return [
+      `${index + 1}. Causa bloqueante: Violación del ciclo TDD`,
+      `   Registro TDD: ${truncateNotificationText(formatLocation(cause), 120)}`,
+      `   Falta: ${truncateNotificationText(formatGoldenFlowMissing(cause.message), 120)}`,
+    ];
+  }
 
+  const causeLabel = isSkillCause(cause) ? 'Regla' : 'Causa bloqueante';
   return [
-    `${index + 1}. Regla: ${truncateNotificationText(rule, 96)}`,
+    `${index + 1}. ${causeLabel}: ${truncateNotificationText(visibleRule, 96)}`,
     `   Fichero: ${truncateNotificationText(formatLocation(cause), 120)}`,
     `   Viola: ${truncateNotificationText(problem, 160)}`,
     buildEvidenceLine(cause),
@@ -142,6 +257,18 @@ const hasOnlyWorktreeHygieneCauses = (
 ): boolean =>
   Boolean(causes?.length) && causes!.every(isWorktreeHygieneCause);
 
+const hasOnlyGoldenFlowCauses = (
+  causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
+): boolean =>
+  Boolean(causes?.length) && causes!.every(isGoldenFlowCause);
+
+const resolveGoldenFlowDialogRemediation = (
+  causes: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>['blockingCauses']
+): string => {
+  const first = causes?.find(isGoldenFlowCause);
+  return first ? formatGoldenFlowRemediation(first.message) : GOLDEN_FLOW_REMEDIATION;
+};
+
 export const buildBlockedDialogPayload = (params: {
   event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>;
   repoRoot: string;
@@ -152,6 +279,8 @@ export const buildBlockedDialogPayload = (params: {
     ?? resolveBlockedCauseSummary(params.event, causeCode);
   const remediation = hasOnlyWorktreeHygieneCauses(params.event.blockingCauses)
     ? WORKTREE_HYGIENE_REMEDIATION
+    : hasOnlyGoldenFlowCauses(params.event.blockingCauses)
+    ? resolveGoldenFlowDialogRemediation(params.event.blockingCauses)
     : params.event.blockingCauses && params.event.blockingCauses.length > 0
     ? 'Corrige las violaciones listadas y vuelve a intentar el commit.'
     : resolveBlockedRemediation(params.event, causeCode);

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

@@ -26,6 +26,40 @@ const isSkillCause = (cause: BlockedCause): boolean => {
   return ruleId.startsWith('skills.') || code.startsWith('SKILLS_');
 };
 
+const isGoldenFlowCause = (cause: BlockedCause): boolean => {
+  const ruleId = cause.ruleId ?? '';
+  const code = cause.code ?? '';
+  return (
+    code.startsWith('GOLDEN_FLOW_') ||
+    code.startsWith('TDD_') ||
+    ruleId.includes('golden_flow') ||
+    ruleId.startsWith('generic_tdd_') ||
+    ruleId.startsWith('generic_red_green_refactor')
+  );
+};
+
+const normalizeGoldenFlowMissingToken = (message: string): string => {
+  const match = message.match(/missing=\[([^\]]+)\]/i);
+  return (match?.[1] ?? '').toUpperCase();
+};
+
+const formatGoldenFlowBannerRemediation = (cause: BlockedCause): string => {
+  const missing = normalizeGoldenFlowMissingToken(cause.message);
+  if (missing.includes('RED')) {
+    return 'Implementa la fase RED antes de continuar. Las fases del ciclo TDD (RED, GREEN, REFACTOR) deben completarse para desbloquear.';
+  }
+  if (missing.includes('GREEN')) {
+    return 'Implementa la fase GREEN antes de continuar. Haz el cambio mínimo para que el test pase y continúa el ciclo TDD.';
+  }
+  if (missing.includes('REFACTOR')) {
+    return 'Implementa la fase REFACTOR antes de continuar. Limpia la solución manteniendo los tests en verde.';
+  }
+  if (missing.includes('VERIFY')) {
+    return 'Ejecuta los tests de la implementación. Si están en verde, haz un commit atómico de los cambios.';
+  }
+  return 'Completa el ciclo TDD en orden: RED, GREEN, REFACTOR y tests finales en verde antes del commit.';
+};
+
 const formatCauseLocation = (cause: BlockedCause): string => {
   if (!cause.file) {
     return 'sin fichero';
@@ -40,6 +74,45 @@ const formatCauseLocation = (cause: BlockedCause): string => {
 
 const formatCauseRule = (cause: BlockedCause): string => cause.ruleId ?? cause.code;
 
+const humanizeRuleId = (ruleId: string): string => {
+  const knownRules: Record<string, string> = {
+    'prefer-swift-testing': 'Swift Testing',
+    'no-xctassert': 'XCTest assertions',
+    'no-wait-for-expectations': 'waitForExpectations en XCTest',
+    'ios-test-quality': 'calidad de tests iOS',
+    'dynamic-type-font-scaling-automatico': 'Dynamic Type',
+    'dynamic-type-fuentes-escalables-y-layouts-adaptativos': 'fuentes escalables y layouts adaptativos',
+    'use-relative-layout-over-hard-coded-constants': 'layout relativo en vez de constantes fijas',
+    'magic-numbers-usar-constantes-con-nombres': 'números mágicos sin constantes con nombre',
+    'prefer-static-member-lookup-blue-vs-color-blue': 'colores semánticos en SwiftUI',
+  };
+  const normalized = ruleId
+    .replace(/^skills\./u, '')
+    .replace(/^governance\./u, '')
+    .replace(/^ai_gate\./u, '')
+    .replace(/_/gu, '-');
+  const parts = normalized.split('.').filter(Boolean);
+  const leaf = parts.at(-1) ?? normalized;
+  if (knownRules[leaf]) {
+    return knownRules[leaf];
+  }
+  return leaf
+    .replace(/-/gu, ' ')
+    .replace(/\bios\b/giu, 'iOS')
+    .replace(/\bui\b/giu, 'UI')
+    .replace(/\bapi\b/giu, 'API')
+    .replace(/\btdd\b/giu, 'TDD')
+    .replace(/\bsdd\b/giu, 'SDD')
+    .replace(/\bguard\b/giu, 'guard')
+    .trim();
+};
+
+const formatVisibleRule = (cause: BlockedCause): string => {
+  const ruleId = formatCauseRule(cause);
+  const readable = humanizeRuleId(ruleId);
+  return readable.length > 0 ? readable : ruleId;
+};
+
 const extractMessageField = (message: string, field: string): string | null => {
   const escapedField = field.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const match = message.match(new RegExp(`\\b${escapedField}=([^\\n]+?)(?=\\s(?:severity|code|rule|file|lines?|message|remediation|snippet|node|primary_node|missing)=|$)`, 'i'));
@@ -85,6 +158,11 @@ export const resolvePrioritizedBlockingCauses = (
     if (leftSkill !== rightSkill) {
       return leftSkill ? -1 : 1;
     }
+    const leftGoldenFlow = isGoldenFlowCause(left);
+    const rightGoldenFlow = isGoldenFlowCause(right);
+    if (leftGoldenFlow !== rightGoldenFlow) {
+      return leftGoldenFlow ? -1 : 1;
+    }
     return 0;
   });
 };
@@ -103,7 +181,10 @@ const buildBlockingCausesSummary = (
   const prefix = isSkillCause(first) ? 'Skill violada' : 'Causa bloqueante';
   const overflow = prioritized.length > 1 ? ` (+${prioritized.length - 1} más)` : '';
   if (isSkillCause(first)) {
-    return `${prefix}: ${formatCauseLocation(first)} · ${formatCauseRule(first)}${overflow}`;
+    return `${prefix}: ${formatCauseLocation(first)} · ${formatVisibleRule(first)}${overflow}`;
+  }
+  if (isGoldenFlowCause(first)) {
+    return `Violación del ciclo TDD${overflow}`;
   }
   return `${prefix}: ${formatCauseRule(first)} · ${formatCauseLocation(first)}${overflow}`;
 };
@@ -121,7 +202,7 @@ const buildBlockingCausesRemediation = (
   }
   if (isSkillCause(first)) {
     return [
-      `Regla: ${formatCauseRule(first)}.`,
+      `Regla: ${formatVisibleRule(first)}.`,
       `Fichero: ${formatCauseLocation(first)}.`,
       `Viola: ${formatCauseProblem(first)}.`,
       `Solución: ${formatCauseFix(first)}.`,
@@ -130,6 +211,9 @@ const buildBlockingCausesRemediation = (
       .filter((line) => line.length > 0)
       .join(' ');
   }
+  if (isGoldenFlowCause(first)) {
+    return formatGoldenFlowBannerRemediation(first);
+  }
   return `${formatCauseFix(first)} Revisa el reporte completo para el resto de causas bloqueantes.`;
 };
 
@@ -140,7 +224,7 @@ export const buildGateBlockedPayload = (
   const causeCode = event.causeCode ?? 'GATE_BLOCKED';
   const causeSummary = truncateNotificationText(
     buildBlockingCausesSummary(event.blockingCauses) ?? resolveBlockedCauseSummary(event, causeCode),
-    72
+    96
   );
   const remediation =
     buildBlockingCausesRemediation(event.blockingCauses) ?? resolveBlockedRemediation(event, causeCode);