@ryuenn3123/agentic-senior-core 2.0.5 → 2.0.7

package/scripts/frontend-usability-audit.mjs

@@ -1,87 +1,87 @@
-#!/usr/bin/env node
-
-/**
- * frontend-usability-audit.mjs
- *
- * Governance-level audit for V1.7 frontend execution assets.
- * This repository does not host a frontend runtime app, so the audit validates
- * required execution artifacts and quality gates documentation.
- */
-
-import { existsSync, readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const REPOSITORY_ROOT = resolve(__dirname, '..');
-
-const REQUIRED_FILES = [
-  'docs/roadmap.md',
-  'docs/v1.7-issue-breakdown.md',
-  'docs/v1.7-execution-playbook.md',
-  '.agent-context/review-checklists/frontend-usability.md',
-];
-
-const REQUIRED_ROADMAP_SNIPPETS = [
-  'V1.7',
-  'Frontend Product Experience',
-  'Release status: Completed',
-  'Delivered Scope',
-];
-
-const REQUIRED_CHECKLIST_SNIPPETS = [
-  'Responsiveness',
-  'Accessibility',
-  'Performance',
-  'Documentation and Release Evidence',
-];
-
-function assertFileExists(relativeFilePath, failures) {
-  const absoluteFilePath = resolve(REPOSITORY_ROOT, relativeFilePath);
-  if (!existsSync(absoluteFilePath)) {
-    failures.push(`Missing required file: ${relativeFilePath}`);
-  }
-}
-
-function assertContains(contentLabel, filePath, fileContent, snippets, failures) {
-  for (const snippetText of snippets) {
-    if (!fileContent.includes(snippetText)) {
-      failures.push(`${contentLabel} missing snippet "${snippetText}" in ${filePath}`);
-    }
-  }
-}
-
-function runAudit() {
-  const failures = [];
-
-  for (const requiredFilePath of REQUIRED_FILES) {
-    assertFileExists(requiredFilePath, failures);
-  }
-
-  const roadmapPath = 'docs/roadmap.md';
-  const checklistPath = '.agent-context/review-checklists/frontend-usability.md';
-
-  if (existsSync(resolve(REPOSITORY_ROOT, roadmapPath))) {
-    const roadmapContent = readFileSync(resolve(REPOSITORY_ROOT, roadmapPath), 'utf8');
-    assertContains('Roadmap', roadmapPath, roadmapContent, REQUIRED_ROADMAP_SNIPPETS, failures);
-  }
-
-  if (existsSync(resolve(REPOSITORY_ROOT, checklistPath))) {
-    const checklistContent = readFileSync(resolve(REPOSITORY_ROOT, checklistPath), 'utf8');
-    assertContains('Checklist', checklistPath, checklistContent, REQUIRED_CHECKLIST_SNIPPETS, failures);
-  }
-
-  const reportPayload = {
-    generatedAt: new Date().toISOString(),
-    auditName: 'frontend-usability-audit',
-    passed: failures.length === 0,
-    failureCount: failures.length,
-    failures,
-  };
-
-  console.log(JSON.stringify(reportPayload, null, 2));
-  process.exit(reportPayload.passed ? 0 : 1);
-}
-
-runAudit();
+#!/usr/bin/env node
+
+/**
+ * frontend-usability-audit.mjs
+ *
+ * Governance-level audit for V1.7 frontend execution assets.
+ * This repository does not host a frontend runtime app, so the audit validates
+ * required execution artifacts and quality gates documentation.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const REPOSITORY_ROOT = resolve(__dirname, '..');
+
+const REQUIRED_FILES = [
+  'docs/roadmap.md',
+  'docs/v1.7-issue-breakdown.md',
+  'docs/v1.7-execution-playbook.md',
+  '.agent-context/review-checklists/frontend-usability.md',
+];
+
+const REQUIRED_ROADMAP_SNIPPETS = [
+  'V1.7',
+  'Frontend Product Experience',
+  'Release status: Completed',
+  'Delivered Scope',
+];
+
+const REQUIRED_CHECKLIST_SNIPPETS = [
+  'Responsiveness',
+  'Accessibility',
+  'Performance',
+  'Documentation and Release Evidence',
+];
+
+function assertFileExists(relativeFilePath, failures) {
+  const absoluteFilePath = resolve(REPOSITORY_ROOT, relativeFilePath);
+  if (!existsSync(absoluteFilePath)) {
+    failures.push(`Missing required file: ${relativeFilePath}`);
+  }
+}
+
+function assertContains(contentLabel, filePath, fileContent, snippets, failures) {
+  for (const snippetText of snippets) {
+    if (!fileContent.includes(snippetText)) {
+      failures.push(`${contentLabel} missing snippet "${snippetText}" in ${filePath}`);
+    }
+  }
+}
+
+function runAudit() {
+  const failures = [];
+
+  for (const requiredFilePath of REQUIRED_FILES) {
+    assertFileExists(requiredFilePath, failures);
+  }
+
+  const roadmapPath = 'docs/roadmap.md';
+  const checklistPath = '.agent-context/review-checklists/frontend-usability.md';
+
+  if (existsSync(resolve(REPOSITORY_ROOT, roadmapPath))) {
+    const roadmapContent = readFileSync(resolve(REPOSITORY_ROOT, roadmapPath), 'utf8');
+    assertContains('Roadmap', roadmapPath, roadmapContent, REQUIRED_ROADMAP_SNIPPETS, failures);
+  }
+
+  if (existsSync(resolve(REPOSITORY_ROOT, checklistPath))) {
+    const checklistContent = readFileSync(resolve(REPOSITORY_ROOT, checklistPath), 'utf8');
+    assertContains('Checklist', checklistPath, checklistContent, REQUIRED_CHECKLIST_SNIPPETS, failures);
+  }
+
+  const reportPayload = {
+    generatedAt: new Date().toISOString(),
+    auditName: 'frontend-usability-audit',
+    passed: failures.length === 0,
+    failureCount: failures.length,
+    failures,
+  };
+
+  console.log(JSON.stringify(reportPayload, null, 2));
+  process.exit(reportPayload.passed ? 0 : 1);
+}
+
+runAudit();

package/scripts/generate-sbom.mjs

@@ -1,61 +1,61 @@
-#!/usr/bin/env node
-
-/**
- * generate-sbom.mjs
- *
- * Minimal CycloneDX-compatible SBOM for governance CI evidence.
- */
-
-import { readFileSync } from 'node:fs';
-import { resolve, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { randomUUID } from 'node:crypto';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const REPOSITORY_ROOT = resolve(__dirname, '..');
-const PACKAGE_JSON_PATH = resolve(REPOSITORY_ROOT, 'package.json');
-
-function buildComponents(dependencyGroup, dependencies) {
-  return Object.entries(dependencies || {}).map(([dependencyName, dependencyVersion]) => ({
-    type: 'library',
-    name: dependencyName,
-    version: String(dependencyVersion).replace(/^[^\d]*/, ''),
-    scope: dependencyGroup,
-    purl: `pkg:npm/${dependencyName}@${String(dependencyVersion).replace(/^[^\d]*/, '')}`,
-  }));
-}
-
-function generateSbom() {
-  const packageManifest = JSON.parse(readFileSync(PACKAGE_JSON_PATH, 'utf8'));
-  const runtimeComponents = buildComponents('required', packageManifest.dependencies);
-  const developmentComponents = buildComponents('optional', packageManifest.devDependencies);
-  const allComponents = [...runtimeComponents, ...developmentComponents];
-
-  const sbomPayload = {
-    bomFormat: 'CycloneDX',
-    specVersion: '1.5',
-    serialNumber: `urn:uuid:${randomUUID()}`,
-    version: 1,
-    metadata: {
-      timestamp: new Date().toISOString(),
-      component: {
-        type: 'application',
-        name: packageManifest.name,
-        version: packageManifest.version,
-      },
-      tools: [
-        {
-          vendor: 'Agentic-Senior-Core',
-          name: 'generate-sbom.mjs',
-          version: packageManifest.version,
-        },
-      ],
-    },
-    components: allComponents,
-  };
-
-  console.log(JSON.stringify(sbomPayload, null, 2));
-}
-
-generateSbom();
+#!/usr/bin/env node
+
+/**
+ * generate-sbom.mjs
+ *
+ * Minimal CycloneDX-compatible SBOM for governance CI evidence.
+ */
+
+import { readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { randomUUID } from 'node:crypto';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const REPOSITORY_ROOT = resolve(__dirname, '..');
+const PACKAGE_JSON_PATH = resolve(REPOSITORY_ROOT, 'package.json');
+
+function buildComponents(dependencyGroup, dependencies) {
+  return Object.entries(dependencies || {}).map(([dependencyName, dependencyVersion]) => ({
+    type: 'library',
+    name: dependencyName,
+    version: String(dependencyVersion).replace(/^[^\d]*/, ''),
+    scope: dependencyGroup,
+    purl: `pkg:npm/${dependencyName}@${String(dependencyVersion).replace(/^[^\d]*/, '')}`,
+  }));
+}
+
+function generateSbom() {
+  const packageManifest = JSON.parse(readFileSync(PACKAGE_JSON_PATH, 'utf8'));
+  const runtimeComponents = buildComponents('required', packageManifest.dependencies);
+  const developmentComponents = buildComponents('optional', packageManifest.devDependencies);
+  const allComponents = [...runtimeComponents, ...developmentComponents];
+
+  const sbomPayload = {
+    bomFormat: 'CycloneDX',
+    specVersion: '1.5',
+    serialNumber: `urn:uuid:${randomUUID()}`,
+    version: 1,
+    metadata: {
+      timestamp: new Date().toISOString(),
+      component: {
+        type: 'application',
+        name: packageManifest.name,
+        version: packageManifest.version,
+      },
+      tools: [
+        {
+          vendor: 'Agentic-Senior-Core',
+          name: 'generate-sbom.mjs',
+          version: packageManifest.version,
+        },
+      ],
+    },
+    components: allComponents,
+  };
+
+  console.log(JSON.stringify(sbomPayload, null, 2));
+}
+
+generateSbom();

package/scripts/governance-weekly-report.mjs

@@ -0,0 +1,293 @@
+#!/usr/bin/env node
+
+/**
+ * governance-weekly-report.mjs
+ *
+ * Aggregates weekly governance readiness signals for maintainers.
+ * Produces a machine-readable report with trend, trust, and release posture.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import fs from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { calculateTrustScore } from './trust-scorer.mjs';
+
+const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
+const SCRIPT_DIR = dirname(SCRIPT_FILE_PATH);
+const REPOSITORY_ROOT = resolve(SCRIPT_DIR, '..');
+const QUALITY_TREND_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'quality-trend-report.json');
+const REPORT_PATH = join(REPOSITORY_ROOT, '.agent-context', 'state', 'weekly-governance-report.json');
+const ARGUMENT_FLAGS = new Set(process.argv.slice(2));
+const isStdoutOnlyMode = ARGUMENT_FLAGS.has('--stdout-only');
+const WEEKLY_WINDOW_DAYS = 7;
+const HISTORY_LIMIT = 26;
+const REQUIRED_VERIFIED_DOMAINS = new Set(['cli', 'frontend', 'fullstack', 'distribution', 'review-quality']);
+
+function readJsonOrNull(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function runJsonScript(scriptRelativePath, scriptArguments = []) {
+  const absoluteScriptPath = join(REPOSITORY_ROOT, scriptRelativePath);
+  const commandResult = spawnSync('node', [absoluteScriptPath, ...scriptArguments], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024 * 10,
+  });
+
+  const standardOutput = (commandResult.stdout || '').trim();
+  const standardError = (commandResult.stderr || '').trim();
+  const exitCode = typeof commandResult.status === 'number' ? commandResult.status : 1;
+
+  if (!standardOutput) {
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: null,
+      parseError: 'Script produced no stdout JSON payload',
+      stderr: standardError,
+    };
+  }
+
+  try {
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: JSON.parse(standardOutput),
+      parseError: null,
+      stderr: standardError,
+    };
+  } catch (jsonParseError) {
+    const parseErrorMessage = jsonParseError instanceof Error ? jsonParseError.message : String(jsonParseError);
+    return {
+      scriptPath: scriptRelativePath,
+      exitCode,
+      parsedReport: null,
+      parseError: parseErrorMessage,
+      stderr: standardError,
+    };
+  }
+}
+
+function loadQualityTrendReport() {
+  const existingQualityTrend = readJsonOrNull(QUALITY_TREND_PATH);
+  if (existingQualityTrend) {
+    return {
+      source: 'state-file',
+      report: existingQualityTrend,
+      freshness: existingQualityTrend.generatedAt || null,
+    };
+  }
+
+  const generatedQualityTrend = runJsonScript('scripts/quality-trend-report.mjs', ['--stdout-only']);
+  return {
+    source: 'generated-stdout',
+    report: generatedQualityTrend.parsedReport,
+    freshness: generatedQualityTrend.parsedReport?.generatedAt || null,
+    parseError: generatedQualityTrend.parseError,
+    exitCode: generatedQualityTrend.exitCode,
+  };
+}
+
+function collectCommitSignals(windowDays) {
+  const commitLogResult = spawnSync('git', ['log', `--since=${windowDays}.days`, '--pretty=format:%s'], {
+    cwd: REPOSITORY_ROOT,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+  });
+
+  if (commitLogResult.status !== 0) {
+    return {
+      windowDays,
+      commitCount: 0,
+      releaseCommitCount: 0,
+      rollbackCommitCount: 0,
+      releaseFrequencyPercent: null,
+      rollbackFrequencyPercent: null,
+      error: (commitLogResult.stderr || 'Failed to read git log').trim(),
+    };
+  }
+
+  const commitSubjects = (commitLogResult.stdout || '')
+    .split(/\r?\n/u)
+    .map((subjectLine) => subjectLine.trim())
+    .filter((subjectLine) => subjectLine.length > 0);
+
+  const commitCount = commitSubjects.length;
+  const releaseCommitCount = commitSubjects.filter((subjectLine) => /release|publish|chore\(release\)/i.test(subjectLine)).length;
+  const rollbackCommitCount = commitSubjects.filter((subjectLine) => /rollback|revert/i.test(subjectLine)).length;
+
+  return {
+    windowDays,
+    commitCount,
+    releaseCommitCount,
+    rollbackCommitCount,
+    releaseFrequencyPercent: commitCount === 0 ? 0 : Number(((releaseCommitCount / commitCount) * 100).toFixed(2)),
+    rollbackFrequencyPercent: commitCount === 0 ? 0 : Number(((rollbackCommitCount / commitCount) * 100).toFixed(2)),
+    error: null,
+  };
+}
+
+async function collectSkillTrustSignals() {
+  const skillDirectoryPath = join(REPOSITORY_ROOT, '.agent-context', 'skills');
+  const skillDirectoryEntries = await fs.readdir(skillDirectoryPath, { withFileTypes: true });
+  const skillDomainNames = skillDirectoryEntries
+    .filter((directoryEntry) => directoryEntry.isDirectory())
+    .map((directoryEntry) => directoryEntry.name)
+    .sort((leftDomainName, rightDomainName) => leftDomainName.localeCompare(rightDomainName));
+
+  const trustRows = [];
+  const tierCounts = {
+    verified: 0,
+    community: 0,
+    experimental: 0,
+  };
+
+  for (const skillDomainName of skillDomainNames) {
+    const trustResult = await calculateTrustScore(join(skillDirectoryPath, skillDomainName));
+
+    if (typeof tierCounts[trustResult.tier] === 'number') {
+      tierCounts[trustResult.tier] += 1;
+    }
+
+    trustRows.push({
+      domain: skillDomainName,
+      tier: trustResult.tier,
+      score: trustResult.score,
+    });
+  }
+
+  const requiredVerifiedDomainFailures = trustRows
+    .filter((trustRow) => REQUIRED_VERIFIED_DOMAINS.has(trustRow.domain) && trustRow.tier !== 'verified')
+    .map((trustRow) => trustRow.domain);
+
+  return {
+    domains: trustRows,
+    tierCounts,
+    requiredVerifiedDomains: Array.from(REQUIRED_VERIFIED_DOMAINS),
+    requiredVerifiedDomainFailures,
+    allRequiredVerified: requiredVerifiedDomainFailures.length === 0,
+  };
+}
+
+function buildBlockers(qualityTrendReport, skillTrustSignals, commitSignals) {
+  const blockers = [];
+
+  const qualityGatePassRatePercent = qualityTrendReport?.governanceHealth?.gatePassRatePercent;
+  if (typeof qualityGatePassRatePercent !== 'number' || qualityGatePassRatePercent < 100) {
+    blockers.push('Governance gate pass rate is below 100%.');
+  }
+
+  if (!skillTrustSignals.allRequiredVerified) {
+    blockers.push(
+      `Required verified skill domains missing: ${skillTrustSignals.requiredVerifiedDomainFailures.join(', ')}`
+    );
+  }
+
+  if (commitSignals.error) {
+    blockers.push(`Commit signal extraction failed: ${commitSignals.error}`);
+  }
+
+  return blockers;
+}
+
+function buildHistoryEntry(weeklyReport) {
+  return {
+    generatedAt: weeklyReport.generatedAt,
+    readinessStatus: weeklyReport.releaseReadiness.isReady ? 'ready' : 'blocked',
+    blockerCount: weeklyReport.releaseReadiness.blockers.length,
+    gatePassRatePercent: weeklyReport.qualitySignals.governanceHealth.gatePassRatePercent,
+    verifiedSkillDomainCount: weeklyReport.skillTrust.tierCounts.verified,
+    releaseFrequencyPercent: weeklyReport.commitSignals.releaseFrequencyPercent,
+    rollbackFrequencyPercent: weeklyReport.commitSignals.rollbackFrequencyPercent,
+  };
+}
+
+function mergeHistory(previousReport, currentHistoryEntry) {
+  const existingHistory = Array.isArray(previousReport?.history) ? previousReport.history : [];
+  const mergedHistory = [...existingHistory, currentHistoryEntry];
+
+  if (mergedHistory.length <= HISTORY_LIMIT) {
+    return mergedHistory;
+  }
+
+  return mergedHistory.slice(mergedHistory.length - HISTORY_LIMIT);
+}
+
+async function runWeeklyGovernanceReport() {
+  const qualityTrendState = loadQualityTrendReport();
+  const qualityTrendReport = qualityTrendState.report;
+
+  const skillTrustSignals = await collectSkillTrustSignals();
+  const commitSignals = collectCommitSignals(WEEKLY_WINDOW_DAYS);
+  const blockers = buildBlockers(qualityTrendReport, skillTrustSignals, commitSignals);
+
+  const weeklyReportSnapshot = {
+    generatedAt: new Date().toISOString(),
+    reportName: 'weekly-governance-report',
+    methodology: {
+      qualityTrendSource: qualityTrendState.source,
+      qualityTrendGeneratedAt: qualityTrendState.freshness,
+      commitWindowDays: WEEKLY_WINDOW_DAYS,
+      requiredVerifiedDomains: Array.from(REQUIRED_VERIFIED_DOMAINS),
+    },
+    qualitySignals: {
+      governanceHealth: {
+        availableGateCount: qualityTrendReport?.governanceHealth?.availableGateCount ?? null,
+        passedGateCount: qualityTrendReport?.governanceHealth?.passedGateCount ?? null,
+        gatePassRatePercent: qualityTrendReport?.governanceHealth?.gatePassRatePercent ?? null,
+      },
+      rejectionCategories: Array.isArray(qualityTrendReport?.rejectionCategories)
+        ? qualityTrendReport.rejectionCategories
+        : [],
+      tokenEfficiency: qualityTrendReport?.tokenEfficiency || null,
+    },
+    skillTrust: skillTrustSignals,
+    commitSignals,
+    releaseReadiness: {
+      isReady: blockers.length === 0,
+      blockers,
+      summary: blockers.length === 0
+        ? 'Weekly governance posture is ready for maintenance releases.'
+        : 'Weekly governance posture is blocked by unresolved readiness signals.',
+    },
+    artifact: {
+      path: REPORT_PATH,
+      writeMode: isStdoutOnlyMode ? 'stdout-only' : 'stdout-and-file',
+    },
+  };
+
+  const previousReport = readJsonOrNull(REPORT_PATH);
+  const history = mergeHistory(previousReport, buildHistoryEntry(weeklyReportSnapshot));
+  const weeklyReport = {
+    ...weeklyReportSnapshot,
+    history,
+  };
+
+  if (!isStdoutOnlyMode) {
+    await fs.mkdir(dirname(REPORT_PATH), { recursive: true });
+    await fs.writeFile(REPORT_PATH, JSON.stringify(weeklyReport, null, 2) + '\n', 'utf8');
+  }
+
+  return weeklyReport;
+}
+
+runWeeklyGovernanceReport()
+  .then((weeklyReport) => {
+    console.log(JSON.stringify(weeklyReport, null, 2));
+  })
+  .catch((reportError) => {
+    const errorMessage = reportError instanceof Error ? reportError.message : String(reportError);
+    console.error(`Weekly governance report failed: ${errorMessage}`);
+    process.exit(1);
+  });