@opengsd/gsd-core 1.2.0-rc.1

package/scripts/lint-skill-deps.cjs

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * lint-skill-deps.cjs
+ *
+ * Two checks:
+ *
+ * a) Frontmatter to body consistency:
+ *    For each commands/gsd/*.md, parse requires: and walk the body for
+ *    references to other GSD skills (pattern: /gsd:<stem> or gsd:<stem>).
+ *    Fail if a skill body references a skill not listed in requires:.
+ *
+ * b) Profile closure satisfaction:
+ *    Load PROFILES from install-profiles.cjs. For each non-full profile,
+ *    compute closure(profile.base) using the manifest. If any skill in
+ *    the closure references a skill NOT in the closure, fail.
+ *
+ * Usage:
+ *   node scripts/lint-skill-deps.cjs               # scans commands/gsd/
+ *   node scripts/lint-skill-deps.cjs --dir <path>  # scan a custom dir (testing)
+ *
+ * Exits 0 if all pass; exits 1 if any violation.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const PROFILES_MODULE = path.join(__dirname, '..', 'get-shit-done', 'bin', 'lib', 'install-profiles.cjs');
+const { PROFILES, loadSkillsManifest, resolveProfile } = require(PROFILES_MODULE);
+
+// ---------------------------------------------------------------------------
+// Argument parsing
+// ---------------------------------------------------------------------------
+
+let commandsDir = path.join(__dirname, '..', 'commands', 'gsd');
+const args = process.argv.slice(2);
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--dir' && args[i + 1]) {
+    commandsDir = args[i + 1];
+    i++;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Reference extraction from skill body
+// ---------------------------------------------------------------------------
+
+function extractBodyReferences(body) {
+  const refs = new Set();
+  const re = /(?:\/?)gsd:([a-z0-9_-]+)/g;
+  let m;
+  while ((m = re.exec(body)) !== null) {
+    refs.add(m[1]);
+  }
+  return refs;
+}
+
+function extractBody(content) {
+  const fmEnd = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/m);
+  if (!fmEnd) return content;
+  return content.slice(fmEnd[0].length);
+}
+
+// ---------------------------------------------------------------------------
+// Check a: frontmatter to body consistency
+// ---------------------------------------------------------------------------
+
+function checkFrontmatterBodyConsistency(manifest, allStems) {
+  const violations = [];
+
+  for (const [stem, declared] of manifest) {
+    if (stem.startsWith('_calls_agents_')) continue;
+    const filePath = path.join(commandsDir, stem + '.md');
+    let content;
+    try {
+      content = fs.readFileSync(filePath, 'utf8');
+    } catch {
+      continue;
+    }
+    const body = extractBody(content);
+    const referenced = extractBodyReferences(body);
+    const declaredSet = new Set(declared);
+    for (const ref of referenced) {
+      if (ref === stem) continue;
+      if (!allStems.has(ref)) {
+        violations.push({
+          stem,
+          filePath,
+          undeclared: ref,
+          message: 'body references unknown skill gsd:' + ref,
+        });
+        continue;
+      }
+      if (!declaredSet.has(ref)) {
+        violations.push({
+          stem,
+          filePath,
+          undeclared: ref,
+          message: 'body references gsd:' + ref + ' but requires: does not list it',
+        });
+      }
+    }
+  }
+
+  return violations;
+}
+
+// ---------------------------------------------------------------------------
+// Check b: profile closure satisfaction
+// ---------------------------------------------------------------------------
+
+function checkProfileClosure(manifest) {
+  const violations = [];
+
+  for (const profileName of Object.keys(PROFILES)) {
+    const base = PROFILES[profileName];
+    if (base === '*') continue;
+    const resolved = resolveProfile({ modes: [profileName], manifest });
+    if (resolved.skills === '*') continue;
+
+    const closure = resolved.skills;
+    for (const stem of closure) {
+      const deps = manifest.get(stem) || [];
+      for (const dep of deps) {
+        if (!closure.has(dep)) {
+          violations.push({
+            profile: profileName,
+            stem,
+            missingDep: dep,
+            message: 'profile "' + profileName + '" includes "' + stem + '" which requires "' + dep + '", but "' + dep + '" is not in the closure',
+          });
+        }
+      }
+    }
+  }
+
+  return violations;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+const manifest = loadSkillsManifest(commandsDir);
+const allStems = new Set(
+  [...manifest.keys()].filter((k) => !k.startsWith('_calls_agents_'))
+);
+
+const consistencyViolations = checkFrontmatterBodyConsistency(manifest, allStems);
+const closureViolations = checkProfileClosure(manifest);
+
+const totalViolations = consistencyViolations.length + closureViolations.length;
+
+if (totalViolations === 0) {
+  const checked = manifest.size;
+  process.stdout.write('ok lint-skill-deps: ' + checked + ' skill(s) checked, 0 violations\n');
+  process.exit(0);
+}
+
+process.stderr.write('\nERROR lint-skill-deps: ' + totalViolations + ' violation(s) found\n\n');
+
+if (consistencyViolations.length > 0) {
+  process.stderr.write('Frontmatter to body consistency violations (' + consistencyViolations.length + '):\n\n');
+  for (const v of consistencyViolations) {
+    process.stderr.write('  ' + v.filePath + '\n');
+    process.stderr.write('    ' + v.message + '\n\n');
+  }
+  process.stderr.write('Fix: add missing deps to requires: in the skill frontmatter.\n\n');
+}
+
+if (closureViolations.length > 0) {
+  process.stderr.write('Profile closure violations (' + closureViolations.length + '):\n\n');
+  for (const v of closureViolations) {
+    process.stderr.write('  ' + v.message + '\n');
+  }
+  process.stderr.write('\nFix: add the missing skills to the profile base set in install-profiles.cjs.\n\n');
+}
+
+process.exit(1);

package/scripts/lint-test-file-count.allowlist.json

@@ -0,0 +1,36 @@
+{
+  "_doc": "Baseline of modules currently exceeding the 2-test-file limit. Each entry locks in TODAY's count as the ceiling. Reductions are ratcheted automatically — when a cluster drops to ≤ 2, remove its entry. New entries require justification in PR description.",
+  "modules": {
+    "phase":                  { "current": 5, "issue": "3788" },
+    "worktree":               { "current": 13, "issue": "TBD" },
+    "milestone":              { "current": 10, "issue": "TBD" },
+    "roadmap":                { "current": 9,  "issue": "TBD" },
+    "verify":                 { "current": 10, "issue": "3767" },
+    "install":                { "current": 9,  "issue": "TBD" },
+    "init":                   { "current": 8,  "issue": "TBD" },
+    "state":                  { "current": 11, "issue": "180" },
+    "config":                 { "current": 8,  "issue": "TBD" },
+    "graphify":               { "current": 7,  "issue": "TBD" },
+    "progress":               { "current": 6,  "issue": "14"  },
+    "cli":                    { "current": 5,  "issue": "TBD" },
+    "surface":                { "current": 5,  "issue": "TBD" },
+    "commit":                 { "current": 4,  "issue": "TBD" },
+    "frontmatter":            { "current": 4,  "issue": "TBD" },
+    "index":                  { "current": 5,  "issue": "180" },
+    "intel":                  { "current": 4,  "issue": "TBD" },
+    "mvp":                    { "current": 4,  "issue": "TBD" },
+    "install-profiles":       { "current": 4,  "issue": "TBD" },
+    "audit":                  { "current": 4,  "issue": "192" },
+    "audit-open":             { "current": 3,  "issue": "TBD" },
+    "config-schema":          { "current": 3,  "issue": "TBD" },
+    "profile":                { "current": 3,  "issue": "TBD" },
+    "prompt-budget":          { "current": 3,  "issue": "TBD" },
+    "uat":                    { "current": 3,  "issue": "TBD" },
+    "validate":               { "current": 3,  "issue": "TBD" },
+    "workstream":             { "current": 3,  "issue": "TBD" },
+    "gsd-tools":              { "current": 3,  "issue": "TBD" },
+    "runtime-artifact-layout":{ "current": 3,  "issue": "TBD" },
+    "security":               { "current": 3,  "issue": "TBD" },
+    "gsd-sdk":                { "current": 3,  "issue": "TBD" }
+  }
+}

package/scripts/lint-test-file-count.cjs

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * lint-test-file-count.cjs — max 2 test files per production module.
+ *
+ * Scans sdk/src/query/, sdk/src/, get-shit-done/bin/lib/, bin/ for production
+ * modules, then counts matching test files in tests/ and sdk/src (recursive). Cap is 2
+ * (primary + one integration). Over-limit clusters must be in the allowlist at
+ * their frozen count (ratchet: may only decrease). --json emits structured output.
+ *
+ * Verdicts: OK_UNDER_LIMIT | OK_IN_ALLOWLIST | FAIL_EXCEEDS_LIMIT |
+ *           FAIL_EXCEEDS_ALLOWLIST | HINT_CAN_REMOVE_FROM_ALLOWLIST
+ */
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT = path.join(__dirname, '..');
+const PROD_DIRS = [
+  path.join(ROOT, 'sdk', 'src', 'query'),
+  path.join(ROOT, 'sdk', 'src'),
+  path.join(ROOT, 'get-shit-done', 'bin', 'lib'),
+  path.join(ROOT, 'bin'),
+];
+const TEST_DIRS = [
+  path.join(ROOT, 'tests'),
+  path.join(ROOT, 'sdk', 'src'),
+];
+const ALLOWLIST_PATH = path.join(__dirname, 'lint-test-file-count.allowlist.json');
+const MAX_FILES = 2;
+
+const Verdict = Object.freeze({
+  OK_UNDER_LIMIT:                 'OK_UNDER_LIMIT',
+  OK_IN_ALLOWLIST:                'OK_IN_ALLOWLIST',
+  FAIL_EXCEEDS_LIMIT:             'FAIL_EXCEEDS_LIMIT',
+  FAIL_EXCEEDS_ALLOWLIST:         'FAIL_EXCEEDS_ALLOWLIST',
+  HINT_CAN_REMOVE_FROM_ALLOWLIST: 'HINT_CAN_REMOVE_FROM_ALLOWLIST',
+});
+
+function isTestFile(name) {
+  return name.endsWith('.test.ts') || name.endsWith('.test.cjs');
+}
+
+function listFiles(dir, pred) {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true })
+      .filter(e => e.isFile() && pred(e.name))
+      .map(e => path.join(dir, e.name));
+  } catch (_) { return []; }
+}
+
+function findTestFilesRecursive(dir) {
+  const out = [];
+  let entries;
+  try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+  catch (_) { return out; }
+  for (const e of entries) {
+    const full = path.join(dir, e.name);
+    if (e.isDirectory()) out.push(...findTestFilesRecursive(full));
+    else if (isTestFile(e.name)) out.push(full);
+  }
+  return out;
+}
+
+function prodPrefix(filename) {
+  return filename.replace(/\.(cjs|ts|js)$/, '');
+}
+
+// Strip .test.{cjs,ts} and .integration.test.ts, then strip issue stamps.
+function testEffectivePrefix(testName) {
+  const bare = testName
+    .replace(/\.integration\.test\.(ts|cjs)$/, '')
+    .replace(/\.test\.(ts|cjs)$/, '');
+  const m = bare.match(/^(?:feat|bug|enh|fix)-\d+(?:-\d+)*-(.+)$/);
+  return m ? m[1] : bare;
+}
+
+function collectProdPrefixes() {
+  const map = new Map();
+  for (const dir of PROD_DIRS) {
+    for (const f of listFiles(dir, n =>
+      !isTestFile(n) &&
+      !/\.(generated|md|json)(\.|$)/.test(n) &&
+      /\.(ts|cjs|js)$/.test(n)
+    )) {
+      const prefix = prodPrefix(path.basename(f));
+      if (!map.has(prefix)) map.set(prefix, f);
+    }
+  }
+  return map;
+}
+
+function collectAllTestFiles() {
+  const seen = new Set();
+  const all = [];
+  for (const dir of TEST_DIRS) {
+    for (const f of findTestFilesRecursive(dir)) {
+      if (!seen.has(f)) { seen.add(f); all.push(f); }
+    }
+  }
+  return all;
+}
+
+function buildTestMap(prodPrefixes, allTestFiles) {
+  const map = new Map([...prodPrefixes.keys()].map(p => [p, []]));
+  for (const tf of allTestFiles) {
+    const ep = testEffectivePrefix(path.basename(tf));
+    for (const prefix of prodPrefixes.keys()) {
+      if (ep === prefix || ep.startsWith(prefix + '-')) {
+        map.get(prefix).push(tf);
+        break;
+      }
+    }
+  }
+  return map;
+}
+
+function loadAllowlist() {
+  try { return JSON.parse(fs.readFileSync(ALLOWLIST_PATH, 'utf-8')).modules || {}; }
+  catch (_) { return {}; }
+}
+
+function evaluateLint({ prefix, testFiles, allowlist }) {
+  const count = testFiles.length;
+  const entry = allowlist[prefix];
+  const ceiling = entry ? entry.current : null;
+  if (entry !== undefined) {
+    if (count <= MAX_FILES)    return { verdict: Verdict.HINT_CAN_REMOVE_FROM_ALLOWLIST, prefix, count, ceiling, files: testFiles };
+    if (count <= ceiling)      return { verdict: Verdict.OK_IN_ALLOWLIST,                prefix, count, ceiling, files: testFiles };
+    return                            { verdict: Verdict.FAIL_EXCEEDS_ALLOWLIST,          prefix, count, ceiling, files: testFiles };
+  }
+  if (count <= MAX_FILES) return { verdict: Verdict.OK_UNDER_LIMIT,    prefix, count, ceiling: null, files: testFiles };
+  return                         { verdict: Verdict.FAIL_EXCEEDS_LIMIT, prefix, count, ceiling: null, files: testFiles };
+}
+
+function run() {
+  const jsonMode = process.argv.includes('--json');
+  const prodPrefixes = collectProdPrefixes();
+  const allTestFiles = collectAllTestFiles();
+  const testMap      = buildTestMap(prodPrefixes, allTestFiles);
+  const allowlist    = loadAllowlist();
+
+  const results = [];
+  for (const [prefix, files] of testMap) {
+    if (files.length === 0) continue;
+    results.push(evaluateLint({ prefix, testFiles: files, allowlist }));
+  }
+
+  const failures = results.filter(r =>
+    r.verdict === Verdict.FAIL_EXCEEDS_LIMIT || r.verdict === Verdict.FAIL_EXCEEDS_ALLOWLIST);
+  const hints = results.filter(r => r.verdict === Verdict.HINT_CAN_REMOVE_FROM_ALLOWLIST);
+
+  if (jsonMode) {
+    console.log(JSON.stringify({ ok: failures.length === 0, results, failures, hints }, null, 2));
+    process.exit(failures.length > 0 ? 1 : 0);
+  }
+
+  if (failures.length === 0) {
+    const inAllowlist = results.filter(r => r.verdict === Verdict.OK_IN_ALLOWLIST).length;
+    console.log(`ok lint-test-file-count: ${results.length} module(s) checked, 0 failures` +
+      (inAllowlist > 0 ? `, ${inAllowlist} allowlisted` : '') +
+      (hints.length > 0 ? `, ${hints.length} hint(s)` : ''));
+    for (const h of hints) {
+      console.log(`  hint: "${h.prefix}" is allowlisted at ${h.ceiling} but now has ${h.count} — remove from allowlist`);
+    }
+    process.exit(0);
+  }
+
+  process.stderr.write(`\nERROR lint-test-file-count: ${failures.length} module(s) exceed the test-file limit\n\n`);
+  for (const f of failures) {
+    const tag = f.verdict === Verdict.FAIL_EXCEEDS_LIMIT
+      ? `${f.count} files (limit ${MAX_FILES})`
+      : `${f.count} files (allowlist ceiling ${f.ceiling})`;
+    process.stderr.write(`  ${f.prefix}: ${tag}\n`);
+    for (const tf of f.files) process.stderr.write(`    ${path.relative(ROOT, tf)}\n`);
+  }
+  process.stderr.write('\nFix: consolidate test files per module (one primary + one integration).\n');
+  process.stderr.write('Or add the module to scripts/lint-test-file-count.allowlist.json with PR justification.\n\n');
+  process.exit(1);
+}
+
+module.exports = {
+  Verdict, evaluateLint, testEffectivePrefix, prodPrefix,
+  _collectProdPrefixes: collectProdPrefixes,
+  _collectAllTestFiles: collectAllTestFiles,
+  _buildTestMap: buildTestMap,
+  _loadAllowlist: loadAllowlist,
+};
+
+if (require.main === module) run();

package/scripts/pr-template-policy.cjs

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+
+const { matchesGlob } = require('path');
+
+const TRUSTED_AUTHOR_ASSOCIATIONS = new Set([
+  'CONTRIBUTOR',
+  'COLLABORATOR',
+  'MEMBER',
+  'OWNER',
+]);
+
+const DEFAULT_TEMPLATE_MARKERS = [
+  'Wrong template',
+  'Every PR must use a typed template',
+  'Select the template that matches your PR',
+];
+
+/**
+ * Glob patterns for files that are considered CI/tooling/docs scope.
+ * If ALL changed files in a PR match at least one of these patterns,
+ * template enforcement is skipped automatically.
+ */
+const TOOLING_PATH_ALLOWLIST = [
+  '.github/**',
+  'scripts/**',
+  'docs/**',
+  '*.md',
+  '.changeset/**',
+  'package.json',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'Pipfile',
+  'Pipfile.lock',
+  'requirements.txt',
+  'requirements*.txt',
+  'poetry.lock',
+  'Gemfile',
+  'Gemfile.lock',
+  'go.sum',
+  'go.mod',
+];
+
+/**
+ * Matches an explicit PR-template exemption marker of the form:
+ *   <!-- pr-template-exempt: <non-empty reason> -->
+ *
+ * Capture group 1 is the reason (trimmed). Empty/whitespace-only reasons
+ * do NOT match because the pattern requires at least one non-whitespace
+ * character in the captured body.
+ */
+const EXEMPT_MARKER_REGEX = /<!--\s*pr-template-exempt:\s*([\s\S]*?\S)\s*-->/;
+
+const TEMPLATES = [
+  {
+    name: 'fix',
+    heading: 'Fix PR',
+    requiredHeadings: [
+      'Fix PR',
+      'Linked Issue',
+      'What was broken',
+      'What this fix does',
+      'Testing',
+      'Checklist',
+    ],
+  },
+  {
+    name: 'enhancement',
+    heading: 'Enhancement PR',
+    requiredHeadings: [
+      'Enhancement PR',
+      'Linked Issue',
+      'What this enhancement improves',
+      'Before / After',
+      'How it was implemented',
+      'Testing',
+      'Scope confirmation',
+      'Checklist',
+    ],
+  },
+  {
+    name: 'feature',
+    heading: 'Feature PR',
+    requiredHeadings: [
+      'Feature PR',
+      'Linked Issue',
+      'Feature summary',
+      'What changed',
+      'Implementation notes',
+      'Spec compliance',
+      'Testing',
+      'Scope confirmation',
+      'Checklist',
+    ],
+  },
+];
+
+function stripMarkdownDecoration(value) {
+  return value
+    .replace(/^\s*#+\s*/, '')
+    .replace(/\s*#+\s*$/, '')
+    .replace(/\*\*/g, '')
+    .trim()
+    .toLowerCase();
+}
+
+function extractHeadings(body) {
+  const headings = new Set();
+  for (const line of String(body || '').split(/\r?\n/)) {
+    if (/^\s*#{1,6}\s+\S/.test(line)) {
+      headings.add(stripMarkdownDecoration(line));
+    }
+  }
+  return headings;
+}
+
+function includesDefaultTemplate(body) {
+  const text = String(body || '').toLowerCase();
+  return DEFAULT_TEMPLATE_MARKERS.some((marker) => text.includes(marker.toLowerCase()));
+}
+
+function matchingTemplate(body) {
+  const headings = extractHeadings(body);
+  for (const template of TEMPLATES) {
+    if (!headings.has(stripMarkdownDecoration(template.heading))) continue;
+    const missingHeadings = template.requiredHeadings.filter((heading) => {
+      return !headings.has(stripMarkdownDecoration(heading));
+    });
+    return {
+      template: template.name,
+      missingHeadings,
+    };
+  }
+  return {
+    template: null,
+    missingHeadings: [],
+  };
+}
+
+/**
+ * Returns true iff every path in changedFiles matches at least one glob
+ * pattern in the allowlist. Returns false for an empty file list (no
+ * files means we cannot confirm it is a tooling-only PR).
+ */
+function allPathsAreTooling(changedFiles, allowlist) {
+  if (!Array.isArray(changedFiles) || changedFiles.length === 0) return false;
+  return changedFiles.every((file) =>
+    allowlist.some((pattern) => matchesGlob(file, pattern)),
+  );
+}
+
+/**
+ * Returns true iff the body contains an explicit exemption marker with a
+ * non-empty (non-whitespace) reason.
+ */
+function hasExemptMarker(body, regex) {
+  const match = regex.exec(String(body || ''));
+  if (!match) return false;
+  return match[1].trim().length > 0;
+}
+
+function evaluatePrTemplate(body, authorAssociation, changedFiles) {
+  const association = String(authorAssociation || '').toUpperCase();
+  const trusted = TRUSTED_AUTHOR_ASSOCIATIONS.has(association);
+  const normalizedBody = String(body || '').trim();
+
+  // --- Carve-out 1: all changed files are in the tooling allowlist ---
+  if (allPathsAreTooling(changedFiles, TOOLING_PATH_ALLOWLIST)) {
+    return {
+      valid: true,
+      action: 'pass',
+      trusted,
+      authorAssociation: association || 'UNKNOWN',
+      template: null,
+      reason: null,
+      missingHeadings: [],
+      skipped: 'tooling-paths',
+    };
+  }
+
+  // --- Carve-out 2: explicit exemption marker in the PR body ---
+  if (hasExemptMarker(normalizedBody, EXEMPT_MARKER_REGEX)) {
+    return {
+      valid: true,
+      action: 'pass',
+      trusted,
+      authorAssociation: association || 'UNKNOWN',
+      template: null,
+      reason: null,
+      missingHeadings: [],
+      skipped: 'exempt-marker',
+    };
+  }
+
+  let valid = true;
+  let reason = 'PR body uses a typed pull request template.';
+  let template = null;
+  let missingHeadings = [];
+
+  if (!normalizedBody) {
+    valid = false;
+    reason = 'PR body is empty; a typed pull request template is required.';
+  } else {
+    const match = matchingTemplate(normalizedBody);
+    template = match.template;
+    missingHeadings = match.missingHeadings;
+    if (template && missingHeadings.length === 0) {
+      valid = true;
+    } else if (template && missingHeadings.length > 0) {
+      valid = false;
+      reason = `PR body appears to use the ${template} template but is missing required headings.`;
+    } else if (includesDefaultTemplate(normalizedBody)) {
+      valid = false;
+      reason = 'PR body still contains the default wrong-template guidance.';
+    } else {
+      valid = false;
+      reason = 'PR body does not match the fix, enhancement, or feature template.';
+    }
+  }
+
+  let action = 'pass';
+  if (!valid) {
+    action = trusted ? 'warn' : 'close';
+  }
+
+  return {
+    valid,
+    action,
+    trusted,
+    authorAssociation: association || 'UNKNOWN',
+    template,
+    reason,
+    missingHeadings,
+  };
+}
+
+function main() {
+  const changedFiles = process.env.CHANGED_FILES
+    ? process.env.CHANGED_FILES.split('\n').map((f) => f.trim()).filter(Boolean)
+    : undefined;
+  const result = evaluatePrTemplate(
+    process.env.PR_BODY || '',
+    process.env.AUTHOR_ASSOCIATION || '',
+    changedFiles,
+  );
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (process.env.GITHUB_OUTPUT) {
+    const fs = require('fs');
+    fs.appendFileSync(process.env.GITHUB_OUTPUT, `result=${JSON.stringify(result)}\n`);
+    fs.appendFileSync(process.env.GITHUB_OUTPUT, `action=${result.action}\n`);
+    fs.appendFileSync(process.env.GITHUB_OUTPUT, `valid=${result.valid ? 'true' : 'false'}\n`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  evaluatePrTemplate,
+  extractHeadings,
+  includesDefaultTemplate,
+  matchingTemplate,
+  allPathsAreTooling,
+  hasExemptMarker,
+  TOOLING_PATH_ALLOWLIST,
+  EXEMPT_MARKER_REGEX,
+};