pumuki 6.3.26 → 6.3.28

package/scripts/p9-validation-manifests-lib.ts

@@ -0,0 +1,366 @@
+import { mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+
+export type ValidationStage = 'PRE_WRITE' | 'PRE_COMMIT' | 'PRE_PUSH' | 'CI';
+
+export type StageMatrixStatus = {
+  PRE_WRITE: 'pending' | 'pass' | 'fail' | 'na';
+  PRE_COMMIT: 'pending' | 'pass' | 'fail' | 'na';
+  PRE_PUSH: 'pending' | 'pass' | 'fail' | 'na';
+  CI: 'pending' | 'pass' | 'fail' | 'na';
+};
+
+export type FunctionalityKind = 'bin' | 'script' | 'export' | 'lifecycle_command' | 'menu_action';
+
+export type FunctionalityItem = {
+  id: string;
+  kind: FunctionalityKind;
+  source: string;
+  description: string;
+  command?: string;
+  stageMatrix: StageMatrixStatus;
+};
+
+export type RulesItem = {
+  ruleId: string;
+  source: 'execution_board' | 'source_scan';
+  stageMatrix: StageMatrixStatus;
+};
+
+export type FunctionalityMatrix = {
+  generatedAt: string;
+  repoRoot: string;
+  totals: {
+    bins: number;
+    scripts: number;
+    exports: number;
+    lifecycleCommands: number;
+    menuActions: number;
+    overall: number;
+  };
+  items: ReadonlyArray<FunctionalityItem>;
+};
+
+export type RulesMatrix = {
+  generatedAt: string;
+  repoRoot: string;
+  totals: {
+    executionBoardRules: number;
+    sourceScannedRules: number;
+    overallUnion: number;
+  };
+  items: ReadonlyArray<RulesItem>;
+};
+
+const PENDING_STAGE_MATRIX: StageMatrixStatus = {
+  PRE_WRITE: 'pending',
+  PRE_COMMIT: 'pending',
+  PRE_PUSH: 'pending',
+  CI: 'pending',
+};
+
+const clonePendingStageMatrix = (): StageMatrixStatus => {
+  return {
+    PRE_WRITE: PENDING_STAGE_MATRIX.PRE_WRITE,
+    PRE_COMMIT: PENDING_STAGE_MATRIX.PRE_COMMIT,
+    PRE_PUSH: PENDING_STAGE_MATRIX.PRE_PUSH,
+    CI: PENDING_STAGE_MATRIX.CI,
+  };
+};
+
+const readUtf8 = (path: string): string => {
+  return readFileSync(path, 'utf8');
+};
+
+const parseLifecycleCommandsFromHelpText = (cliSource: string): ReadonlyArray<string> => {
+  const helpMatch = cliSource.match(/const HELP_TEXT = `([\s\S]*?)`\.trim\(\);/);
+  if (!helpMatch) {
+    return [];
+  }
+  return helpMatch[1]
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line.startsWith('pumuki '));
+};
+
+type MenuAction = {
+  id: string;
+  label: string;
+};
+
+const parseMenuActions = (source: string): ReadonlyArray<MenuAction> => {
+  const actions: MenuAction[] = [];
+  const actionPattern = /id:\s*'([^']+)'\s*,[\s\S]{0,260}?label:\s*'([^']+)'/g;
+  let match = actionPattern.exec(source);
+  while (match) {
+    actions.push({ id: match[1], label: match[2] });
+    match = actionPattern.exec(source);
+  }
+  const seen = new Set<string>();
+  const unique: MenuAction[] = [];
+  for (const action of actions) {
+    const key = `${action.id}|${action.label}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(action);
+  }
+  return unique.sort((a, b) => Number(a.id) - Number(b.id) || a.label.localeCompare(b.label));
+};
+
+const parseConsumerMenuActions = (repoRoot: string): ReadonlyArray<MenuAction> => {
+  const source = readUtf8(resolve(repoRoot, 'scripts/framework-menu-consumer-actions-lib.ts'));
+  return parseMenuActions(source);
+};
+
+const parseAdvancedMenuActions = (repoRoot: string): ReadonlyArray<MenuAction> => {
+  const files = [
+    'scripts/framework-menu-actions-gates-stage-lib.ts',
+    'scripts/framework-menu-actions-gates-ci-lib.ts',
+    'scripts/framework-menu-actions-gates-tools-lib.ts',
+    'scripts/framework-menu-actions-diagnostics-adapter-lib.ts',
+    'scripts/framework-menu-actions-diagnostics-ci-lib.ts',
+    'scripts/framework-menu-actions-diagnostics-support-core-lib.ts',
+    'scripts/framework-menu-actions-diagnostics-support-triage-lib.ts',
+    'scripts/framework-menu-actions-diagnostics-maintenance-lib.ts',
+    'scripts/framework-menu-actions-phase5-reports-lib.ts',
+    'scripts/framework-menu-actions-phase5-exec-lib.ts',
+    'scripts/framework-menu-actions-phase5-exit-lib.ts',
+  ];
+  const actions: MenuAction[] = [];
+  for (const file of files) {
+    const source = readUtf8(resolve(repoRoot, file));
+    for (const action of parseMenuActions(source)) {
+      actions.push(action);
+    }
+  }
+  const seen = new Set<string>();
+  const unique: MenuAction[] = [];
+  for (const action of actions) {
+    const key = `${action.id}|${action.label}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    unique.push(action);
+  }
+  return unique.sort((a, b) => Number(a.id) - Number(b.id) || a.label.localeCompare(b.label));
+};
+
+const parseRuleIdsFromExecutionBoard = (repoRoot: string): ReadonlyArray<string> => {
+  const source = readUtf8(resolve(repoRoot, 'docs/EXECUTION_BOARD.md'));
+  const ruleIds = new Set<string>();
+  const lines = source.split('\n');
+  let inRulesSection = false;
+  for (const line of lines) {
+    if (line.startsWith('## Checklist B')) {
+      inRulesSection = true;
+      continue;
+    }
+    if (inRulesSection && line.startsWith('## ') && !line.startsWith('## Checklist B')) {
+      inRulesSection = false;
+    }
+    if (!inRulesSection) {
+      continue;
+    }
+    const match = line.match(/`rule:([^`]+)`/);
+    if (match) {
+      ruleIds.add(match[1].trim());
+    }
+  }
+  return [...ruleIds].sort();
+};
+
+const readAllTsSources = (repoRoot: string): ReadonlyArray<string> => {
+  const roots = ['core/rules/presets', 'integrations/config'];
+  const files: string[] = [];
+  const visit = (relativePath: string): void => {
+    const absolutePath = resolve(repoRoot, relativePath);
+    const stats = statSync(absolutePath);
+    if (stats.isDirectory()) {
+      for (const child of readdirSync(absolutePath)) {
+        visit(`${relativePath}/${child}`);
+      }
+      return;
+    }
+    if (!relativePath.endsWith('.ts') || relativePath.endsWith('.test.ts')) {
+      return;
+    }
+    files.push(absolutePath);
+  };
+  for (const root of roots) {
+    visit(root);
+  }
+  return files.map((file) => readUtf8(file));
+};
+
+const parseRuleIdsFromSource = (repoRoot: string): ReadonlyArray<string> => {
+  const ruleIds = new Set<string>();
+  const sources = readAllTsSources(repoRoot);
+  for (const source of sources) {
+    const ruleIdPattern = /ruleId:\s*['"]([^'"]+)['"]/g;
+    let match = ruleIdPattern.exec(source);
+    while (match) {
+      ruleIds.add(match[1].trim());
+      match = ruleIdPattern.exec(source);
+    }
+    const explicitIdPattern = /id:\s*['"]((?:skills|backend|frontend|ios|android|common|workflow|heuristics)\.[^'"]+)['"]/g;
+    match = explicitIdPattern.exec(source);
+    while (match) {
+      ruleIds.add(match[1].trim());
+      match = explicitIdPattern.exec(source);
+    }
+  }
+  return [...ruleIds].sort();
+};
+
+export const buildFunctionalityMatrix = (repoRoot: string): FunctionalityMatrix => {
+  const packageJson = JSON.parse(readUtf8(resolve(repoRoot, 'package.json'))) as {
+    bin?: Record<string, string>;
+    scripts?: Record<string, string>;
+    exports?: Record<string, string>;
+  };
+  const bins = Object.keys(packageJson.bin ?? {}).sort();
+  const scripts = Object.keys(packageJson.scripts ?? {}).sort();
+  const exportsEntries = Object.keys(packageJson.exports ?? {}).sort();
+  const lifecycleSource = readUtf8(resolve(repoRoot, 'integrations/lifecycle/cli.ts'));
+  const lifecycleCommands = parseLifecycleCommandsFromHelpText(lifecycleSource);
+  const consumerActions = parseConsumerMenuActions(repoRoot);
+  const advancedActions = parseAdvancedMenuActions(repoRoot);
+
+  const items: FunctionalityItem[] = [];
+
+  for (const bin of bins) {
+    items.push({
+      id: `bin:${bin}`,
+      kind: 'bin',
+      source: 'package.json#bin',
+      description: `Binary entrypoint "${bin}"`,
+      command: `npx ${bin}`,
+      stageMatrix: clonePendingStageMatrix(),
+    });
+  }
+
+  for (const script of scripts) {
+    items.push({
+      id: `script:${script}`,
+      kind: 'script',
+      source: 'package.json#scripts',
+      description: `Script "${script}"`,
+      command: `npm run ${script}`,
+      stageMatrix: clonePendingStageMatrix(),
+    });
+  }
+
+  for (const exportEntry of exportsEntries) {
+    items.push({
+      id: `export:${exportEntry}`,
+      kind: 'export',
+      source: 'package.json#exports',
+      description: `Export "${exportEntry}"`,
+      stageMatrix: clonePendingStageMatrix(),
+    });
+  }
+
+  for (const command of lifecycleCommands) {
+    items.push({
+      id: `lifecycle:${command}`,
+      kind: 'lifecycle_command',
+      source: 'integrations/lifecycle/cli.ts#HELP_TEXT',
+      description: command,
+      command,
+      stageMatrix: clonePendingStageMatrix(),
+    });
+  }
+
+  for (const action of consumerActions) {
+    items.push({
+      id: `menu.consumer.${action.id}`,
+      kind: 'menu_action',
+      source: 'scripts/framework-menu-consumer-actions-lib.ts',
+      description: action.label,
+      stageMatrix: clonePendingStageMatrix(),
+    });
+  }
+
+  for (const action of advancedActions) {
+    items.push({
+      id: `menu.advanced.${action.id}`,
+      kind: 'menu_action',
+      source: 'scripts/framework-menu-actions-*-lib.ts',
+      description: action.label,
+      stageMatrix: clonePendingStageMatrix(),
+    });
+  }
+
+  items.push({
+    id: 'menu.consumer.switch.A',
+    kind: 'menu_action',
+    source: 'scripts/framework-menu.ts',
+    description: 'Switch consumer mode to advanced mode',
+    stageMatrix: clonePendingStageMatrix(),
+  });
+  items.push({
+    id: 'menu.advanced.switch.C',
+    kind: 'menu_action',
+    source: 'scripts/framework-menu.ts',
+    description: 'Switch advanced mode to consumer mode',
+    stageMatrix: clonePendingStageMatrix(),
+  });
+
+  return {
+    generatedAt: new Date().toISOString(),
+    repoRoot: resolve(repoRoot),
+    totals: {
+      bins: bins.length,
+      scripts: scripts.length,
+      exports: exportsEntries.length,
+      lifecycleCommands: lifecycleCommands.length,
+      menuActions: consumerActions.length + advancedActions.length + 2,
+      overall: items.length,
+    },
+    items,
+  };
+};
+
+export const buildRulesMatrix = (repoRoot: string): RulesMatrix => {
+  const fromExecutionBoard = parseRuleIdsFromExecutionBoard(repoRoot);
+  const fromSource = parseRuleIdsFromSource(repoRoot);
+  const executionBoardSet = new Set(fromExecutionBoard);
+  const sourceSet = new Set(fromSource);
+  const union = new Set<string>([...fromExecutionBoard, ...fromSource]);
+  const items: RulesItem[] = [...union]
+    .sort()
+    .map((ruleId) => ({
+      ruleId,
+      source: executionBoardSet.has(ruleId) ? 'execution_board' : 'source_scan',
+      stageMatrix: clonePendingStageMatrix(),
+    }));
+  return {
+    generatedAt: new Date().toISOString(),
+    repoRoot: resolve(repoRoot),
+    totals: {
+      executionBoardRules: executionBoardSet.size,
+      sourceScannedRules: sourceSet.size,
+      overallUnion: union.size,
+    },
+    items,
+  };
+};
+
+export const writeP9ValidationManifests = (repoRoot: string, outDir: string): {
+  functionalityPath: string;
+  rulesPath: string;
+  functionality: FunctionalityMatrix;
+  rules: RulesMatrix;
+} => {
+  const functionality = buildFunctionalityMatrix(repoRoot);
+  const rules = buildRulesMatrix(repoRoot);
+  const functionalityPath = resolve(outDir, 'p9-functionality-matrix.json');
+  const rulesPath = resolve(outDir, 'p9-rules-matrix.json');
+  mkdirSync(dirname(functionalityPath), { recursive: true });
+  writeFileSync(functionalityPath, `${JSON.stringify(functionality, null, 2)}\n`, 'utf8');
+  writeFileSync(rulesPath, `${JSON.stringify(rules, null, 2)}\n`, 'utf8');
+  return { functionalityPath, rulesPath, functionality, rules };
+};

package/scripts/package-manifest-lib.ts

@@ -5,12 +5,21 @@ export const REQUIRED_PACKAGE_PATHS = [
   'bin/pumuki-pre-push.js',
   'bin/pumuki-ci.js',
   'bin/pumuki-mcp-evidence.js',
+  'bin/pumuki-mcp-evidence-stdio.js',
+  'bin/pumuki-mcp-enterprise.js',
+  'bin/pumuki-mcp-enterprise-stdio.js',
+  'core/gate/evaluateGate.js',
+  'core/gate/evaluateRules.js',
   'core/utils/stableStringify.ts',
   'core/facts/detectors/typescript/index.ts',
   'core/rules/presets/heuristics/typescript.ts',
   'scripts/package-install-smoke.ts',
+  'integrations/git/index.js',
   'integrations/git/runPlatformGate.ts',
+  'integrations/lifecycle/index.js',
   'integrations/lifecycle/cli.ts',
+  'integrations/mcp/index.js',
+  'integrations/sdd/index.js',
   'integrations/notifications/emitAuditSummaryNotification.ts',
   'integrations/evidence/buildEvidence.ts',
 ];

package/skills.lock.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0",
   "compilerVersion": "1.0.0",
-  "generatedAt": "2026-02-23T00:59:03.442Z",
+  "generatedAt": "2026-03-01T00:40:34.556Z",
   "bundles": [
     {
       "name": "android-guidelines",