@ryuenn3123/agentic-senior-core 4.0.3 → 4.1.0

package/scripts/migrate-rule-format/parse-legacy.mjs

@@ -1,180 +0,0 @@
-// @ts-check
-
-/**
- * Best-effort parser for the legacy v3 rule file format. Extracts:
- *   - the H1 title
- *   - an optional intro paragraph (1-3 sentences before the first H2)
- *   - a list of sections, each with H2 title + ordered content blocks
- *
- * Each content block is one of:
- *   { kind: 'paragraph', text }
- *   { kind: 'bullet-list', items: string[] }
- *   { kind: 'sub-bullet-list', items: string[] }  // legacy nested bullets
- *
- * The parser intentionally throws on shapes it cannot represent in the new
- * format. This forces the human migrator to review unusual sections instead of
- * silently losing content.
- */
-
-/**
- * @typedef {{ kind: 'paragraph', text: string }} ParagraphBlock
- * @typedef {{ kind: 'bullet-list', items: string[] }} BulletListBlock
- * @typedef {ParagraphBlock | BulletListBlock} ContentBlock
- *
- * @typedef {{
- *   title: string,
- *   blocks: ContentBlock[],
- * }} ParsedSection
- *
- * @typedef {{
- *   h1Title: string,
- *   introParagraph: string | null,
- *   sections: ParsedSection[],
- *   warnings: string[],
- * }} ParsedRuleFile
- */
-
-/**
- * @param {string} sourceText
- * @returns {ParsedRuleFile}
- */
-export function parseLegacyRuleFile(sourceText) {
-  const lines = sourceText.replace(/\r\n/g, '\n').split('\n');
-  const warnings = [];
-  const isH2 = (line) => line.startsWith('## ');
-  const isH1 = (line) => line.startsWith('# ');
-  const isColonSectionLabel = (line) => /^[A-Z][^:\n]+:$/.test(line.trim());
-
-  let cursor = 0;
-  while (cursor < lines.length && lines[cursor].trim() === '') {
-    cursor += 1;
-  }
-
-  const h1Match = (lines[cursor] || '').match(/^#\s+(.+)$/);
-  if (!h1Match) {
-    throw new Error('Legacy file missing top-level H1 heading at the first non-empty line.');
-  }
-  const h1Title = h1Match[1].trim();
-  cursor += 1;
-
-  while (cursor < lines.length && lines[cursor].trim() === '') {
-    cursor += 1;
-  }
-
-  let introParagraph = null;
-  if (cursor < lines.length && !lines[cursor].startsWith('## ') && !lines[cursor].startsWith('# ')) {
-    const introLines = [];
-    while (cursor < lines.length && !lines[cursor].startsWith('## ') && !lines[cursor].startsWith('# ')) {
-      const line = lines[cursor];
-      if (line.trim() === '' && introLines.length > 0) {
-        break;
-      }
-      if (line.trim() !== '') {
-        introLines.push(line.trim());
-      }
-      cursor += 1;
-    }
-    if (introLines.length > 0) {
-      introParagraph = introLines.join(' ').trim();
-      const sentenceCount = (introParagraph.match(/[.!?](?=\s|$)/g) || []).length;
-      if (sentenceCount > 3) {
-        warnings.push(`Intro paragraph has ${sentenceCount} sentences (max 3 per format spec). Trim or split during manual review.`);
-      }
-    }
-  }
-
-  while (cursor < lines.length && lines[cursor].trim() === '') {
-    cursor += 1;
-  }
-
-  /** @type {ParsedSection[]} */
-  const sections = [];
-  while (cursor < lines.length) {
-    while (cursor < lines.length && lines[cursor].trim() === '') {
-      cursor += 1;
-    }
-    if (cursor >= lines.length) {
-      break;
-    }
-
-    let sectionTitle = '';
-    if (isH2(lines[cursor])) {
-      sectionTitle = lines[cursor].slice(3).trim();
-      cursor += 1;
-    } else if (isColonSectionLabel(lines[cursor])) {
-      sectionTitle = lines[cursor].trim().replace(/:$/, '');
-      cursor += 1;
-    } else if (!isH1(lines[cursor])) {
-      sectionTitle = sections.length === 0 ? 'General Guidance' : 'Boundary Summary';
-    } else {
-      cursor += 1;
-      continue;
-    }
-
-    /** @type {ContentBlock[]} */
-    const blocks = [];
-    while (cursor < lines.length && !isH2(lines[cursor]) && !isH1(lines[cursor]) && !isColonSectionLabel(lines[cursor])) {
-      const line = lines[cursor];
-
-      if (line.trim() === '') {
-        cursor += 1;
-        continue;
-      }
-
-      if (/^\s*-\s+/.test(line)) {
-        const items = [];
-        let nestedItems = [];
-        while (cursor < lines.length && (/^\s*-\s+/.test(lines[cursor]) || lines[cursor].trim() === '' || /^\s{2,}\S/.test(lines[cursor]))) {
-          const bulletLine = lines[cursor];
-          if (bulletLine.trim() === '') {
-            cursor += 1;
-            if (cursor < lines.length && !/^\s*-\s+/.test(lines[cursor])) {
-              break;
-            }
-            continue;
-          }
-          const topMatch = bulletLine.match(/^-\s+(.+)$/);
-          const nestedMatch = bulletLine.match(/^\s{2,}-\s+(.+)$/);
-          const continuationMatch = bulletLine.match(/^\s{2,}(\S.+)$/);
-          if (topMatch) {
-            if (nestedItems.length > 0 && items.length > 0) {
-              items[items.length - 1] += `\n  ${nestedItems.map((nested) => `- ${nested}`).join('\n  ')}`;
-              nestedItems = [];
-            }
-            items.push(topMatch[1].trim());
-          } else if (nestedMatch) {
-            nestedItems.push(nestedMatch[1].trim());
-          } else if (continuationMatch && items.length > 0) {
-            items[items.length - 1] += ` ${continuationMatch[1].trim()}`;
-          } else {
-            break;
-          }
-          cursor += 1;
-        }
-        if (nestedItems.length > 0 && items.length > 0) {
-          items[items.length - 1] += `\n  ${nestedItems.map((nested) => `- ${nested}`).join('\n  ')}`;
-        }
-        blocks.push({ kind: 'bullet-list', items });
-        continue;
-      }
-
-      const paragraphLines = [];
-      while (
-        cursor < lines.length
-        && lines[cursor].trim() !== ''
-        && !isH2(lines[cursor])
-        && !isH1(lines[cursor])
-        && !isColonSectionLabel(lines[cursor])
-        && !/^\s*-\s+/.test(lines[cursor])
-      ) {
-        paragraphLines.push(lines[cursor].trim());
-        cursor += 1;
-      }
-      blocks.push({ kind: 'paragraph', text: paragraphLines.join(' ').trim() });
-    }
-
-    sections.push({ title: sectionTitle, blocks });
-  }
-
-  return { h1Title, introParagraph, sections, warnings };
-}

package/scripts/migrate-rule-format/render-new.mjs

@@ -1,169 +0,0 @@
-// @ts-check
-
-/**
- * Renders a parsed legacy rule file plus a prefix-table entry into the v4
- * canonical format defined in `docs/architecture/format-spec.md`.
- *
- * Section IDs auto-assign sequentially starting at 001. The renderer never
- * skips integers; humans introduce gaps manually during review by editing
- * the produced file (e.g. when expecting later splits).
- *
- * Each parsed bullet-list becomes one numbered item if it has 1-2 items, or a
- * single numbered item with sub-bullets when the list is enumerative (3+
- * items that share the same shape).
- */
-
-import { stringify as stringifyYaml } from 'yaml';
-
-function pickKeywords(parsedRuleFile, prefixEntry) {
-  // Hand-picked first: the file's id_prefix lowercased and the domain itself
-  // are always relevant. Additional keywords are drawn from the highest-signal
-  // kebab-case tokens in the H1 + section titles, capped at 6 total. The
-  // validate gate snippet checks accept either body presence or this array, so
-  // we prioritize tokens that appear in section titles (more likely to be
-  // queried) over tokens buried in paragraphs.
-  const handPicked = new Set([prefixEntry.domain, prefixEntry.prefix.toLowerCase()]);
-  const titleSignal = parsedRuleFile.h1Title + ' ' + parsedRuleFile.sections.map((section) => section.title).join(' ');
-  for (const word of titleSignal.toLowerCase().match(/[a-z][a-z0-9]+(?:-[a-z0-9]+)*/g) ?? []) {
-    if (word.length >= 4 && word.length <= 32 && handPicked.size < 6) {
-      handPicked.add(word);
-    }
-  }
-  return [...handPicked];
-}
-
-function renderFrontmatter(prefixEntry, parsedRuleFile) {
-  // Trimmed v4 frontmatter (per phase-1-format.md GATE B revision):
-  //   - drop `version` for first-time-v1 files (only meaningful when bumped)
-  //   - drop `last_migrated` (git history is the audit trail)
-  //   - cap `keywords` at 6 hand-picked entries instead of 12 auto-extracted
-  const frontmatterObject = {
-    id_prefix: prefixEntry.prefix,
-    domain: prefixEntry.domain,
-    priority: prefixEntry.priority,
-    scope: prefixEntry.scope,
-    applies_to: [...prefixEntry.appliesTo],
-    keywords: pickKeywords(parsedRuleFile, prefixEntry),
-  };
-  const yamlBody = stringifyYaml(frontmatterObject, { lineWidth: 0 }).trimEnd();
-  return `---\n${yamlBody}\n---\n`;
-}
-
-function renderIntroParagraph(parsedRuleFile) {
-  if (!parsedRuleFile.introParagraph) return '';
-  return `${parsedRuleFile.introParagraph}\n\n`;
-}
-
-// Common abbreviations that end with a period but are not sentence endings.
-// Mid-sentence occurrences like "etc. The next..." would otherwise be split
-// at the abbreviation. Pre-masking is the cheapest fix and is easy to extend.
-const NON_SENTENCE_ENDING_ABBREVIATIONS = Object.freeze(['e.g', 'i.e', 'etc', 'vs', 'cf', 'Mr', 'Dr', 'Mrs', 'Inc', 'Ltd']);
-const ABBREVIATION_MASK_TOKEN = '\u0001';
-
-function maskAbbreviationPeriods(paragraphText) {
-  let masked = paragraphText;
-  for (const abbreviation of NON_SENTENCE_ENDING_ABBREVIATIONS) {
-    const escaped = abbreviation.replace(/\./g, '\\.');
-    masked = masked.replace(new RegExp(`\\b${escaped}\\.`, 'g'), `${abbreviation}${ABBREVIATION_MASK_TOKEN}`);
-  }
-  return masked;
-}
-
-function unmaskAbbreviationPeriods(text) {
-  return text.replace(new RegExp(ABBREVIATION_MASK_TOKEN, 'g'), '.');
-}
-
-export function paragraphSplitsIntoDirectives(paragraphText) {
-  // A `.` `!` or `?` ends a sentence only when it is followed by whitespace
-  // and an uppercase letter, a backtick (next clause starts with `code`), or
-  // an opening parenthesis. This rule recognizes:
-  //   - file paths     "docs/DESIGN.md"        period + lowercase, no whitespace -> not a boundary
-  //   - dotted versions "v1.5", "2.0.0"        period + digit -> not a boundary
-  //   - domain literals "example.com"          period + lowercase -> not a boundary
-  //   - abbreviations  "e.g.", "i.e.", "etc."  pre-masked so their internal periods do not split
-  // Everything else is treated as sentence-final.
-  const masked = maskAbbreviationPeriods(paragraphText);
-  const SENTENCE_BOUNDARY = /([.!?])\s+(?=[A-Z`(])/g;
-  const sentences = [];
-  let cursor = 0;
-  for (const match of masked.matchAll(SENTENCE_BOUNDARY)) {
-    const sentenceEnd = match.index + match[1].length;
-    sentences.push(unmaskAbbreviationPeriods(masked.slice(cursor, sentenceEnd)).trim());
-    cursor = match.index + match[0].length;
-  }
-  const tail = unmaskAbbreviationPeriods(masked.slice(cursor)).trim();
-  if (tail.length > 0) {
-    sentences.push(tail);
-  }
-  return sentences.filter((sentence) => sentence.length > 0);
-}
-
-function renderBlockAsNumberedItem(block) {
-  if (block.kind === 'paragraph') {
-    return paragraphSplitsIntoDirectives(block.text);
-  }
-
-  // Each bullet becomes its own numbered directive. The format spec allows
-  // sub-bullets only as supporting detail under one parent directive, never
-  // as a way to compress an enumerative list into a single item. Keeping them
-  // as numbered items preserves citability (each becomes a sub-ID candidate
-  // during manual review) and matches the worked example in section 6.2.
-  return [...block.items];
-}
-
-function buildSectionBody(blocks) {
-  const numberedDirectives = [];
-  for (const block of blocks) {
-    const directives = renderBlockAsNumberedItem(block);
-    for (const directive of directives) {
-      numberedDirectives.push(directive);
-    }
-  }
-  return numberedDirectives;
-}
-
-/**
- * @param {{ prefix: string, domain: string, priority: string, scope: string, appliesTo: string[] }} prefixEntry
- * @param {ReturnType<typeof import('./parse-legacy.mjs').parseLegacyRuleFile>} parsedRuleFile
- * @returns {{ rendered: string, sectionAssignments: Array<{ sectionTitle: string, sectionId: string, itemCount: number }>, warnings: string[] }}
- */
-export function renderNewFormat(prefixEntry, parsedRuleFile) {
-  const warnings = [...parsedRuleFile.warnings];
-  const renderedParts = [];
-  renderedParts.push(renderFrontmatter(prefixEntry, parsedRuleFile));
-  renderedParts.push('\n');
-  renderedParts.push(`# ${parsedRuleFile.h1Title}\n\n`);
-  renderedParts.push(renderIntroParagraph(parsedRuleFile));
-
-  const sectionAssignments = [];
-  parsedRuleFile.sections.forEach((section, sectionIndex) => {
-    const sectionId = `${prefixEntry.prefix}-${String(sectionIndex + 1).padStart(3, '0')}`;
-    const numberedItems = buildSectionBody(section.blocks);
-    if (numberedItems.length > 12) {
-      warnings.push(
-        `Section "${section.title}" has ${numberedItems.length} numbered items. Format spec caps at 12; split into two sections during manual review.`,
-      );
-    }
-    if (numberedItems.length === 0) {
-      warnings.push(`Section "${section.title}" produced no numbered items. Manual review required.`);
-    }
-
-    renderedParts.push(`## ${sectionId}: ${section.title}\n\n`);
-    numberedItems.forEach((directive, itemIndex) => {
-      renderedParts.push(`${itemIndex + 1}. ${directive}\n`);
-    });
-    renderedParts.push('\n');
-
-    sectionAssignments.push({
-      sectionTitle: section.title,
-      sectionId,
-      itemCount: numberedItems.length,
-    });
-  });
-
-  return {
-    rendered: renderedParts.join('').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n',
-    sectionAssignments,
-    warnings,
-  };
-}

package/scripts/migrate-rule-format/roundtrip-validate.mjs

@@ -1,89 +0,0 @@
-// @ts-check
-
-/**
- * Roundtrip substance validator.
- *
- * After rendering the new format, we extract the substantial-word set from
- * both the original v3 file and the rendered v4 file, then compute set overlap.
- * Drop in overlap below the threshold means the migration almost certainly
- * lost real content; the helper surfaces the lost words so the human migrator
- * can decide whether the loss is intentional (renamed terms) or a bug.
- */
-
-const STOPWORD_SET = new Set([
-  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'are', 'was',
-  'were', 'has', 'have', 'had', 'not', 'but', 'can', 'will', 'must', 'use',
-  'used', 'using', 'when', 'then', 'than', 'they', 'their', 'them', 'who',
-  'what', 'why', 'how', 'all', 'any', 'one', 'two', 'three', 'four', 'five',
-  'six', 'seven', 'eight', 'nine', 'ten', 'each', 'such', 'some', 'most',
-  'more', 'less', 'only', 'also', 'just', 'over', 'under', 'between', 'across',
-  'before', 'after', 'because', 'while', 'until', 'unless', 'within',
-  'without', 'inside', 'outside', 'about', 'around', 'against', 'through',
-  'throughout', 'during', 'including', 'include', 'includes', 'see', 'note',
-  'rule', 'rules', 'agent', 'agents', 'project', 'repo', 'code', 'file',
-  'files', 'item', 'items', 'list', 'lists', 'thing', 'things', 'value',
-  'values', 'should', 'shall', 'may', 'might', 'could', 'would', 'does',
-  'doing', 'done', 'make', 'makes', 'making', 'made', 'set', 'sets',
-]);
-
-function tokenize(text) {
-  const lowered = text.toLowerCase();
-  // Strip fenced code blocks first (multi-line ``` ... ``` spans).
-  const noFenced = lowered.replace(/```[\s\S]*?```/g, ' ');
-  // Strip inline code spans, but only within a single line so that an
-  // unmatched backtick on a code-heavy line cannot eat the rest of the file.
-  const noInline = noFenced.replace(/`[^`\n]+`/g, ' ');
-  const words = noInline.match(/[a-z][a-z0-9]+(?:-[a-z0-9]+)*/g) ?? [];
-  return words.filter((word) => word.length >= 4 && !STOPWORD_SET.has(word));
-}
-
-/**
- * @param {string} originalSourceText
- * @param {string} renderedSourceText
- * @param {{ minimumOverlapPercent?: number }} [options]
- * @returns {{
- *   passed: boolean,
- *   originalSubstantialWordCount: number,
- *   renderedSubstantialWordCount: number,
- *   overlapPercent: number,
- *   lostWords: string[],
- *   newWords: string[],
- *   minimumRequired: number,
- * }}
- */
-export function roundtripSubstanceCheck(originalSourceText, renderedSourceText, options = {}) {
-  const minimumOverlapPercent = options.minimumOverlapPercent ?? 95;
-  const originalWordCounts = new Map();
-  for (const word of tokenize(originalSourceText)) {
-    originalWordCounts.set(word, (originalWordCounts.get(word) || 0) + 1);
-  }
-  const renderedWordSet = new Set(tokenize(renderedSourceText));
-
-  const lostWords = [];
-  let preservedDistinctWordCount = 0;
-  for (const [word, count] of originalWordCounts.entries()) {
-    if (renderedWordSet.has(word)) {
-      preservedDistinctWordCount += 1;
-    } else {
-      lostWords.push(`${word} (x${count})`);
-    }
-  }
-
-  const originalDistinctCount = originalWordCounts.size;
-  const overlapPercent = originalDistinctCount > 0
-    ? (preservedDistinctWordCount / originalDistinctCount) * 100
-    : 100;
-
-  const originalWordSet = new Set(originalWordCounts.keys());
-  const newWords = [...renderedWordSet].filter((word) => !originalWordSet.has(word));
-
-  return {
-    passed: overlapPercent >= minimumOverlapPercent,
-    originalSubstantialWordCount: originalDistinctCount,
-    renderedSubstantialWordCount: renderedWordSet.size,
-    overlapPercent: Math.round(overlapPercent * 100) / 100,
-    lostWords: lostWords.sort().slice(0, 50),
-    newWords: newWords.sort().slice(0, 50),
-    minimumRequired: minimumOverlapPercent,
-  };
-}

package/scripts/migrate-rule-format.mjs

@@ -1,192 +0,0 @@
-#!/usr/bin/env node
-// @ts-check
-
-/**
- * scripts/migrate-rule-format.mjs
- *
- * Phase 1 Task 1.2 migration helper. Converts a legacy v3 rule file into the
- * canonical v4 format defined in docs/architecture/format-spec.md. Output is written
- * to a `.candidate.md` sibling so the human migrator can review the diff
- * before replacing the original.
- *
- * Usage:
- *   node scripts/migrate-rule-format.mjs <path-to-rule-file>
- *   node scripts/migrate-rule-format.mjs <path> --json
- *   node scripts/migrate-rule-format.mjs <path> --apply
- *
- * Flags:
- *   --json    Print the structured report to stdout (JSON only, no human prose).
- *   --apply   Overwrite the source file with the rendered v4 content. Default
- *             behavior writes a .candidate.md file and leaves the source alone.
- *
- * The helper does not commit, does not stage, and does not call any network.
- *
- * Exit codes:
- *   0 — rendered cleanly + roundtrip overlap >= 95%
- *   1 — roundtrip overlap below threshold OR parser warnings present
- *   2 — input path missing or filename not in the locked prefix table
- */
-
-import { readFileSync, writeFileSync } from 'node:fs';
-import { basename, dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { countTokens } from '../benchmarks/token-usage/lib/token-counter.mjs';
-import { getPrefixEntry } from './migrate-rule-format/id-prefix-table.mjs';
-import { parseLegacyRuleFile } from './migrate-rule-format/parse-legacy.mjs';
-import { renderNewFormat } from './migrate-rule-format/render-new.mjs';
-import { roundtripSubstanceCheck } from './migrate-rule-format/roundtrip-validate.mjs';
-
-const SCRIPT_FILE_PATH = fileURLToPath(import.meta.url);
-const REPOSITORY_ROOT = resolve(dirname(SCRIPT_FILE_PATH), '..');
-
-/**
- * @param {string} ruleFileAbsolutePath
- * @returns {Promise<{
- *   sourcePath: string,
- *   filename: string,
- *   prefix: string,
- *   sectionAssignments: Array<{ sectionTitle: string, sectionId: string, itemCount: number }>,
- *   warnings: string[],
- *   roundtrip: ReturnType<typeof roundtripSubstanceCheck>,
- *   tokenSavings: { original: number, rendered: number, deltaPercent: number },
- *   candidatePath: string,
- *   rendered: string,
- * }>}
- */
-export async function migrateOneRuleFile(ruleFileAbsolutePath) {
-  const filename = basename(ruleFileAbsolutePath);
-  const prefixEntry = getPrefixEntry(filename);
-  const originalSource = readFileSync(ruleFileAbsolutePath, 'utf8');
-  const parsed = parseLegacyRuleFile(originalSource);
-  const { rendered, sectionAssignments, warnings } = renderNewFormat(prefixEntry, parsed);
-  const roundtrip = roundtripSubstanceCheck(originalSource, rendered);
-
-  const originalTokenCount = await countTokens(originalSource, 'openai', 'gpt-4o-2024-08-06');
-  const renderedTokenCount = await countTokens(rendered, 'openai', 'gpt-4o-2024-08-06');
-  const tokenSavings = {
-    original: originalTokenCount.token_count,
-    rendered: renderedTokenCount.token_count,
-    deltaPercent: Math.round(
-      ((renderedTokenCount.token_count - originalTokenCount.token_count) / originalTokenCount.token_count) * 10000,
-    ) / 100,
-  };
-
-  const candidatePath = ruleFileAbsolutePath.replace(/\.md$/, '.candidate.md');
-
-  return {
-    sourcePath: ruleFileAbsolutePath,
-    filename,
-    prefix: prefixEntry.prefix,
-    sectionAssignments,
-    warnings,
-    roundtrip,
-    tokenSavings,
-    candidatePath,
-    rendered,
-  };
-}
-
-function formatHumanReport(report) {
-  const lines = [];
-  lines.push('=================================================');
-  lines.push(`  migrate-rule-format: ${report.filename}`);
-  lines.push('=================================================');
-  lines.push(`  Prefix         : ${report.prefix}`);
-  lines.push(`  Section count  : ${report.sectionAssignments.length}`);
-  lines.push(`  Token (orig)   : ${report.tokenSavings.original}`);
-  lines.push(`  Token (new)    : ${report.tokenSavings.rendered}`);
-  const sign = report.tokenSavings.deltaPercent <= 0 ? '' : '+';
-  lines.push(`  Token delta    : ${sign}${report.tokenSavings.deltaPercent}%`);
-  lines.push(`  Roundtrip      : ${report.roundtrip.passed ? 'PASS' : 'FAIL'} (${report.roundtrip.overlapPercent}% overlap, min ${report.roundtrip.minimumRequired}%)`);
-  lines.push('');
-
-  lines.push('  Sections assigned:');
-  for (const assignment of report.sectionAssignments) {
-    lines.push(`    ${assignment.sectionId.padEnd(12)} ${assignment.itemCount} items   ${assignment.sectionTitle}`);
-  }
-  lines.push('');
-
-  if (report.warnings.length > 0) {
-    lines.push('  Warnings:');
-    for (const warning of report.warnings) {
-      lines.push(`    ! ${warning}`);
-    }
-    lines.push('');
-  }
-
-  if (report.roundtrip.lostWords.length > 0) {
-    lines.push(`  Substantial words present in original, missing in rendered (${report.roundtrip.lostWords.length} of distinct):`);
-    for (const word of report.roundtrip.lostWords.slice(0, 30)) {
-      lines.push(`    - ${word}`);
-    }
-    if (report.roundtrip.lostWords.length > 30) {
-      lines.push(`    ... ${report.roundtrip.lostWords.length - 30} more (see JSON report)`);
-    }
-    lines.push('');
-  }
-
-  return lines.join('\n');
-}
-
-async function runCli() {
-  const argv = process.argv.slice(2);
-  if (argv.length === 0) {
-    console.error('usage: node scripts/migrate-rule-format.mjs <path-to-rule-file> [--json] [--apply]');
-    process.exit(2);
-  }
-
-  const inputPath = argv[0];
-  const jsonMode = argv.includes('--json');
-  const applyMode = argv.includes('--apply');
-  const ruleFileAbsolutePath = resolve(REPOSITORY_ROOT, inputPath);
-
-  let report;
-  try {
-    report = await migrateOneRuleFile(ruleFileAbsolutePath);
-  } catch (migrationError) {
-    if (jsonMode) {
-      process.stdout.write(`${JSON.stringify({ passed: false, error: migrationError.message }, null, 2)}\n`);
-    } else {
-      console.error(`migrate-rule-format failed: ${migrationError.message}`);
-    }
-    process.exit(2);
-  }
-
-  if (applyMode) {
-    writeFileSync(ruleFileAbsolutePath, report.rendered, 'utf8');
-  } else {
-    writeFileSync(report.candidatePath, report.rendered, 'utf8');
-  }
-
-  const exitCode = report.roundtrip.passed && report.warnings.length === 0 ? 0 : 1;
-
-  if (jsonMode) {
-    process.stdout.write(`${JSON.stringify({
-      passed: report.roundtrip.passed,
-      filename: report.filename,
-      prefix: report.prefix,
-      sectionCount: report.sectionAssignments.length,
-      sectionAssignments: report.sectionAssignments,
-      warnings: report.warnings,
-      roundtrip: report.roundtrip,
-      tokenSavings: report.tokenSavings,
-      candidatePath: applyMode ? report.sourcePath : report.candidatePath,
-      mode: applyMode ? 'apply' : 'candidate',
-    }, null, 2)}\n`);
-    process.exit(exitCode);
-  }
-
-  console.log(formatHumanReport(report));
-  if (applyMode) {
-    console.log(`  APPLIED in place: ${report.sourcePath}`);
-  } else {
-    console.log(`  Candidate written: ${report.candidatePath}`);
-    console.log('  Review the diff, then re-run with --apply when satisfied.');
-  }
-  process.exit(exitCode);
-}
-
-if (import.meta.url === `file://${process.argv[1].replace(/\\/g, '/')}` || process.argv[1].endsWith('migrate-rule-format.mjs')) {
-  runCli();
-}