pumuki 6.3.97 → 6.3.99

package/scripts/pumuki-full-surface-smoke.ts

@@ -0,0 +1,346 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+  installedBinMarkerPath,
+  resolveSmokeLayout,
+} from './pumuki-full-surface-smoke-lib';
+
+type SmokeRowKind = 'core' | 'diagnostic';
+
+type SmokeRow = {
+  id: string;
+  bin: string;
+  args: ReadonlyArray<string>;
+  timeoutMs: number;
+  allowNonZero?: boolean;
+  kind: SmokeRowKind;
+};
+
+const parseBooleanEnv = (raw: string | undefined): boolean => {
+  const value = (raw ?? '').trim().toLowerCase();
+  return value === '1' || value === 'true' || value === 'yes';
+};
+
+const includeDiagnosticRowsInStrict = parseBooleanEnv(
+  process.env.PUMUKI_SMOKE_INCLUDE_DIAGNOSTIC_ROWS
+);
+
+const layout = resolveSmokeLayout({
+  scriptFileUrl: import.meta.url,
+  env: process.env,
+});
+
+const { pumukiPackageRoot, smokeCwd, binStrategy, binRoot } = layout;
+const node = process.execPath;
+const binPath = (name: string): string => join(binRoot, 'bin', name);
+
+const run = (row: SmokeRow): { code: number | null; signal: NodeJS.Signals | null; ms: number } => {
+  const started = Date.now();
+  const r = spawnSync(node, [binPath(row.bin), ...row.args], {
+    cwd: smokeCwd,
+    encoding: 'utf8',
+    timeout: row.timeoutMs,
+    maxBuffer: 50 * 1024 * 1024,
+    env: { ...process.env, FORCE_COLOR: '0' },
+  });
+  return { code: r.status, signal: r.signal, ms: Date.now() - started };
+};
+
+const rows: ReadonlyArray<SmokeRow> = [
+  { id: 'cli.help_implicit', bin: 'pumuki.js', args: [], timeoutMs: 15_000, kind: 'core', allowNonZero: true },
+  { id: 'cli.help_explicit', bin: 'pumuki.js', args: ['--help'], timeoutMs: 15_000, kind: 'core' },
+  {
+    id: 'cli.unknown_subcommand',
+    bin: 'pumuki.js',
+    args: ['__no_such_lifecycle_command__'],
+    timeoutMs: 15_000,
+    kind: 'core',
+    allowNonZero: true,
+  },
+  { id: 'doctor.json', bin: 'pumuki.js', args: ['doctor', '--json'], timeoutMs: 60_000, kind: 'core' },
+  {
+    id: 'doctor.deep_json',
+    bin: 'pumuki.js',
+    args: ['doctor', '--deep', '--json'],
+    timeoutMs: 180_000,
+    kind: 'core',
+    allowNonZero: true,
+  },
+  { id: 'doctor.parity_json', bin: 'pumuki.js', args: ['doctor', '--parity', '--json'], timeoutMs: 120_000, kind: 'core' },
+  { id: 'status.json', bin: 'pumuki.js', args: ['status', '--json'], timeoutMs: 90_000, kind: 'core' },
+  {
+    id: 'audit.default_json',
+    bin: 'pumuki.js',
+    args: ['audit', '--json'],
+    timeoutMs: 300_000,
+    kind: 'core',
+    allowNonZero: true,
+  },
+  {
+    id: 'audit.pre_push_json',
+    bin: 'pumuki.js',
+    args: ['audit', '--stage=PRE_PUSH', '--json'],
+    timeoutMs: 300_000,
+    kind: 'core',
+    allowNonZero: true,
+  },
+  {
+    id: 'audit.ci_engine_json',
+    bin: 'pumuki.js',
+    args: ['audit', '--stage=CI', '--engine', '--json'],
+    timeoutMs: 300_000,
+    kind: 'core',
+    allowNonZero: true,
+  },
+  {
+    id: 'watch.once_json',
+    bin: 'pumuki.js',
+    args: [
+      'watch',
+      '--once',
+      '--json',
+      '--stage=PRE_COMMIT',
+      '--scope=repo',
+      '--interval-ms=200',
+      '--no-notify',
+    ],
+    timeoutMs: 180_000,
+    kind: 'diagnostic',
+  },
+  {
+    id: 'watch.once_staged_json',
+    bin: 'pumuki.js',
+    args: [
+      'watch',
+      '--once',
+      '--json',
+      '--stage=PRE_COMMIT',
+      '--scope=staged',
+      '--interval-ms=200',
+      '--no-notify',
+    ],
+    timeoutMs: 180_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'loop.list_json',
+    bin: 'pumuki.js',
+    args: ['loop', 'list', '--json'],
+    timeoutMs: 30_000,
+    kind: 'core',
+  },
+  {
+    id: 'loop.run_smoke',
+    bin: 'pumuki.js',
+    args: ['loop', 'run', '--objective=smoke-surface', '--max-attempts=1', '--json'],
+    timeoutMs: 300_000,
+    kind: 'core',
+    allowNonZero: true,
+  },
+  {
+    id: 'adapter.install_dry_repo_json',
+    bin: 'pumuki.js',
+    args: ['adapter', 'install', '--agent=repo', '--dry-run', '--json'],
+    timeoutMs: 30_000,
+    kind: 'core',
+  },
+  {
+    id: 'adapter.install_dry_codex_json',
+    bin: 'pumuki.js',
+    args: ['adapter', 'install', '--agent=codex', '--dry-run', '--json'],
+    timeoutMs: 30_000,
+    kind: 'core',
+  },
+  {
+    id: 'analytics.hotspots_report',
+    bin: 'pumuki.js',
+    args: ['analytics', 'hotspots', 'report', '--top=3', '--since-days=30', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'analytics.hotspots_diagnose',
+    bin: 'pumuki.js',
+    args: ['analytics', 'hotspots', 'diagnose', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'policy.reconcile_json',
+    bin: 'pumuki.js',
+    args: ['policy', 'reconcile', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'policy.reconcile_strict_json',
+    bin: 'pumuki.js',
+    args: ['policy', 'reconcile', '--strict', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'sdd.status_json',
+    bin: 'pumuki.js',
+    args: ['sdd', 'status', '--json'],
+    timeoutMs: 60_000,
+    kind: 'diagnostic',
+  },
+  {
+    id: 'sdd.validate_pre_write_json',
+    bin: 'pumuki.js',
+    args: ['sdd', 'validate', '--stage=PRE_WRITE', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'sdd.validate_precommit_json',
+    bin: 'pumuki.js',
+    args: ['sdd', 'validate', '--stage=PRE_COMMIT', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'sdd.validate_prepush_json',
+    bin: 'pumuki.js',
+    args: ['sdd', 'validate', '--stage=PRE_PUSH', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'sdd.validate_ci_json',
+    bin: 'pumuki.js',
+    args: ['sdd', 'validate', '--stage=CI', '--json'],
+    timeoutMs: 120_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'hook.pre_write',
+    bin: 'pumuki-pre-write.js',
+    args: [],
+    timeoutMs: 300_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'hook.pre_commit',
+    bin: 'pumuki-pre-commit.js',
+    args: [],
+    timeoutMs: 300_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'hook.pre_push',
+    bin: 'pumuki-pre-push.js',
+    args: [],
+    timeoutMs: 300_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+  {
+    id: 'hook.ci',
+    bin: 'pumuki-ci.js',
+    args: [],
+    timeoutMs: 300_000,
+    kind: 'diagnostic',
+    allowNonZero: true,
+  },
+];
+
+const main = (): number => {
+  if (binStrategy === 'installed') {
+    const marker = installedBinMarkerPath(layout);
+    if (!existsSync(marker)) {
+      process.stderr.write(
+        `[pumuki] smoke: PUMUKI_SMOKE_BIN_STRATEGY=installed pero no existe ${marker}. ` +
+          'Ejecuta npm install en el consumidor o revisa PUMUKI_SMOKE_REPO_ROOT.\n'
+      );
+      return 2;
+    }
+  }
+
+  const lines: string[] = [];
+  lines.push('# Pumuki superficie — smoke');
+  lines.push('');
+  lines.push(`- binStrategy: \`${binStrategy}\` (PUMUKI_SMOKE_BIN_STRATEGY=source|installed)`);
+  lines.push(`- binRoot: \`${binRoot}\``);
+  lines.push(`- pumukiPackageRoot (script host): \`${pumukiPackageRoot}\``);
+  lines.push(`- smokeCwd (gate/doctor cwd): \`${smokeCwd}\``);
+  lines.push(`- node: \`${node}\``);
+  lines.push(
+    `- filas: **${rows.length}** (incluye CLI, doctor/status, audit×3, watch×2, loop, adapter×2, analytics×2, policy×2, sdd×5, hooks×4)`
+  );
+  lines.push(
+    `- modo: \`${includeDiagnosticRowsInStrict ? 'strict+diagnostic' : 'strict-only'}\`` +
+      ' (activar diagnóstico con `PUMUKI_SMOKE_INCLUDE_DIAGNOSTIC_ROWS=1`)'
+  );
+  lines.push('');
+  lines.push('| id | tipo | exit | ms | ok |');
+  lines.push('|----|----|------|----|----|');
+  let strictFailed = 0;
+  let diagnosticFailed = 0;
+  for (const row of rows) {
+    const { code, signal, ms } = run(row);
+    const exit = signal ? `signal:${signal}` : String(code ?? 'null');
+    const ok =
+      signal !== null
+        ? false
+        : row.allowNonZero
+          ? true
+          : code === 0;
+    const isStrict = row.kind === 'core' || includeDiagnosticRowsInStrict;
+    if (!ok) {
+      if (isStrict) {
+        strictFailed += 1;
+      } else {
+        diagnosticFailed += 1;
+      }
+    }
+    lines.push(`| ${row.id} | ${row.kind} | ${exit} | ${ms} | ${ok ? 'yes' : 'no'} |`);
+  }
+  lines.push('');
+  lines.push('## Interpretación de exit codes');
+  lines.push('');
+  lines.push('- `audit` devuelve el **mismo código que el gate** del alcance auditado (p. ej. 1 si hay `BLOCK` en el repo). Eso es correcto, no indica CLI roto.');
+  lines.push('- `doctor --deep` puede devolver **1** si `doctorHasBlockingIssues` (issues `error` o `deep.blocking`) o mismatch de parity esperado.');
+  lines.push('- Los comandos de diagnóstico (`diagnostic`) quedan fuera de fallo estricto por defecto.');
+  lines.push('- `sdd validate` y `policy reconcile --strict` pueden devolver **1** según política del repo; el smoke los marca con `allowNonZero`.');
+  lines.push('');
+  lines.push('## No cubierto aquí (manual o destructivo)');
+  lines.push('');
+  lines.push('- `pumuki install|uninstall|remove|update|bootstrap` (mutan hooks/artefactos).');
+  lines.push('- `pumuki framework` / menú interactivo (`pumuki-framework.js`).');
+  lines.push('- Servidores MCP stdio (`pumuki-mcp-*-stdio.js`): esperan JSON-RPC por stdin; probar con cliente MCP.');
+  lines.push('- `pumuki sdd session|sync|learn|evidence|state-sync|auto-sync`: requieren ids / evidencia / cambios reales.');
+  lines.push('- `pumuki doctor|status --remote-checks`: dependen de red / GitHub.');
+  lines.push('');
+  lines.push('## Otro repo (consumidor)');
+  lines.push('');
+  lines.push(
+    '- **Bins del tree pumuki (desarrollo):** `PUMUKI_SMOKE_REPO_ROOT=/ruta/al/repo npm run -s smoke:pumuki-surface` desde la raíz de **pumuki** (`PUMUKI_SMOKE_BIN_STRATEGY=source` por defecto).'
+  );
+  lines.push(
+    '- **Bins instalados en el consumidor (`node_modules/pumuki`):** `PUMUKI_SMOKE_REPO_ROOT=/ruta/al/repo PUMUKI_SMOKE_BIN_STRATEGY=installed npm run -s smoke:pumuki-surface` o `npm run -s smoke:pumuki-surface-installed` (exige `PUMUKI_SMOKE_REPO_ROOT`).'
+  );
+  lines.push('');
+  lines.push(
+    `**Resumen:** ${strictFailed} filas críticas con fallo estricto (sin allowNonZero),` +
+      ` ${diagnosticFailed} filas diagnósticas con fallo no bloqueante.`
+  );
+  process.stdout.write(lines.join('\n'));
+  process.stdout.write('\n');
+  return strictFailed > 0 ? 1 : 0;
+};
+
+process.exitCode = main();

package/scripts/pumuki-smoke-installed-wrapper.cjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+const { join } = require('node:path');
+
+if (!process.env.PUMUKI_SMOKE_REPO_ROOT || !String(process.env.PUMUKI_SMOKE_REPO_ROOT).trim()) {
+  console.error(
+    '[pumuki] smoke:pumuki-surface-installed requires PUMUKI_SMOKE_REPO_ROOT (absolute path to consumer repo).'
+  );
+  process.exit(1);
+}
+
+const root = join(__dirname, '..');
+const env = {
+  ...process.env,
+  PUMUKI_SMOKE_BIN_STRATEGY: 'installed',
+};
+
+const result = spawnSync(
+  'npx',
+  ['--yes', 'tsx@4.21.0', 'scripts/pumuki-full-surface-smoke.ts'],
+  {
+    cwd: root,
+    env,
+    stdio: 'inherit',
+  }
+);
+
+const code = typeof result.status === 'number' ? result.status : 1;
+process.exitCode = code;

package/integrations/evidence/trackingContract.ts

@@ -1,150 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, relative, resolve, sep } from 'node:path';
-import type { RepoTrackingDeclaration, RepoTrackingState } from './schema';
-
-const TRACKING_DECLARATION_SOURCES = [
-  'AGENTS.md',
-  'docs/README.md',
-  'docs/validation/README.md',
-  'docs/strategy/README.md',
-] as const;
-
-const TRACKING_KEYWORDS =
-  /(seguimiento|tracking interno|tracking can[oó]nico|canonical tracking|fuente viva|fuente can[oó]nica|source of truth|single source)/i;
-const TRACKING_PRIORITY_SOURCE = new Set(['AGENTS.md']);
-const IN_PROGRESS_PATTERNS = [
-  /^- Estado:\s*🚧/m,
-  /^- 🚧 (\`?P[0-9A-Za-z.-]+\`?)/m,
-  /^\`?\[\s*🚧\s*\]\s*-\`?/m,
-  /^-\s*\`?\[\s*🚧\s*\]\s*-\`?/m,
-  /^\|\s*🚧(?:\s|\|)/m,
-  /^\|[^|\n]+\|\s*🚧(?:\s|\|)/m,
-  /^\|[^|\n]+\|\s*\`?\[\s*🚧\s*\]\s*-\`?/m,
-] as const;
-
-const toRepoRelativePath = (repoRoot: string, absolutePath: string): string => {
-  const relativePath = relative(repoRoot, absolutePath).replace(/\\/g, '/');
-  return relativePath.length > 0 && !relativePath.startsWith('..') ? relativePath : absolutePath.replace(/\\/g, '/');
-};
-
-const collectDeclaredPathsFromLine = (line: string): string[] => {
-  const matches = new Set<string>();
-  for (const regex of [/`([^`]+\.md)`/g, /\[[^\]]+\]\(([^)]+\.md)\)/g]) {
-    let match: RegExpExecArray | null;
-    while ((match = regex.exec(line)) !== null) {
-      const candidate = match[1]?.trim();
-      if (candidate) {
-        matches.add(candidate);
-      }
-    }
-  }
-  return [...matches];
-};
-
-const collectTrackingDeclarations = (repoRoot: string): ReadonlyArray<RepoTrackingDeclaration> => {
-  const declarations: RepoTrackingDeclaration[] = [];
-  for (const sourceFile of TRACKING_DECLARATION_SOURCES) {
-    const absoluteSourcePath = resolve(repoRoot, sourceFile);
-    if (!existsSync(absoluteSourcePath)) {
-      continue;
-    }
-    const content = readFileSync(absoluteSourcePath, 'utf8');
-    for (const line of content.split(/\r?\n/)) {
-      if (!TRACKING_KEYWORDS.test(line)) {
-        continue;
-      }
-      for (const declaredPath of collectDeclaredPathsFromLine(line)) {
-        const resolvedPath = declaredPath.startsWith('./') || declaredPath.startsWith('../')
-          ? resolve(repoRoot, dirname(sourceFile), declaredPath)
-          : resolve(repoRoot, declaredPath);
-        declarations.push({
-          source_file: sourceFile,
-          declared_path: declaredPath,
-          resolved_path: toRepoRelativePath(repoRoot, resolvedPath),
-        });
-      }
-    }
-  }
-  const deduped = new Map<string, RepoTrackingDeclaration>();
-  for (const declaration of declarations) {
-    deduped.set(
-      `${declaration.source_file}::${declaration.resolved_path}`,
-      declaration
-    );
-  }
-  return [...deduped.values()];
-};
-
-const resolveCanonicalTrackingPath = (
-  declarations: ReadonlyArray<RepoTrackingDeclaration>
-): { canonicalPath: string | null; sourceFile: string | null; conflict: boolean } => {
-  if (declarations.length === 0) {
-    return {
-      canonicalPath: null,
-      sourceFile: null,
-      conflict: false,
-    };
-  }
-
-  const agentsDeclarations = declarations.filter((entry) => TRACKING_PRIORITY_SOURCE.has(entry.source_file));
-  const preferred = agentsDeclarations.length > 0 ? agentsDeclarations : declarations;
-  const preferredPaths = [...new Set(preferred.map((entry) => entry.resolved_path))];
-  const allPaths = [...new Set(declarations.map((entry) => entry.resolved_path))];
-
-  if (preferredPaths.length === 0) {
-    return {
-      canonicalPath: null,
-      sourceFile: null,
-      conflict: allPaths.length > 1,
-    };
-  }
-
-  const canonicalPath = preferredPaths[0] ?? null;
-  const sourceFile =
-    preferred.find((entry) => entry.resolved_path === canonicalPath)?.source_file
-    ?? null;
-  return {
-    canonicalPath,
-    sourceFile,
-    conflict: allPaths.length > 1 || preferredPaths.length > 1,
-  };
-};
-
-const countInProgressMarkers = (absolutePath: string): number => {
-  if (!existsSync(absolutePath)) {
-    return 0;
-  }
-  const content = readFileSync(absolutePath, 'utf8');
-  const matchedLines = new Set<number>();
-  const lines = content.split(/\r?\n/);
-  lines.forEach((line, index) => {
-    if (IN_PROGRESS_PATTERNS.some((pattern) => pattern.test(line))) {
-      matchedLines.add(index);
-    }
-  });
-  return matchedLines.size;
-};
-
-export const readRepoTrackingState = (repoRoot: string): RepoTrackingState => {
-  const declarations = collectTrackingDeclarations(repoRoot);
-  const enforced = declarations.length > 0;
-  const resolution = resolveCanonicalTrackingPath(declarations);
-  const canonicalAbsolutePath = resolution.canonicalPath
-    ? resolve(repoRoot, resolution.canonicalPath.split('/').join(sep))
-    : null;
-  const canonicalPresent = canonicalAbsolutePath ? existsSync(canonicalAbsolutePath) : false;
-  const inProgressCount = canonicalPresent && canonicalAbsolutePath
-    ? countInProgressMarkers(canonicalAbsolutePath)
-    : null;
-
-  return {
-    enforced,
-    canonical_path: resolution.canonicalPath,
-    canonical_present: canonicalPresent,
-    source_file: resolution.sourceFile,
-    in_progress_count: inProgressCount,
-    single_in_progress_valid: inProgressCount === null ? null : inProgressCount === 1,
-    conflict: resolution.conflict,
-    declarations,
-  };
-};