pumuki 6.3.37 → 6.3.39

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

@@ -15,6 +15,9 @@ export type PumukiCriticalNotificationEvent =
       kind: 'gate.blocked';
       stage: PumukiNotificationStage;
       totalViolations: number;
+      causeCode?: string;
+      causeMessage?: string;
+      remediation?: string;
     }
   | {
       kind: 'evidence.stale';
@@ -31,23 +34,36 @@ export type SystemNotificationPayload = {
   title: string;
   message: string;
   subtitle?: string;
+  soundName?: string;
 };
 
 export type SystemNotificationsConfig = {
   enabled: boolean;
   channel: 'macos';
+  muteUntil?: string;
 };
 
 export type SystemNotificationEmitResult =
   | { delivered: true; reason: 'delivered' }
-  | { delivered: false; reason: 'disabled' | 'unsupported-platform' | 'command-failed' };
+  | { delivered: false; reason: 'disabled' | 'muted' | 'unsupported-platform' | 'command-failed' };
 
 type SystemNotificationCommandRunner = (
   command: string,
   args: ReadonlyArray<string>
 ) => number;
 
+type SystemNotificationCommandRunnerWithOutput = (
+  command: string,
+  args: ReadonlyArray<string>
+) => {
+  exitCode: number;
+  stdout: string;
+};
+
 const SYSTEM_NOTIFICATIONS_CONFIG_PATH = '.pumuki/system-notifications.json';
+const BLOCKED_DIALOG_KEEP = 'Mantener activas';
+const BLOCKED_DIALOG_MUTE_30 = 'Silenciar 30 min';
+const BLOCKED_DIALOG_DISABLE = 'Desactivar';
 
 const escapeAppleScriptString = (value: string): string =>
   value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, ' ').trim();
@@ -58,7 +74,132 @@ const buildDisplayNotificationScript = (payload: SystemNotificationPayload): str
   const subtitleFragment = payload.subtitle
     ? ` subtitle "${escapeAppleScriptString(payload.subtitle)}"`
     : '';
-  return `display notification "${message}" with title "${title}"${subtitleFragment}`;
+  const soundFragment = payload.soundName
+    ? ` sound name "${escapeAppleScriptString(payload.soundName)}"`
+    : '';
+  return `display notification "${message}" with title "${title}"${subtitleFragment}${soundFragment}`;
+};
+
+const buildDisplayDialogScript = (params: {
+  title: string;
+  cause: string;
+  remediation: string;
+}): string => {
+  const title = escapeAppleScriptString(params.title);
+  const cause = escapeAppleScriptString(params.cause);
+  const remediation = escapeAppleScriptString(params.remediation);
+  const message = escapeAppleScriptString(`Causa: ${cause}\n\nSolución: ${remediation}`);
+  return `display dialog "${message}" with title "${title}" buttons {"${BLOCKED_DIALOG_DISABLE}", "${BLOCKED_DIALOG_MUTE_30}", "${BLOCKED_DIALOG_KEEP}"} default button "${BLOCKED_DIALOG_KEEP}" with icon stop giving up after 15`;
+};
+
+const normalizeNotificationText = (value: string): string =>
+  value.replace(/\s+/g, ' ').trim();
+
+const truncateNotificationText = (value: string, maxLength: number): string => {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(1, maxLength - 1)).trimEnd()}…`;
+};
+
+const isTruthyFlag = (value?: string): boolean => {
+  if (!value) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+};
+
+const BLOCKED_CAUSE_SUMMARY_BY_CODE: Readonly<Record<string, string>> = {
+  EVIDENCE_MISSING: 'Falta evidencia para validar este paso.',
+  EVIDENCE_INVALID: 'La evidencia actual es inválida.',
+  EVIDENCE_CHAIN_INVALID: 'La cadena de evidencia no es válida.',
+  EVIDENCE_STALE: 'La evidencia está desactualizada.',
+  EVIDENCE_BRANCH_MISMATCH: 'La evidencia no corresponde con la rama actual.',
+  EVIDENCE_REPO_ROOT_MISMATCH: 'La evidencia no corresponde con este repositorio.',
+  PRE_PUSH_UPSTREAM_MISSING: 'La rama no tiene upstream configurado.',
+  GITFLOW_PROTECTED_BRANCH: 'No se permiten cambios directos en esta rama protegida.',
+  SDD_SESSION_MISSING: 'No hay sesión SDD activa.',
+  SDD_SESSION_INVALID: 'La sesión SDD actual no es válida.',
+  OPENSPEC_MISSING: 'OpenSpec no está instalado en este repositorio.',
+  MCP_ENTERPRISE_RECEIPT_MISSING: 'Falta el recibo enterprise de MCP.',
+  BACKEND_AVOID_EXPLICIT_ANY: 'Se detectó uso de "any" explícito en backend.',
+};
+
+const BLOCKED_REMEDIATION_BY_CODE: Readonly<Record<string, string>> = {
+  EVIDENCE_MISSING: 'Genera evidencia y vuelve a ejecutar el gate.',
+  EVIDENCE_INVALID: 'Regenera la evidencia antes de reintentar.',
+  EVIDENCE_CHAIN_INVALID: 'Regenera evidencia para reparar la cadena criptográfica.',
+  EVIDENCE_STALE: 'Refresca la evidencia y vuelve a intentarlo.',
+  EVIDENCE_BRANCH_MISMATCH: 'Regenera evidencia en esta rama y reintenta.',
+  EVIDENCE_REPO_ROOT_MISMATCH: 'Regenera evidencia desde este repositorio.',
+  PRE_PUSH_UPSTREAM_MISSING: 'Ejecuta: git push --set-upstream origin <branch>.',
+  SDD_SESSION_MISSING: 'Abre sesión SDD y vuelve a intentar.',
+  SDD_SESSION_INVALID: 'Refresca la sesión SDD y vuelve a intentar.',
+  OPENSPEC_MISSING: 'Instala OpenSpec y reintenta la validación.',
+  MCP_ENTERPRISE_RECEIPT_MISSING: 'Genera el receipt enterprise de MCP antes de continuar.',
+  BACKEND_AVOID_EXPLICIT_ANY: 'Tipa el valor y elimina "any" explícito en backend.',
+};
+
+const toKnownSpanishCauseFromMessage = (message: string): string | null => {
+  const normalized = message.toLowerCase();
+  if (normalized.includes('avoid explicit any')) {
+    return BLOCKED_CAUSE_SUMMARY_BY_CODE.BACKEND_AVOID_EXPLICIT_ANY;
+  }
+  if (normalized.includes('evidence is stale')) {
+    return BLOCKED_CAUSE_SUMMARY_BY_CODE.EVIDENCE_STALE;
+  }
+  if (normalized.includes('no upstream tracking reference')) {
+    return BLOCKED_CAUSE_SUMMARY_BY_CODE.PRE_PUSH_UPSTREAM_MISSING;
+  }
+  return null;
+};
+
+const toKnownSpanishRemediationFromMessage = (message: string): string | null => {
+  const normalized = message.toLowerCase();
+  if (normalized.includes('avoid explicit any')) {
+    return BLOCKED_REMEDIATION_BY_CODE.BACKEND_AVOID_EXPLICIT_ANY;
+  }
+  if (normalized.includes('set-upstream')) {
+    return BLOCKED_REMEDIATION_BY_CODE.PRE_PUSH_UPSTREAM_MISSING;
+  }
+  if (normalized.includes('refresh evidence')) {
+    return BLOCKED_REMEDIATION_BY_CODE.EVIDENCE_STALE;
+  }
+  return null;
+};
+
+const resolveBlockedCauseSummary = (event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>, causeCode: string): string => {
+  const mapped = BLOCKED_CAUSE_SUMMARY_BY_CODE[causeCode];
+  if (mapped) {
+    return mapped;
+  }
+  if (event.causeMessage && event.causeMessage.trim().length > 0) {
+    const rawMessage = normalizeNotificationText(event.causeMessage).replace(/^[A-Z0-9_]+:\s*/, '');
+    const translated = toKnownSpanishCauseFromMessage(rawMessage);
+    if (translated) {
+      return translated;
+    }
+    return truncateNotificationText(rawMessage, 72);
+  }
+  return `Se detectaron ${event.totalViolations} bloqueos en ${event.stage}.`;
+};
+
+const resolveBlockedRemediation = (event: Extract<PumukiCriticalNotificationEvent, { kind: 'gate.blocked' }>, causeCode: string): string => {
+  const fromEvent = event.remediation
+    ? normalizeNotificationText(event.remediation).replace(/^cómo solucionarlo:\s*/i, '').replace(/^remediation:\s*/i, '')
+    : '';
+  if (fromEvent.length > 0) {
+    const translated = toKnownSpanishRemediationFromMessage(fromEvent);
+    if (translated) {
+      return truncateNotificationText(translated, 88);
+    }
+    return truncateNotificationText(fromEvent, 88);
+  }
+  const fallback =
+    BLOCKED_REMEDIATION_BY_CODE[causeCode]
+    ?? 'Corrige el bloqueo indicado y vuelve a ejecutar el comando.';
+  return truncateNotificationText(fallback, 88);
 };
 
 const runSystemCommand: SystemNotificationCommandRunner = (command, args) => {
@@ -70,6 +211,43 @@ const runSystemCommand: SystemNotificationCommandRunner = (command, args) => {
   }
 };
 
+const runSystemCommandWithOutput: SystemNotificationCommandRunnerWithOutput = (
+  command,
+  args
+) => {
+  try {
+    const stdout = runBinarySync(command, [...args], {
+      encoding: 'utf8',
+    });
+    return {
+      exitCode: 0,
+      stdout: typeof stdout === 'string' ? stdout : '',
+    };
+  } catch (error: unknown) {
+    const fallbackStdout =
+      typeof error === 'object' &&
+      error !== null &&
+      'stdout' in error &&
+      typeof (error as { stdout?: unknown }).stdout === 'string'
+        ? (error as { stdout: string }).stdout
+        : '';
+    return {
+      exitCode: 1,
+      stdout: fallbackStdout,
+    };
+  }
+};
+
+const persistSystemNotificationsConfigFile = (
+  repoRoot: string,
+  config: SystemNotificationsConfig
+): string => {
+  const configPath = join(repoRoot, SYSTEM_NOTIFICATIONS_CONFIG_PATH);
+  mkdirSync(join(repoRoot, '.pumuki'), { recursive: true });
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  return configPath;
+};
+
 export const buildSystemNotificationsConfigFromSelection = (
   enabled: boolean
 ): SystemNotificationsConfig => ({
@@ -78,14 +256,10 @@ export const buildSystemNotificationsConfigFromSelection = (
 });
 
 export const persistSystemNotificationsConfig = (repoRoot: string, enabled: boolean): string => {
-  const configPath = join(repoRoot, SYSTEM_NOTIFICATIONS_CONFIG_PATH);
-  mkdirSync(join(repoRoot, '.pumuki'), { recursive: true });
-  writeFileSync(
-    configPath,
-    `${JSON.stringify(buildSystemNotificationsConfigFromSelection(enabled), null, 2)}\n`,
-    'utf8'
+  return persistSystemNotificationsConfigFile(
+    repoRoot,
+    buildSystemNotificationsConfigFromSelection(enabled)
   );
-  return configPath;
 };
 
 export const readSystemNotificationsConfig = (repoRoot: string): SystemNotificationsConfig => {
@@ -98,16 +272,67 @@ export const readSystemNotificationsConfig = (repoRoot: string): SystemNotificat
     const parsed = JSON.parse(readFileSync(configPath, 'utf8')) as {
       enabled?: unknown;
       channel?: unknown;
+      muteUntil?: unknown;
     };
-    return {
+    const config: SystemNotificationsConfig = {
       enabled: parsed.enabled === true,
       channel: 'macos',
     };
+    if (typeof parsed.muteUntil === 'string' && parsed.muteUntil.trim().length > 0) {
+      config.muteUntil = parsed.muteUntil;
+    }
+    return config;
   } catch {
     return buildSystemNotificationsConfigFromSelection(true);
   }
 };
 
+const isMutedAt = (config: SystemNotificationsConfig, nowMs: number): boolean => {
+  if (!config.muteUntil) {
+    return false;
+  }
+  const parsed = Date.parse(config.muteUntil);
+  if (!Number.isFinite(parsed)) {
+    return false;
+  }
+  return parsed > nowMs;
+};
+
+const extractDialogButton = (stdout: string): string | null => {
+  const match = stdout.match(/button returned:(.+)/i);
+  if (!match || !match[1]) {
+    return null;
+  }
+  return match[1].trim();
+};
+
+const applyDialogChoice = (params: {
+  repoRoot: string;
+  config: SystemNotificationsConfig;
+  button: string;
+  nowMs: number;
+}): void => {
+  if (params.button === BLOCKED_DIALOG_KEEP) {
+    return;
+  }
+  if (params.button === BLOCKED_DIALOG_DISABLE) {
+    persistSystemNotificationsConfigFile(params.repoRoot, {
+      enabled: false,
+      channel: params.config.channel,
+    });
+    return;
+  }
+  if (params.button === BLOCKED_DIALOG_MUTE_30) {
+    const minutes = 30;
+    const muteUntil = new Date(params.nowMs + minutes * 60_000).toISOString();
+    persistSystemNotificationsConfigFile(params.repoRoot, {
+      enabled: true,
+      channel: params.config.channel,
+      muteUntil,
+    });
+  }
+};
+
 export const buildSystemNotificationPayload = (
   event: PumukiCriticalNotificationEvent
 ): SystemNotificationPayload => {
@@ -137,23 +362,30 @@ export const buildSystemNotificationPayload = (
   }
 
   if (event.kind === 'gate.blocked') {
+    const causeCode = event.causeCode ?? 'GATE_BLOCKED';
+    const causeSummary = truncateNotificationText(
+      resolveBlockedCauseSummary(event, causeCode),
+      72
+    );
+    const remediation = resolveBlockedRemediation(event, causeCode);
     return {
-      title: 'Pumuki · Gate BLOCK',
-      subtitle: event.stage,
-      message: `Detected ${event.totalViolations} blocking violations in stage ${event.stage}.`,
+      title: '🔴 Pumuki bloqueado',
+      subtitle: `${event.stage} · ${causeSummary}`,
+      message: `Solución: ${remediation}`,
+      soundName: 'Basso',
     };
   }
 
   if (event.kind === 'evidence.stale') {
     return {
-      title: 'Pumuki · Evidence Stale',
-      message: `${event.evidencePath} is stale (${event.ageMinutes} minutes old). Refresh evidence before continue.`,
+      title: '🟡 Pumuki · evidencia desactualizada',
+      message: `Actualiza evidencia (${event.ageMinutes} min): ${event.evidencePath}.`,
     };
   }
 
   return {
-    title: 'Pumuki · Git-Flow Violation',
-    message: `Branch ${event.currentBranch} violates git-flow (${event.reason}).`,
+    title: '🔴 Pumuki · bloqueo GitFlow',
+    message: `La rama ${event.currentBranch} no cumple GitFlow (${event.reason}).`,
   };
 };
 
@@ -161,8 +393,11 @@ export const emitSystemNotification = (params: {
   event: PumukiCriticalNotificationEvent;
   platform?: NodeJS.Platform;
   runCommand?: SystemNotificationCommandRunner;
+  runCommandWithOutput?: SystemNotificationCommandRunnerWithOutput;
   repoRoot?: string;
   config?: SystemNotificationsConfig;
+  env?: NodeJS.ProcessEnv;
+  now?: () => number;
 }): SystemNotificationEmitResult => {
   const config =
     params.config ??
@@ -172,6 +407,10 @@ export const emitSystemNotification = (params: {
   if (!config.enabled) {
     return { delivered: false, reason: 'disabled' };
   }
+  const nowMs = (params.now ?? Date.now)();
+  if (isMutedAt(config, nowMs)) {
+    return { delivered: false, reason: 'muted' };
+  }
 
   const platform = params.platform ?? process.platform;
   if (platform !== 'darwin') {
@@ -187,5 +426,30 @@ export const emitSystemNotification = (params: {
     return { delivered: false, reason: 'command-failed' };
   }
 
+  const env = params.env ?? process.env;
+  if (params.event.kind === 'gate.blocked' && isTruthyFlag(env.PUMUKI_MACOS_BLOCKED_DIALOG)) {
+    const causeCode = params.event.causeCode ?? 'GATE_BLOCKED';
+    const cause = resolveBlockedCauseSummary(params.event, causeCode);
+    const remediation = resolveBlockedRemediation(params.event, causeCode);
+    const dialogScript = buildDisplayDialogScript({
+      title: '🔴 Pumuki bloqueado',
+      cause,
+      remediation,
+    });
+    const dialogRunner = params.runCommandWithOutput ?? runSystemCommandWithOutput;
+    const dialogResult = dialogRunner('osascript', ['-e', dialogScript]);
+    if (dialogResult.exitCode === 0 && params.repoRoot) {
+      const selectedButton = extractDialogButton(dialogResult.stdout);
+      if (selectedButton) {
+        applyDialogChoice({
+          repoRoot: params.repoRoot,
+          config,
+          button: selectedButton,
+          nowMs,
+        });
+      }
+    }
+  }
+
   return { delivered: true, reason: 'delivered' };
 };