pumuki 6.3.26 → 6.3.28

package/scripts/p9-ruralgo-baseline-versioned-lib.ts

@@ -0,0 +1,119 @@
+export type P9RuralgoBaselineVersionedIssueCode =
+  | 'NOT_GIT_REPO'
+  | 'OPENSPEC_PROJECT_MISSING'
+  | 'OPENSPEC_ARCHIVE_GITKEEP_MISSING'
+  | 'OPENSPEC_SPECS_GITKEEP_MISSING'
+  | 'AI_EVIDENCE_MISSING'
+  | 'OPENSPEC_PROJECT_UNTRACKED'
+  | 'OPENSPEC_ARCHIVE_GITKEEP_UNTRACKED'
+  | 'OPENSPEC_SPECS_GITKEEP_UNTRACKED'
+  | 'AI_EVIDENCE_UNTRACKED';
+
+export type P9RuralgoBaselineVersionedIssue = {
+  code: P9RuralgoBaselineVersionedIssueCode;
+  severity: 'error' | 'warning';
+  message: string;
+};
+
+export type P9RuralgoBaselineVersionedSnapshot = {
+  isGitRepo: boolean;
+  openspecProjectExists: boolean;
+  openspecArchiveGitkeepExists: boolean;
+  openspecSpecsGitkeepExists: boolean;
+  aiEvidenceExists: boolean;
+  openspecProjectTracked: boolean;
+  openspecArchiveGitkeepTracked: boolean;
+  openspecSpecsGitkeepTracked: boolean;
+  aiEvidenceTracked: boolean;
+};
+
+export type P9RuralgoBaselineVersionedPolicy = {
+  requireExists: boolean;
+  requireTracked: boolean;
+};
+
+export type P9RuralgoBaselineVersionedResult = {
+  ready: boolean;
+  issues: ReadonlyArray<P9RuralgoBaselineVersionedIssue>;
+};
+
+export const DEFAULT_P9_RURALGO_BASELINE_VERSIONED_POLICY: P9RuralgoBaselineVersionedPolicy = {
+  requireExists: true,
+  requireTracked: true,
+};
+
+const pushIssue = (
+  issues: P9RuralgoBaselineVersionedIssue[],
+  code: P9RuralgoBaselineVersionedIssueCode,
+  message: string,
+  severity: 'error' | 'warning' = 'error',
+): void => {
+  issues.push({ code, severity, message });
+};
+
+export const evaluateP9RuralgoBaselineVersioned = (
+  snapshot: P9RuralgoBaselineVersionedSnapshot,
+  policyOverrides?: Partial<P9RuralgoBaselineVersionedPolicy>,
+): P9RuralgoBaselineVersionedResult => {
+  const policy: P9RuralgoBaselineVersionedPolicy = {
+    ...DEFAULT_P9_RURALGO_BASELINE_VERSIONED_POLICY,
+    ...(policyOverrides ?? {}),
+  };
+  const issues: P9RuralgoBaselineVersionedIssue[] = [];
+
+  if (!snapshot.isGitRepo) {
+    pushIssue(issues, 'NOT_GIT_REPO', 'La ruta objetivo no es un repositorio git válido.');
+    return { ready: false, issues };
+  }
+
+  if (policy.requireExists && !snapshot.openspecProjectExists) {
+    pushIssue(issues, 'OPENSPEC_PROJECT_MISSING', 'Falta openspec/project.md.');
+  }
+  if (policy.requireExists && !snapshot.openspecArchiveGitkeepExists) {
+    pushIssue(
+      issues,
+      'OPENSPEC_ARCHIVE_GITKEEP_MISSING',
+      'Falta openspec/changes/archive/.gitkeep.',
+    );
+  }
+  if (policy.requireExists && !snapshot.openspecSpecsGitkeepExists) {
+    pushIssue(issues, 'OPENSPEC_SPECS_GITKEEP_MISSING', 'Falta openspec/specs/.gitkeep.');
+  }
+  if (policy.requireExists && !snapshot.aiEvidenceExists) {
+    pushIssue(issues, 'AI_EVIDENCE_MISSING', 'Falta .ai_evidence.json.');
+  }
+
+  if (policy.requireTracked && !snapshot.openspecProjectTracked) {
+    pushIssue(
+      issues,
+      'OPENSPEC_PROJECT_UNTRACKED',
+      'openspec/project.md no está trackeado por git.',
+    );
+  }
+  if (policy.requireTracked && !snapshot.openspecArchiveGitkeepTracked) {
+    pushIssue(
+      issues,
+      'OPENSPEC_ARCHIVE_GITKEEP_UNTRACKED',
+      'openspec/changes/archive/.gitkeep no está trackeado por git.',
+    );
+  }
+  if (policy.requireTracked && !snapshot.openspecSpecsGitkeepTracked) {
+    pushIssue(
+      issues,
+      'OPENSPEC_SPECS_GITKEEP_UNTRACKED',
+      'openspec/specs/.gitkeep no está trackeado por git.',
+    );
+  }
+  if (policy.requireTracked && !snapshot.aiEvidenceTracked) {
+    pushIssue(
+      issues,
+      'AI_EVIDENCE_UNTRACKED',
+      '.ai_evidence.json no está trackeado por git.',
+    );
+  }
+
+  return {
+    ready: !issues.some((issue) => issue.severity === 'error'),
+    issues,
+  };
+};

package/scripts/p9-ruralgo-branch-ready-lib.ts

@@ -0,0 +1,128 @@
+export type P9RuralgoBranchReadinessIssueCode =
+  | 'NOT_GIT_REPO'
+  | 'CURRENT_BRANCH_UNKNOWN'
+  | 'BRANCH_MISMATCH'
+  | 'INVALID_BRANCH_NAMING'
+  | 'UPSTREAM_ALREADY_SET'
+  | 'WORKTREE_DIRTY'
+  | 'BASE_NOT_ANCESTOR'
+  | 'BASE_REF_UNAVAILABLE';
+
+export type P9RuralgoBranchReadinessIssue = {
+  code: P9RuralgoBranchReadinessIssueCode;
+  severity: 'error' | 'warning';
+  message: string;
+};
+
+export type P9RuralgoBranchReadinessInput = {
+  repoPath: string;
+  expectedBranch: string;
+  currentBranch: string | null;
+  upstreamRef: string | null;
+  baseRef: string;
+  baseReachable: boolean | null;
+  worktreeDirty: boolean;
+  isGitRepo: boolean;
+};
+
+export type P9RuralgoBranchReadinessPolicy = {
+  requireNoUpstream: boolean;
+  requireCleanWorktree: boolean;
+  requireFeatureNaming: boolean;
+};
+
+export type P9RuralgoBranchReadinessResult = {
+  ready: boolean;
+  issues: ReadonlyArray<P9RuralgoBranchReadinessIssue>;
+};
+
+export const DEFAULT_P9_RURALGO_BRANCH_POLICY: P9RuralgoBranchReadinessPolicy = {
+  requireNoUpstream: true,
+  requireCleanWorktree: true,
+  requireFeatureNaming: true,
+};
+
+const FEATURE_BRANCH_PATTERN = /^feature\/[a-z0-9][a-z0-9-]*$/;
+
+const pushIssue = (
+  issues: P9RuralgoBranchReadinessIssue[],
+  code: P9RuralgoBranchReadinessIssueCode,
+  message: string,
+  severity: 'error' | 'warning' = 'error',
+): void => {
+  issues.push({ code, severity, message });
+};
+
+export const evaluateP9RuralgoBranchReadiness = (
+  input: P9RuralgoBranchReadinessInput,
+  policyOverrides?: Partial<P9RuralgoBranchReadinessPolicy>,
+): P9RuralgoBranchReadinessResult => {
+  const policy: P9RuralgoBranchReadinessPolicy = {
+    ...DEFAULT_P9_RURALGO_BRANCH_POLICY,
+    ...(policyOverrides ?? {}),
+  };
+  const issues: P9RuralgoBranchReadinessIssue[] = [];
+
+  if (!input.isGitRepo) {
+    pushIssue(
+      issues,
+      'NOT_GIT_REPO',
+      `La ruta no es un repositorio git válido: ${input.repoPath}.`,
+    );
+    return { ready: false, issues };
+  }
+
+  if (!input.currentBranch) {
+    pushIssue(issues, 'CURRENT_BRANCH_UNKNOWN', 'No se pudo resolver la rama actual.');
+  } else {
+    if (input.currentBranch !== input.expectedBranch) {
+      pushIssue(
+        issues,
+        'BRANCH_MISMATCH',
+        `Rama activa "${input.currentBranch}" distinta de la esperada "${input.expectedBranch}".`,
+      );
+    }
+    if (policy.requireFeatureNaming && !FEATURE_BRANCH_PATTERN.test(input.currentBranch)) {
+      pushIssue(
+        issues,
+        'INVALID_BRANCH_NAMING',
+        `La rama "${input.currentBranch}" no cumple el patrón GitFlow "feature/<kebab-case>".`,
+      );
+    }
+  }
+
+  if (policy.requireNoUpstream && input.upstreamRef) {
+    pushIssue(
+      issues,
+      'UPSTREAM_ALREADY_SET',
+      `La rama ya tiene upstream configurado (${input.upstreamRef}); para ST2 se espera sin upstream.`,
+    );
+  }
+
+  if (policy.requireCleanWorktree && input.worktreeDirty) {
+    pushIssue(
+      issues,
+      'WORKTREE_DIRTY',
+      'El worktree tiene cambios locales; para preparar la rama se espera estado limpio.',
+    );
+  }
+
+  if (input.baseReachable === false) {
+    pushIssue(
+      issues,
+      'BASE_NOT_ANCESTOR',
+      `HEAD no desciende de ${input.baseRef}; la rama no está preparada sobre la base esperada.`,
+    );
+  } else if (input.baseReachable === null) {
+    pushIssue(
+      issues,
+      'BASE_REF_UNAVAILABLE',
+      `No se pudo verificar la relación con ${input.baseRef}.`,
+    );
+  }
+
+  return {
+    ready: !issues.some((issue) => issue.severity === 'error'),
+    issues,
+  };
+};

package/scripts/p9-ruralgo-install-health-lib.ts

@@ -0,0 +1,121 @@
+export type P9RuralgoInstallHealthIssueCode =
+  | 'NOT_GIT_REPO'
+  | 'STATUS_COMMAND_FAILED'
+  | 'STATUS_JSON_INVALID'
+  | 'LIFECYCLE_NOT_INSTALLED'
+  | 'HOOK_PRE_COMMIT_UNMANAGED'
+  | 'HOOK_PRE_PUSH_UNMANAGED'
+  | 'DOCTOR_COMMAND_FAILED'
+  | 'DOCTOR_VERDICT_NOT_PASS'
+  | 'DOCTOR_VERDICT_UNPARSABLE';
+
+export type P9RuralgoInstallHealthIssue = {
+  code: P9RuralgoInstallHealthIssueCode;
+  severity: 'error' | 'warning';
+  message: string;
+};
+
+export type P9RuralgoInstallHealthSnapshot = {
+  isGitRepo: boolean;
+  statusCommandOk: boolean;
+  statusJsonValid: boolean;
+  lifecycleInstalled: boolean | null;
+  preCommitManaged: boolean | null;
+  prePushManaged: boolean | null;
+  doctorCommandOk: boolean;
+  doctorVerdictPass: boolean | null;
+};
+
+export type P9RuralgoInstallHealthPolicy = {
+  requireInstalled: boolean;
+  requireManagedHooks: boolean;
+  requireDoctorPass: boolean;
+};
+
+export type P9RuralgoInstallHealthResult = {
+  ready: boolean;
+  issues: ReadonlyArray<P9RuralgoInstallHealthIssue>;
+};
+
+export const DEFAULT_P9_RURALGO_INSTALL_HEALTH_POLICY: P9RuralgoInstallHealthPolicy = {
+  requireInstalled: true,
+  requireManagedHooks: true,
+  requireDoctorPass: true,
+};
+
+const pushIssue = (
+  issues: P9RuralgoInstallHealthIssue[],
+  code: P9RuralgoInstallHealthIssueCode,
+  message: string,
+  severity: 'error' | 'warning' = 'error',
+): void => {
+  issues.push({ code, severity, message });
+};
+
+export const evaluateP9RuralgoInstallHealth = (
+  snapshot: P9RuralgoInstallHealthSnapshot,
+  policyOverrides?: Partial<P9RuralgoInstallHealthPolicy>,
+): P9RuralgoInstallHealthResult => {
+  const policy: P9RuralgoInstallHealthPolicy = {
+    ...DEFAULT_P9_RURALGO_INSTALL_HEALTH_POLICY,
+    ...(policyOverrides ?? {}),
+  };
+  const issues: P9RuralgoInstallHealthIssue[] = [];
+
+  if (!snapshot.isGitRepo) {
+    pushIssue(issues, 'NOT_GIT_REPO', 'La ruta objetivo no es un repositorio git válido.');
+    return { ready: false, issues };
+  }
+
+  if (!snapshot.statusCommandOk) {
+    pushIssue(issues, 'STATUS_COMMAND_FAILED', 'Falló `pumuki status --json`.');
+  } else if (!snapshot.statusJsonValid) {
+    pushIssue(issues, 'STATUS_JSON_INVALID', '`pumuki status --json` no devolvió JSON válido.');
+  }
+
+  if (policy.requireInstalled && snapshot.lifecycleInstalled !== true) {
+    pushIssue(
+      issues,
+      'LIFECYCLE_NOT_INSTALLED',
+      'Lifecycle no está instalado según `pumuki status --json`.',
+    );
+  }
+
+  if (policy.requireManagedHooks && snapshot.preCommitManaged !== true) {
+    pushIssue(
+      issues,
+      'HOOK_PRE_COMMIT_UNMANAGED',
+      'Hook `pre-commit` no está gestionado por Pumuki.',
+    );
+  }
+  if (policy.requireManagedHooks && snapshot.prePushManaged !== true) {
+    pushIssue(
+      issues,
+      'HOOK_PRE_PUSH_UNMANAGED',
+      'Hook `pre-push` no está gestionado por Pumuki.',
+    );
+  }
+
+  if (policy.requireDoctorPass) {
+    if (!snapshot.doctorCommandOk) {
+      pushIssue(issues, 'DOCTOR_COMMAND_FAILED', 'Falló `pumuki doctor --json`.');
+    } else if (snapshot.doctorVerdictPass === false) {
+      pushIssue(
+        issues,
+        'DOCTOR_VERDICT_NOT_PASS',
+        '`pumuki doctor --json` no devolvió verdict PASS.',
+      );
+    } else if (snapshot.doctorVerdictPass === null) {
+      pushIssue(
+        issues,
+        'DOCTOR_VERDICT_UNPARSABLE',
+        'No se pudo interpretar el verdict de `pumuki doctor --json`.',
+      );
+    }
+  }
+
+  return {
+    ready: !issues.some((issue) => issue.severity === 'error'),
+    issues,
+  };
+};

package/scripts/p9-ruralgo-runtime-ready-lib.ts

@@ -0,0 +1,149 @@
+export type P9RuralgoRuntimeIssueCode =
+  | 'PACKAGE_JSON_MISSING'
+  | 'PACKAGE_JSON_INVALID'
+  | 'ENGINES_NODE_MISSING'
+  | 'ENGINES_NPM_MISSING'
+  | 'NODE_VERSION_UNKNOWN'
+  | 'NODE_VERSION_MISMATCH'
+  | 'NPM_VERSION_MISMATCH'
+  | 'NPM_VERSION_UNKNOWN'
+  | 'ENGINE_RANGE_UNSUPPORTED';
+
+export type P9RuralgoRuntimeIssue = {
+  code: P9RuralgoRuntimeIssueCode;
+  severity: 'error' | 'warning';
+  message: string;
+};
+
+export type P9RuralgoRuntimeInput = {
+  requiredNode: string | null;
+  requiredNpm: string | null;
+  currentNode: string | null;
+  currentNpm: string | null;
+  packageJsonAvailable: boolean;
+  packageJsonValid: boolean;
+};
+
+export type P9RuralgoRuntimePolicy = {
+  requireNodeEngine: boolean;
+  requireNpmEngine: boolean;
+};
+
+export type P9RuralgoRuntimeResult = {
+  ready: boolean;
+  issues: ReadonlyArray<P9RuralgoRuntimeIssue>;
+};
+
+export const DEFAULT_P9_RURALGO_RUNTIME_POLICY: P9RuralgoRuntimePolicy = {
+  requireNodeEngine: true,
+  requireNpmEngine: true,
+};
+
+export const normalizeSemverToken = (value: string): string => value.trim().replace(/^v/i, '');
+
+export const isExactSemver = (value: string): boolean =>
+  /^\d+\.\d+\.\d+$/.test(normalizeSemverToken(value));
+
+const pushIssue = (
+  issues: P9RuralgoRuntimeIssue[],
+  code: P9RuralgoRuntimeIssueCode,
+  message: string,
+  severity: 'error' | 'warning' = 'error',
+): void => {
+  issues.push({ code, severity, message });
+};
+
+const evaluateExactEngine = (
+  issues: P9RuralgoRuntimeIssue[],
+  requiredVersion: string,
+  currentVersion: string | null,
+  mismatchCode: Extract<P9RuralgoRuntimeIssueCode, 'NODE_VERSION_MISMATCH' | 'NPM_VERSION_MISMATCH'>,
+  unknownCode: Extract<P9RuralgoRuntimeIssueCode, 'NODE_VERSION_UNKNOWN' | 'NPM_VERSION_UNKNOWN'>,
+  runtimeLabel: 'node' | 'npm',
+): void => {
+  if (!isExactSemver(requiredVersion)) {
+    pushIssue(
+      issues,
+      'ENGINE_RANGE_UNSUPPORTED',
+      `Engine de ${runtimeLabel} no exacto ("${requiredVersion}"). Usa versión exacta para validación determinista.`,
+      'warning',
+    );
+    return;
+  }
+  if (!currentVersion) {
+    pushIssue(
+      issues,
+      unknownCode,
+      `No se pudo resolver versión actual de ${runtimeLabel}.`,
+    );
+    return;
+  }
+  const normalizedRequired = normalizeSemverToken(requiredVersion);
+  const normalizedCurrent = normalizeSemverToken(currentVersion);
+  if (normalizedRequired !== normalizedCurrent) {
+    pushIssue(
+      issues,
+      mismatchCode,
+      `${runtimeLabel} requerido=${normalizedRequired} actual=${normalizedCurrent}`,
+    );
+  }
+};
+
+export const evaluateP9RuralgoRuntimeReadiness = (
+  input: P9RuralgoRuntimeInput,
+  policyOverrides?: Partial<P9RuralgoRuntimePolicy>,
+): P9RuralgoRuntimeResult => {
+  const policy: P9RuralgoRuntimePolicy = {
+    ...DEFAULT_P9_RURALGO_RUNTIME_POLICY,
+    ...(policyOverrides ?? {}),
+  };
+  const issues: P9RuralgoRuntimeIssue[] = [];
+
+  if (!input.packageJsonAvailable) {
+    pushIssue(issues, 'PACKAGE_JSON_MISSING', 'No existe package.json en el repo objetivo.');
+    return { ready: false, issues };
+  }
+  if (!input.packageJsonValid) {
+    pushIssue(issues, 'PACKAGE_JSON_INVALID', 'package.json no es JSON válido.');
+    return { ready: false, issues };
+  }
+
+  if (policy.requireNodeEngine && !input.requiredNode) {
+    pushIssue(
+      issues,
+      'ENGINES_NODE_MISSING',
+      'Falta engines.node en package.json del repo objetivo.',
+    );
+  } else if (input.requiredNode) {
+    evaluateExactEngine(
+      issues,
+      input.requiredNode,
+      input.currentNode,
+      'NODE_VERSION_MISMATCH',
+      'NODE_VERSION_UNKNOWN',
+      'node',
+    );
+  }
+
+  if (policy.requireNpmEngine && !input.requiredNpm) {
+    pushIssue(
+      issues,
+      'ENGINES_NPM_MISSING',
+      'Falta engines.npm en package.json del repo objetivo.',
+    );
+  } else if (input.requiredNpm) {
+    evaluateExactEngine(
+      issues,
+      input.requiredNpm,
+      input.currentNpm,
+      'NPM_VERSION_MISMATCH',
+      'NPM_VERSION_UNKNOWN',
+      'npm',
+    );
+  }
+
+  return {
+    ready: !issues.some((issue) => issue.severity === 'error'),
+    issues,
+  };
+};