@hegemonart/get-design-done 1.27.6 → 1.28.0

package/scripts/lib/install/mcp-register.cjs

@@ -0,0 +1,235 @@
+'use strict';
+// scripts/lib/install/mcp-register.cjs
+// ---------------------------------------------------------------------------
+// Plan 27.7-04 — registers `gdd-mcp` with the two harnesses that matter
+// (Claude Code, Codex) and detects existing registration. Idempotent;
+// graceful absent-CLI fallback (D-07).
+//
+// Pure library — no side effects on require. Invoked by:
+//   - scripts/install.cjs --register-mcp (opt-in; default off per D-07)
+//   - skills/health/SKILL.md check-mcp-registration step (read-only detect)
+//
+// spawnFn injection allows tests to mock child_process.spawnSync without
+// touching real CLIs in CI.
+//
+// Threat model: scripts/install.cjs --register-mcp writes to harness user-
+// level config. Command args are hardcoded in HARNESSES (no command-
+// injection surface); `--` separator before MCP_NAME prevents flag
+// injection (T-27.7-04-06).
+
+const { spawnSync } = require('node:child_process');
+
+const MCP_NAME = 'gdd-mcp';
+
+const HARNESSES = Object.freeze({
+  claude: Object.freeze({
+    binary: 'claude',
+    addArgs: Object.freeze(['mcp', 'add', MCP_NAME, '-s', 'user', '--', MCP_NAME]),
+    listArgs: Object.freeze(['mcp', 'list']),
+    listMatchPattern: /\bgdd-mcp\b/,
+  }),
+  codex: Object.freeze({
+    binary: 'codex',
+    addArgs: Object.freeze(['mcp', 'add', MCP_NAME, '--', MCP_NAME]),
+    listArgs: Object.freeze(['mcp', 'list']),
+    listMatchPattern: /\bgdd-mcp\b/,
+  }),
+});
+
+/**
+ * Build the command tuple for a given harness + mode.
+ * Currently only 'register' (add) is supported in command-build; 'detect'
+ * uses listArgs internally, 'unregister' is reserved for future work.
+ */
+function buildHarnessCommand(harness, mode = 'register') {
+  const h = HARNESSES[harness];
+  if (!h) throw new Error('Unknown harness: ' + harness);
+  if (mode === 'register') {
+    return { binary: h.binary, args: Array.from(h.addArgs) };
+  }
+  if (mode === 'detect') {
+    return { binary: h.binary, args: Array.from(h.listArgs) };
+  }
+  throw new Error('Unsupported mode: ' + mode);
+}
+
+/**
+ * Detect whether the harness CLI is on PATH. Runs `<binary> --version` and
+ * returns true iff exit code is 0. Catches ENOENT (binary missing).
+ */
+function detectHarnessPresent(harness, spawnFn = spawnSync) {
+  const h = HARNESSES[harness];
+  if (!h) throw new Error('Unknown harness: ' + harness);
+  let result;
+  try {
+    result = spawnFn(h.binary, ['--version'], {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+  } catch (_e) {
+    return false;
+  }
+  if (!result) return false;
+  if (result.error && result.error.code === 'ENOENT') return false;
+  return result.status === 0;
+}
+
+/**
+ * Detect whether gdd-mcp is already registered with the given harness.
+ * Runs `<binary> mcp list` and matches against listMatchPattern.
+ */
+function isAlreadyRegistered(harness, spawnFn = spawnSync) {
+  const h = HARNESSES[harness];
+  if (!h) throw new Error('Unknown harness: ' + harness);
+  let result;
+  try {
+    result = spawnFn(h.binary, Array.from(h.listArgs), {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    });
+  } catch (_e) {
+    return false;
+  }
+  if (!result || result.status !== 0) return false;
+  const stdout = (result.stdout || '').toString();
+  return h.listMatchPattern.test(stdout);
+}
+
+/**
+ * Register gdd-mcp with the given harness.
+ *
+ * @param {object} opts
+ * @param {'claude'|'codex'} opts.harness
+ * @param {'register'|'unregister'|'detect'} [opts.mode='register']
+ * @param {boolean} [opts.dryRun=false]
+ * @param {Function} [opts.spawnFn]  child_process.spawnSync substitute
+ * @returns {object} {harness, action, detected, command, applied,
+ *                    idempotent_skip, notice?, stdout?, stderr?,
+ *                    exit_code?, dry_run?}
+ */
+function registerMcp({ harness, mode = 'register', dryRun = false, spawnFn = spawnSync } = {}) {
+  if (!HARNESSES[harness]) {
+    throw new Error('Unknown harness: ' + harness + ' (expected one of: ' + Object.keys(HARNESSES).join(', ') + ')');
+  }
+  if (mode !== 'register' && mode !== 'detect' && mode !== 'unregister') {
+    throw new Error('Unsupported mode: ' + mode);
+  }
+
+  // Step 1 — detect harness CLI on PATH
+  if (!detectHarnessPresent(harness, spawnFn)) {
+    return {
+      harness,
+      action: mode,
+      detected: false,
+      command: null,
+      applied: false,
+      idempotent_skip: false,
+      notice: harness + ' CLI not on PATH — skipping ' + MCP_NAME + ' registration',
+    };
+  }
+
+  // Step 2 — idempotency check: already registered?
+  if (isAlreadyRegistered(harness, spawnFn)) {
+    return {
+      harness,
+      action: mode,
+      detected: true,
+      command: null,
+      applied: false,
+      idempotent_skip: true,
+    };
+  }
+
+  // Step 3 — build + dispatch add command
+  const { binary, args } = buildHarnessCommand(harness, 'register');
+  const commandStr = binary + ' ' + args.join(' ');
+
+  if (dryRun) {
+    return {
+      harness,
+      action: mode,
+      detected: true,
+      command: commandStr,
+      applied: false,
+      idempotent_skip: false,
+      dry_run: true,
+    };
+  }
+
+  let result;
+  try {
+    result = spawnFn(binary, args, { stdio: 'pipe', encoding: 'utf8' });
+  } catch (e) {
+    return {
+      harness,
+      action: mode,
+      detected: true,
+      command: commandStr,
+      applied: false,
+      idempotent_skip: false,
+      stderr: (e && e.message) || String(e),
+      exit_code: null,
+    };
+  }
+  const stdout = (result && result.stdout) || '';
+  const stderr = (result && result.stderr) || '';
+  const exit_code = result ? result.status : null;
+  return {
+    harness,
+    action: mode,
+    detected: true,
+    command: commandStr,
+    applied: exit_code === 0,
+    idempotent_skip: false,
+    stdout: stdout.toString(),
+    stderr: stderr.toString(),
+    exit_code,
+  };
+}
+
+/**
+ * Detect overall MCP registration state across all known harnesses.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.spawnFn]
+ * @returns {{harnesses: Array, summary: string}}
+ */
+function detectMcpRegistration({ spawnFn = spawnSync } = {}) {
+  const harnessIds = Object.keys(HARNESSES);
+  const results = harnessIds.map((harness) => {
+    const present = detectHarnessPresent(harness, spawnFn);
+    let registered;
+    if (present) {
+      registered = isAlreadyRegistered(harness, spawnFn);
+    } else {
+      registered = undefined;
+    }
+    return { harness, present, registered };
+  });
+
+  const anyPresent = results.some((r) => r.present);
+  const registeredHarnesses = results.filter((r) => r.registered === true).map((r) => r.harness);
+
+  let summary;
+  if (!anyPresent) {
+    summary = 'unknown (claude/codex CLI not found)';
+  } else if (registeredHarnesses.length === 0) {
+    summary = 'not registered';
+  } else if (registeredHarnesses.length === harnessIds.length) {
+    summary = 'registered with ' + registeredHarnesses.join('+');
+  } else {
+    summary = 'registered with ' + registeredHarnesses.join('+');
+  }
+
+  return { harnesses: results, summary };
+}
+
+module.exports = {
+  registerMcp,
+  detectMcpRegistration,
+  detectHarnessPresent,
+  isAlreadyRegistered,
+  buildHarnessCommand,
+  HARNESSES,
+  MCP_NAME,
+};

package/scripts/lib/install/mcp-register.d.cts

@@ -0,0 +1,64 @@
+// scripts/lib/install/mcp-register.d.cts
+// ---------------------------------------------------------------------------
+// Plan 27.7-04 — TypeScript ambient declarations for the mcp-register lib.
+// Sibling .d.cts kept in sync with mcp-register.cjs (Phase 27.6 lesson —
+// precautionary for TS consumers).
+
+import type { spawnSync } from 'node:child_process';
+
+export interface Harness {
+  readonly binary: string;
+  readonly addArgs: readonly string[];
+  readonly listArgs: readonly string[];
+  readonly listMatchPattern: RegExp;
+}
+
+export const HARNESSES: Readonly<Record<'claude' | 'codex', Harness>>;
+export const MCP_NAME: string;
+
+export type HarnessId = 'claude' | 'codex';
+export type RegisterMode = 'register' | 'unregister' | 'detect';
+
+export interface RegisterMcpResult {
+  harness: HarnessId;
+  action: RegisterMode;
+  detected: boolean;
+  command: string | null;
+  applied: boolean;
+  idempotent_skip: boolean;
+  notice?: string;
+  stdout?: string;
+  stderr?: string;
+  exit_code?: number | null;
+  dry_run?: boolean;
+}
+
+export interface HarnessDetectEntry {
+  harness: HarnessId;
+  present: boolean;
+  registered: boolean | undefined;
+}
+
+export interface DetectResult {
+  harnesses: HarnessDetectEntry[];
+  summary: string;
+}
+
+export type SpawnFn = typeof spawnSync;
+
+export interface RegisterMcpOptions {
+  harness: HarnessId;
+  mode?: RegisterMode;
+  dryRun?: boolean;
+  spawnFn?: SpawnFn;
+}
+
+export interface DetectMcpRegistrationOptions {
+  spawnFn?: SpawnFn;
+}
+
+export function registerMcp(opts: RegisterMcpOptions): RegisterMcpResult;
+export function detectMcpRegistration(opts?: DetectMcpRegistrationOptions): DetectResult;
+export function detectHarnessPresent(harness: HarnessId, spawnFn?: SpawnFn): boolean;
+export function isAlreadyRegistered(harness: HarnessId, spawnFn?: SpawnFn): boolean;
+export function buildHarnessCommand(harness: HarnessId, mode?: RegisterMode): { binary: string; args: string[] };

package/scripts/lib/intel-store/index.cjs

@@ -0,0 +1,55 @@
+'use strict';
+// scripts/lib/intel-store/index.cjs — Plan 27.7-02
+//
+// Slice reader over <rootDir>/.design/intel/<slice_id>.json. Different
+// surface from scripts/lib/design-search.cjs (which does cross-cycle
+// FTS/grep recall) — see CONTEXT.md Warning #7.
+//
+// Surface:
+//   class IntelNotFoundError extends Error    — code='directory_not_found'
+//   async readSlice(rootDir, sliceId)         — parsed slice | null
+//   listSlices(rootDir)                       — string[] of slice ids
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+class IntelNotFoundError extends Error {
+  constructor(dir) {
+    super('source directory not found: ' + dir);
+    this.name = 'IntelNotFoundError';
+    this.code = 'directory_not_found';
+    this.dir = dir;
+  }
+}
+
+/** Read slice <rootDir>/.design/intel/<sliceId>.json. Returns parsed
+ *  JSON or `null` if the slice file is missing. Throws
+ *  IntelNotFoundError when the intel directory itself is absent. */
+async function readSlice(rootDir, sliceId) {
+  const dir = path.join(rootDir, '.design', 'intel');
+  if (!fs.existsSync(dir)) {
+    throw new IntelNotFoundError(dir);
+  }
+  const file = path.join(dir, sliceId + '.json');
+  if (!fs.existsSync(file)) return null;
+  const body = await fs.promises.readFile(file, 'utf8');
+  return JSON.parse(body);
+}
+
+/** List slice ids (file basenames without extension) under .design/intel/.
+ *  Throws IntelNotFoundError when the directory is absent. */
+function listSlices(rootDir) {
+  const dir = path.join(rootDir, '.design', 'intel');
+  if (!fs.existsSync(dir)) {
+    throw new IntelNotFoundError(dir);
+  }
+  const entries = fs.readdirSync(dir);
+  const ids = [];
+  for (const name of entries) {
+    if (!name.endsWith('.json')) continue;
+    ids.push(name.slice(0, -'.json'.length));
+  }
+  return ids;
+}
+
+module.exports = { readSlice, listSlices, IntelNotFoundError };

package/scripts/lib/intel-store/index.d.cts

@@ -0,0 +1,11 @@
+// scripts/lib/intel-store/index.d.cts — TypeScript ambient declarations
+// for the intel-store CJS module. Plan 27.7-02.
+
+export class IntelNotFoundError extends Error {
+  code: 'directory_not_found';
+  dir: string;
+  constructor(dir: string);
+}
+
+export function readSlice(rootDir: string, sliceId: string): Promise<unknown | null>;
+export function listSlices(rootDir: string): string[];

package/scripts/lib/mcp-tools-lint/index.cjs

@@ -0,0 +1,216 @@
+'use strict';
+// scripts/lib/mcp-tools-lint/index.cjs
+// ---------------------------------------------------------------------------
+// Plan 27.7-03 — static lint for the gdd-mcp tools directory.
+//
+// 4 invariants enforced (origin: Phase 27.7 CONTEXT decisions):
+//
+//   forbid-fs-path (D-06):  No direct `node:fs`/`node:path` (or bare `fs`/
+//                           `path`) imports inside individual tool .ts
+//                           files. Tools must be thin wrappers — all
+//                           filesystem I/O routes through scripts/lib/*
+//                           helpers (gdd-state, intel-store, etc.). The
+//                           `index.ts` and `shared.ts` siblings ARE
+//                           infrastructure and are exempt.
+//
+//   max-loc (D-06):         Each tool .ts file ≤ 30 non-blank-non-comment
+//                           LOC. Exempt: index.ts, shared.ts.
+//
+//   no-write-names (D-04):  Hard-block every write-verb tool name. A tool
+//                           name matching /_(create|update|delete|append|
+//                           clear|write|set)(_|$)/ is rejected. The MCP
+//                           server is read-only by design.
+//
+//   tool-count-cap (D-03):  ≤ 12 files matching `gdd_*.ts` glob in the
+//                           tools directory. Hard cap. Adding a 13th tool
+//                           requires re-scoping in a new plan.
+//
+// Public API:
+//   lintMcpToolsDir({dir, maxLoc?, toolCap?, exemptions?}) →
+//     { violations: LintViolation[], summary: { files_scanned, violations_count } }
+//
+// Consumed by tests/gdd-mcp-tools-lint.test.cjs and
+// tests/phase-27-7-baseline.test.cjs (Plan 27.7-07).
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_EXEMPTIONS = new Set(['index.ts', 'shared.ts']);
+const DEFAULT_MAX_LOC = 30;
+const DEFAULT_TOOL_CAP = 12;
+const TOOL_FILE_GLOB = /^gdd_[a-z0-9_]+\.ts$/;
+
+const FORBIDDEN_IMPORT_PATTERNS = Object.freeze([
+  /from\s+['"]node:fs['"]/,
+  /from\s+['"]node:fs\/promises['"]/,
+  /from\s+['"]node:path['"]/,
+  /from\s+['"]fs['"]/,
+  /from\s+['"]path['"]/,
+  /require\s*\(\s*['"]node:fs['"]\s*\)/,
+  /require\s*\(\s*['"]node:fs\/promises['"]\s*\)/,
+  /require\s*\(\s*['"]fs['"]\s*\)/,
+  /require\s*\(\s*['"]node:path['"]\s*\)/,
+  /require\s*\(\s*['"]path['"]\s*\)/,
+]);
+
+// Write-verb pattern: matches when the verb is preceded by `_` and either
+// followed by `_` or end-of-string. e.g. `gdd_decision_append` matches;
+// `gdd_appendix_list` does NOT (the verb must be the trailing token of a
+// `_`-separated name).
+const WRITE_NAME_PATTERN = /_(create|update|delete|append|clear|write|set)(?:_|$)/;
+
+const RULES = Object.freeze([
+  'forbid-fs-path',
+  'max-loc',
+  'no-write-names',
+  'tool-count-cap',
+]);
+
+/**
+ * Count non-blank-non-comment lines.
+ * - Blank lines (whitespace-only) → excluded.
+ * - Lines whose first non-whitespace char is `//` (line comment) → excluded.
+ * - Lines starting with `/*` or `*` (block comment opener/continuation) → excluded.
+ */
+function countLoc(text) {
+  return text.split('\n').filter((line) => {
+    const t = line.trim();
+    if (t.length === 0) return false;
+    if (t.startsWith('//')) return false;
+    if (t.startsWith('/*')) return false;
+    if (t.startsWith('*')) return false;
+    return true;
+  }).length;
+}
+
+/**
+ * Scan source text line-by-line for the FORBIDDEN_IMPORT_PATTERNS.
+ * Returns [{rule, line, message}, …] (file is filled by the caller).
+ */
+function scanForbiddenImports(text) {
+  const violations = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const re of FORBIDDEN_IMPORT_PATTERNS) {
+      const m = line.match(re);
+      if (m) {
+        violations.push({
+          rule: 'forbid-fs-path',
+          line: i + 1,
+          message: 'forbidden import: ' + m[0],
+        });
+        break; // one violation per line is enough.
+      }
+    }
+  }
+  return violations;
+}
+
+/**
+ * Extract the `export const name = '…'` value. Tolerates `"` or `'` quotes
+ * and arbitrary whitespace. Returns {name, line} or null.
+ */
+function extractToolName(text) {
+  const lines = text.split('\n');
+  const re = /export\s+const\s+name\s*(?::\s*[A-Za-z<>{}\s,|]+)?\s*=\s*['"]([^'"]+)['"]/;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(re);
+    if (m) return { name: m[1], line: i + 1 };
+  }
+  return null;
+}
+
+/**
+ * Main entry point. Scans `dir` for *.ts files, applies the 4 rules,
+ * and returns a structured result.
+ *
+ * @param {{dir: string, maxLoc?: number, toolCap?: number, exemptions?: Set<string>}} opts
+ * @returns {{violations: Array<{file: string, rule: string, line: number, message: string}>, summary: {files_scanned: number, violations_count: number}}}
+ */
+function lintMcpToolsDir(opts) {
+  if (!opts || typeof opts.dir !== 'string' || opts.dir.length === 0) {
+    throw new Error('lintMcpToolsDir: opts.dir is required');
+  }
+  const dir = opts.dir;
+  const maxLoc = typeof opts.maxLoc === 'number' ? opts.maxLoc : DEFAULT_MAX_LOC;
+  const toolCap =
+    typeof opts.toolCap === 'number' ? opts.toolCap : DEFAULT_TOOL_CAP;
+  const exemptions =
+    opts.exemptions instanceof Set ? opts.exemptions : DEFAULT_EXEMPTIONS;
+
+  const violations = [];
+
+  const entries = fs.readdirSync(dir);
+  const tsFiles = entries.filter((e) => e.endsWith('.ts'));
+
+  // Rule D — tool-count-cap (matches `gdd_*.ts` files only; index/shared
+  // never count toward the cap).
+  const toolFiles = entries.filter((e) => TOOL_FILE_GLOB.test(e));
+  if (toolFiles.length > toolCap) {
+    violations.push({
+      file: dir,
+      rule: 'tool-count-cap',
+      line: 0,
+      message: 'count=' + toolFiles.length + ' > cap=' + toolCap,
+    });
+  }
+
+  // Rules A, B, C — per-file scans.
+  for (const fname of tsFiles) {
+    const text = fs.readFileSync(path.join(dir, fname), 'utf8');
+    const isExempt = exemptions.has(fname);
+
+    // Rule A — forbid-fs-path (skip exemptions).
+    if (!isExempt) {
+      const fsViolations = scanForbiddenImports(text);
+      for (const v of fsViolations) {
+        violations.push({ file: fname, ...v });
+      }
+    }
+
+    // Rule B — max-loc (skip exemptions).
+    if (!isExempt) {
+      const loc = countLoc(text);
+      if (loc > maxLoc) {
+        violations.push({
+          file: fname,
+          rule: 'max-loc',
+          line: 0,
+          message: 'loc=' + loc + ' > max=' + maxLoc,
+        });
+      }
+    }
+
+    // Rule C — no-write-names. Applies to ALL ts files including
+    // exemptions (you should not even define a write-named symbol in
+    // index.ts or shared.ts — that would be a different bug).
+    const ext = extractToolName(text);
+    if (ext && WRITE_NAME_PATTERN.test(ext.name)) {
+      violations.push({
+        file: fname,
+        rule: 'no-write-names',
+        line: ext.line,
+        message: 'write tool name: ' + ext.name,
+      });
+    }
+  }
+
+  return {
+    violations,
+    summary: {
+      files_scanned: tsFiles.length,
+      violations_count: violations.length,
+    },
+  };
+}
+
+module.exports = {
+  lintMcpToolsDir,
+  RULES,
+  DEFAULT_EXEMPTIONS,
+  DEFAULT_MAX_LOC,
+  DEFAULT_TOOL_CAP,
+  FORBIDDEN_IMPORT_PATTERNS,
+  WRITE_NAME_PATTERN,
+};

package/scripts/lib/mcp-tools-lint/index.d.cts

@@ -0,0 +1,74 @@
+// scripts/lib/mcp-tools-lint/index.d.cts — ambient types for the .cjs lib.
+//
+// The runtime consumer is tests/gdd-mcp-tools-lint.test.cjs (CommonJS, so
+// types are not strictly required). This .d.cts ships the Phase 27.6
+// convention (any .cjs lib that may be imported from a .ts file gets a
+// sibling .d.cts) so that a future TypeScript consumer (e.g. a /lint:gdd
+// slash command) gets correct types without a follow-up patch.
+
+/** One detected lint failure. */
+export interface LintViolation {
+  /** Filename (relative to scan dir) or the dir itself for cap violations. */
+  file: string;
+  rule: 'forbid-fs-path' | 'max-loc' | 'no-write-names' | 'tool-count-cap';
+  /** 1-based source line; 0 for whole-file or whole-directory violations. */
+  line: number;
+  /** Human-readable diagnostic, e.g. `loc=42 > max=30`. */
+  message: string;
+}
+
+/** Counts for the scan as a whole. */
+export interface LintSummary {
+  files_scanned: number;
+  violations_count: number;
+}
+
+/** Return shape of {@link lintMcpToolsDir}. */
+export interface LintResult {
+  violations: LintViolation[];
+  summary: LintSummary;
+}
+
+/** Inputs to {@link lintMcpToolsDir}. Only `dir` is required. */
+export interface LintOptions {
+  /** Directory to scan. Tool files match `gdd_*.ts`. */
+  dir: string;
+  /** Max non-blank-non-comment LOC per tool file. Defaults to 30. */
+  maxLoc?: number;
+  /** Max number of `gdd_*.ts` tool files. Defaults to 12. */
+  toolCap?: number;
+  /**
+   * Filenames in `dir` exempt from forbid-fs-path + max-loc rules.
+   * Defaults to {'index.ts', 'shared.ts'}.
+   */
+  exemptions?: Set<string>;
+}
+
+/**
+ * Scan a directory of MCP tool .ts files and apply the 4 invariant rules.
+ * Pure-static — never executes the modules.
+ *
+ * - Rule A (`forbid-fs-path`): no fs/path imports in tool files (D-06).
+ * - Rule B (`max-loc`): each tool ≤ {@link LintOptions.maxLoc} LOC (D-06).
+ * - Rule C (`no-write-names`): no tool name with write-verb substring (D-04).
+ * - Rule D (`tool-count-cap`): ≤ {@link LintOptions.toolCap} tool files (D-03).
+ */
+export function lintMcpToolsDir(opts: LintOptions): LintResult;
+
+/** Ordered list of all rule names this module enforces. */
+export const RULES: readonly LintViolation['rule'][];
+
+/** Default exempt filenames (index.ts + shared.ts). */
+export const DEFAULT_EXEMPTIONS: Set<string>;
+
+/** Default value for the LOC ceiling. */
+export const DEFAULT_MAX_LOC: number;
+
+/** Default value for the tool-count cap. */
+export const DEFAULT_TOOL_CAP: number;
+
+/** The regexes Rule A scans for, line by line. */
+export const FORBIDDEN_IMPORT_PATTERNS: readonly RegExp[];
+
+/** The regex Rule C matches against the extracted `export const name`. */
+export const WRITE_NAME_PATTERN: RegExp;