@opengsd/gsd-core 1.2.0 → 1.3.0

package/gsd-core/bin/lib/prompt-budget.cjs

@@ -0,0 +1,305 @@
+"use strict";
+/**
+ * prompt-budget.cts
+ *
+ * Pure functions for assembling and trimming review prompts to fit within
+ * a token budget (ADR-457 build-at-publish: the hand-written
+ * bin/lib/prompt-budget.cjs collapsed to a TypeScript source of truth).
+ * Behaviour is preserved byte-for-behaviour from the prior hand-written .cjs;
+ * only types are added.
+ *
+ * Used by the review pipeline to support small-context models.
+ *
+ * Trim priority (in order — never violate):
+ *   1. Instructions:   ALWAYS kept verbatim
+ *   2. Reserve note tokens FIRST when any trim is anticipated
+ *   3. Roadmap:        ALWAYS kept verbatim
+ *   4. PROJECT.md:     head-shrink to projectMdHeadLines (default 40) if over budget
+ *   5. Plans:          tail-truncate proportionally; never drop a whole plan
+ *   6. Context:        DROP first if still over
+ *   7. Research:       DROP second if still over
+ *   8. Requirements:   DROP last (last-resort)
+ *   9. Hard-fail:      if minimum-set exceeds effectiveBudget
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTokens = estimateTokens;
+exports.applyBudget = applyBudget;
+const NOTE_RESERVE_TOKENS = 80;
+const DEFAULT_NOTE_TEMPLATE = [
+    '<note>',
+    'Prompt automatically trimmed to fit a {budget}-token budget.',
+    'Omitted sections: {omittedList}.',
+    'Plan content truncated by approximately {planTruncationPct}%.',
+    'Treat any missing context as out-of-scope rather than a review concern.',
+    '</note>',
+].join('\n');
+/**
+ * Estimate tokens for a string. Chars / 4, rounded up.
+ */
+function estimateTokens(text) {
+    if (!text)
+        return 0;
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Render the trim-disclosure note.
+ */
+function renderNote(template, budget, omitted, planTruncationPct) {
+    const omittedList = omitted.length > 0 ? omitted.join(', ') : 'none';
+    return template
+        .replace('{budget}', String(budget))
+        .replace('{omittedList}', omittedList)
+        .replace('{planTruncationPct}', String(Math.round(planTruncationPct)));
+}
+/**
+ * Head-shrink a string to at most `maxLines` lines.
+ */
+function headShrink(text, maxLines) {
+    if (maxLines <= 0)
+        return '';
+    let idx = -1;
+    let seen = 0;
+    while (seen < maxLines) {
+        idx = text.indexOf('\n', idx + 1);
+        if (idx === -1)
+            return text;
+        seen += 1;
+    }
+    return text.slice(0, idx);
+}
+/**
+ * Tail-truncate a string to at most `maxChars` characters.
+ */
+function tailTruncate(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return text.slice(0, maxChars);
+}
+/**
+ * Assemble the final prompt string from its sections.
+ */
+function assemblePrompt(parts) {
+    const { instructions, note, roadmap, projectMd, plans, context, research, requirements, } = parts;
+    const blocks = [];
+    blocks.push(instructions);
+    if (note)
+        blocks.push(note);
+    blocks.push('## Roadmap\n\n' + roadmap);
+    if (projectMd)
+        blocks.push('## Project\n\n' + projectMd);
+    const planBlocks = plans
+        .map((p) => '### ' + p.file + '\n\n' + p.content)
+        .join('\n\n');
+    blocks.push('## Plans\n\n' + planBlocks);
+    if (context)
+        blocks.push('## Context\n\n' + context);
+    if (research)
+        blocks.push('## Research\n\n' + research);
+    if (requirements)
+        blocks.push('## Requirements\n\n' + requirements);
+    return blocks.join('\n\n');
+}
+/**
+ * Apply a token budget to a set of review prompt sections.
+ * Returns the trimmed prompt and structured metadata.
+ */
+function applyBudget({ sections, budget, options = {} }) {
+    const { safetyMarginPct = 10, noteTemplate = DEFAULT_NOTE_TEMPLATE, projectMdHeadLines = 40, } = options;
+    const effectiveBudget = Math.floor(budget * (1 - safetyMarginPct / 100));
+    const { instructions, roadmap, plans, projectMd: projectMdRaw = null, context: contextRaw = null, research: researchRaw = null, requirements: requirementsRaw = null, } = sections;
+    // Working mutable state
+    let projectMd = projectMdRaw;
+    let context = contextRaw;
+    let research = researchRaw;
+    let requirements = requirementsRaw;
+    let workingPlans = plans.map((p) => ({ file: p.file, content: p.content }));
+    const omitted = [];
+    let projectMdShrunk = false;
+    let planTruncationPct = 0;
+    let noteInjected = false;
+    let hardFailed = false;
+    // Minimum-set check: instructions + roadmap + 1KB per plan.
+    // NOTE_RESERVE_TOKENS is intentionally excluded here: a note is only injected
+    // when trimming actually occurs, and a prompt that fits without any trim needs
+    // no note at all. Including NOTE_RESERVE_TOKENS here would cause false hard-fails
+    // for prompts that genuinely fit the effective budget untrimmed.
+    const MIN_PLAN_BYTES = 1024;
+    const minPlanTokens = plans.reduce((sum, p) => {
+        return sum + estimateTokens(p.content.slice(0, MIN_PLAN_BYTES));
+    }, 0);
+    const minSet = estimateTokens(instructions) +
+        estimateTokens(roadmap) +
+        minPlanTokens;
+    if (minSet > effectiveBudget) {
+        return {
+            prompt: '',
+            metadata: {
+                budget,
+                effectiveBudget,
+                estimatedTokens: 0,
+                omitted: [],
+                projectMdShrunk: false,
+                planTruncationPct: 0,
+                hardFailed: true,
+                noteInjected: false,
+            },
+        };
+    }
+    // ── Budget accounting ──────────────────────────────────────────────────────
+    const TOKENS_ROADMAP_HEADER = estimateTokens('## Roadmap\n\n');
+    const TOKENS_PROJECT_HEADER = estimateTokens('## Project\n\n');
+    const TOKENS_PLANS_HEADER = estimateTokens('## Plans\n\n');
+    const TOKENS_CONTEXT_HEADER = estimateTokens('## Context\n\n');
+    const TOKENS_RESEARCH_HEADER = estimateTokens('## Research\n\n');
+    const TOKENS_REQUIREMENTS_HEADER = estimateTokens('## Requirements\n\n');
+    const TOKENS_PLAN_ITEM_HEADERS = workingPlans.reduce((sum, p) => sum + estimateTokens('### ' + p.file + '\n\n'), 0);
+    const staticBaseTokens = estimateTokens(instructions) +
+        TOKENS_ROADMAP_HEADER +
+        estimateTokens(roadmap) +
+        TOKENS_PLANS_HEADER +
+        TOKENS_PLAN_ITEM_HEADERS;
+    let projectTokens = projectMd
+        ? TOKENS_PROJECT_HEADER + estimateTokens(projectMd)
+        : 0;
+    let contextTokens = context
+        ? TOKENS_CONTEXT_HEADER + estimateTokens(context)
+        : 0;
+    let researchTokens = research
+        ? TOKENS_RESEARCH_HEADER + estimateTokens(research)
+        : 0;
+    let requirementsTokens = requirements
+        ? TOKENS_REQUIREMENTS_HEADER + estimateTokens(requirements)
+        : 0;
+    let planContentTokens = workingPlans.reduce((sum, p) => sum + estimateTokens(p.content), 0);
+    const getCurrentBaseTokens = () => staticBaseTokens +
+        projectTokens +
+        planContentTokens +
+        contextTokens +
+        researchTokens +
+        requirementsTokens;
+    let currentBaseTokens = getCurrentBaseTokens();
+    // Detect budget pressure: is ANY trim needed?
+    // Pressure exists when the current base tokens already exceed the effective
+    // budget. Only when pressure is real do we reserve NOTE_RESERVE_TOKENS so
+    // the note itself fits after trimming. Checking against
+    // effectiveBudget - NOTE_RESERVE_TOKENS (the old threshold) would cause
+    // spurious pressure 80 tokens early, dropping sections that fit fine.
+    const baseTokens = currentBaseTokens;
+    const budgetUnderPressure = baseTokens > effectiveBudget;
+    // Available for content (reserve note slot when under pressure)
+    const contentBudget = budgetUnderPressure
+        ? effectiveBudget - NOTE_RESERVE_TOKENS
+        : effectiveBudget;
+    // ── Trim step 1: head-shrink PROJECT.md ───────────────────────────────────
+    if (currentBaseTokens > contentBudget && projectMd) {
+        const shrunk = headShrink(projectMd, projectMdHeadLines);
+        if (shrunk !== projectMd) {
+            projectMd = shrunk;
+            projectMdShrunk = true;
+            projectTokens = TOKENS_PROJECT_HEADER + estimateTokens(projectMd);
+            currentBaseTokens = getCurrentBaseTokens();
+        }
+    }
+    // ── Trim step 2: proportional plan truncation ─────────────────────────────
+    if (currentBaseTokens > contentBudget) {
+        // Compute tokens available for plan content only
+        const overhead = staticBaseTokens +
+            projectTokens +
+            contextTokens +
+            researchTokens +
+            requirementsTokens;
+        const planBudgetTokens = contentBudget - overhead;
+        const totalPlanTokens = planContentTokens;
+        if (planBudgetTokens > 0 && planBudgetTokens < totalPlanTokens) {
+            // Proportional share per plan (at least 1KB per plan)
+            const totalOriginalChars = plans.reduce((sum, p) => sum + p.content.length, 0);
+            const totalPlanCharsBudget = planBudgetTokens * 4;
+            workingPlans = workingPlans.map((p) => {
+                const proportionalShare = totalOriginalChars > 0
+                    ? Math.floor((p.content.length / totalOriginalChars) * totalPlanCharsBudget)
+                    : 0;
+                const maxChars = Math.max(proportionalShare, MIN_PLAN_BYTES);
+                return { file: p.file, content: tailTruncate(p.content, maxChars) };
+            });
+            const newTotalChars = workingPlans.reduce((sum, p) => sum + p.content.length, 0);
+            if (totalOriginalChars > 0) {
+                planTruncationPct =
+                    ((totalOriginalChars - newTotalChars) / totalOriginalChars) * 100;
+            }
+            planContentTokens = workingPlans.reduce((sum, p) => sum + estimateTokens(p.content), 0);
+            currentBaseTokens = getCurrentBaseTokens();
+        }
+    }
+    // ── Trim step 3: drop context ─────────────────────────────────────────────
+    if (currentBaseTokens > contentBudget && context) {
+        context = null;
+        omitted.push('context');
+        contextTokens = 0;
+        currentBaseTokens = getCurrentBaseTokens();
+    }
+    // ── Trim step 4: drop research ────────────────────────────────────────────
+    if (currentBaseTokens > contentBudget && research) {
+        research = null;
+        omitted.push('research');
+        researchTokens = 0;
+        currentBaseTokens = getCurrentBaseTokens();
+    }
+    // ── Trim step 5: drop requirements (last resort) ──────────────────────────
+    if (currentBaseTokens > contentBudget && requirements) {
+        requirements = null;
+        omitted.push('requirements');
+        requirementsTokens = 0;
+        currentBaseTokens = getCurrentBaseTokens();
+    }
+    // ── Decide whether note is actually needed ────────────────────────────────
+    const anyTrimOccurred = omitted.length > 0 || projectMdShrunk || planTruncationPct > 0;
+    let note = null;
+    if (anyTrimOccurred) {
+        note = renderNote(noteTemplate, budget, omitted, planTruncationPct);
+        noteInjected = true;
+    }
+    // Suppress unused variable warning — currentBaseTokens is used via the
+    // closure in getCurrentBaseTokens(); the final value is not used directly.
+    void currentBaseTokens;
+    // ── Assemble ──────────────────────────────────────────────────────────────
+    const prompt = assemblePrompt({
+        instructions,
+        note,
+        roadmap,
+        projectMd,
+        plans: workingPlans,
+        context,
+        research,
+        requirements,
+    });
+    const estimatedTokens = estimateTokens(prompt);
+    if (estimatedTokens > effectiveBudget) {
+        hardFailed = true;
+        return {
+            prompt: '',
+            metadata: {
+                budget,
+                effectiveBudget,
+                estimatedTokens,
+                omitted,
+                projectMdShrunk,
+                planTruncationPct,
+                hardFailed,
+                noteInjected,
+            },
+        };
+    }
+    return {
+        prompt,
+        metadata: {
+            budget,
+            effectiveBudget,
+            estimatedTokens,
+            omitted,
+            projectMdShrunk,
+            planTruncationPct,
+            hardFailed,
+            noteInjected,
+        },
+    };
+}

package/gsd-core/bin/lib/review-reviewer-selection.cjs

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Review Reviewer Selection Module (ADR-457 build-at-publish: the hand-written
+ * bin/lib/review-reviewer-selection.cjs collapsed to a TypeScript source of
+ * truth). Behaviour is preserved byte-for-behaviour from the prior hand-written
+ * .cjs; only types are added.
+ *
+ * Owns reviewer-selection policy projection for /gsd:review:
+ * explicit flags > --all > review.default_reviewers > all detected.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_REVIEWER_SLUGS = void 0;
+exports.normalizeConfiguredDefaultReviewers = normalizeConfiguredDefaultReviewers;
+exports.resolveReviewerSelection = resolveReviewerSelection;
+exports.KNOWN_REVIEWER_SLUGS = [
+    'gemini',
+    'claude',
+    'codex',
+    'coderabbit',
+    'opencode',
+    'qwen',
+    'cursor',
+    'antigravity',
+    'ollama',
+    'lm_studio',
+    'llama_cpp',
+];
+function normalizeConfiguredDefaultReviewers(rawValue) {
+    if (rawValue === undefined || rawValue === null) {
+        return { absent: true, values: [], errors: [] };
+    }
+    if (!Array.isArray(rawValue)) {
+        return {
+            absent: false,
+            values: [],
+            errors: ['review.default_reviewers must be a JSON array of reviewer slugs'],
+        };
+    }
+    if (rawValue.length === 0) {
+        return {
+            absent: false,
+            values: [],
+            errors: ['review.default_reviewers cannot be empty'],
+        };
+    }
+    const seen = new Set();
+    const normalized = [];
+    const errors = [];
+    for (const item of rawValue) {
+        if (typeof item !== 'string') {
+            errors.push('review.default_reviewers must contain only string slugs');
+            continue;
+        }
+        if (!/^[a-zA-Z0-9_-]+$/.test(item)) {
+            errors.push(`invalid reviewer slug in review.default_reviewers: ${item}`);
+            continue;
+        }
+        const slug = item.toLowerCase();
+        if (!seen.has(slug)) {
+            seen.add(slug);
+            normalized.push(slug);
+        }
+    }
+    return { absent: false, values: normalized, errors };
+}
+function resolveReviewerSelection(input) {
+    const detected = new Set((input.detected ?? []).map((v) => String(v).toLowerCase()));
+    const explicitFlags = new Set((input.explicitFlags ?? []).map((v) => String(v).toLowerCase()));
+    const allFlag = !!input.allFlag;
+    const normalizedDefaults = normalizeConfiguredDefaultReviewers(input.configuredDefaultReviewers);
+    const warnings = [];
+    const infos = [];
+    const errors = [...normalizedDefaults.errors];
+    let source = 'no_config_all_detected';
+    let selected = [];
+    if (explicitFlags.size > 0) {
+        source = 'explicit_flags';
+        selected = [...explicitFlags].filter((slug) => detected.has(slug));
+        const missing = [...explicitFlags].filter((slug) => !detected.has(slug));
+        if (missing.length > 0) {
+            infos.push(`explicit reviewers missing on host: ${missing.join(', ')}`);
+        }
+        if (selected.length === 0 && errors.length === 0) {
+            errors.push('no selected reviewers are available for explicit flags');
+        }
+    }
+    else if (allFlag) {
+        source = 'all_flag';
+        selected = [...detected];
+    }
+    else if (!normalizedDefaults.absent) {
+        source = 'config_default';
+        const knownDefaults = [];
+        for (const slug of normalizedDefaults.values) {
+            if (!exports.KNOWN_REVIEWER_SLUGS.includes(slug)) {
+                warnings.push(`unknown reviewer slug in review.default_reviewers: ${slug}`);
+            }
+            else {
+                knownDefaults.push(slug);
+            }
+        }
+        const undetected = knownDefaults.filter((slug) => !detected.has(slug));
+        if (undetected.length > 0) {
+            infos.push(`configured reviewers not detected on this host: ${undetected.join(', ')}`);
+        }
+        selected = knownDefaults.filter((slug) => detected.has(slug));
+        if (selected.length === 0 && errors.length === 0) {
+            errors.push('all configured default reviewers are unavailable on this host');
+        }
+    }
+    else {
+        selected = [...detected];
+    }
+    return {
+        source,
+        selected: selected.sort(),
+        warnings,
+        infos,
+        errors,
+    };
+}

package/gsd-core/bin/lib/roadmap-command-router.cjs

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Manifest-backed roadmap subcommand router.
+ * Keeps gsd-tools.cjs thin while preserving existing command semantics.
+ *
+ * ADR-457 build-at-publish: the hand-written bin/lib/roadmap-command-router.cjs
+ * collapsed to a TypeScript source of truth. Behaviour is preserved byte-for-behaviour
+ * from the prior hand-written .cjs; only types are added.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const command_aliases_cjs_1 = require("./command-aliases.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const cjsCommandRouterAdapter = require("./cjs-command-router-adapter.cjs");
+const { routeCjsCommandFamily } = cjsCommandRouterAdapter;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const roadmapUpgrade = require("./roadmap-upgrade.cjs");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const planningWorkspace = require("./planning-workspace.cjs");
+const { planningDir } = planningWorkspace;
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const core = require("./core.cjs");
+const { loadConfig } = core;
+// ─── W021 Implementation ──────────────────────────────────────────────────────
+/**
+ * Check each phase entry in a milestone-prefixed ROADMAP.md for W021 violations.
+ *
+ * W021: a phase whose ID integer prefix does not match its enclosing milestone's
+ * major version number.
+ *
+ * Sentinel milestones (0 = pre-milestone, 999 = backlog) are exempt.
+ *
+ * @param content - ROADMAP.md content
+ * @returns Array of W021 warnings
+ */
+function checkW021(content) {
+    const warnings = [];
+    // Sentinel milestone integers exempt from W021
+    const SENTINELS = new Set([0, 999]);
+    const MIGRATION_CMD = 'gsd-tools roadmap upgrade --convention milestone-prefixed';
+    // Milestone section heading: ## [GSD] v2.0 — Label  OR  ## v2.0: Label  OR  ## Roadmap v2.0
+    //   OR  ## ✅ v2.0  OR  ## 🚧 v2.0  (emoji-prefixed variants used by roadmap templates)
+    // Capture the major integer.
+    const MILESTONE_RE = /^#{1,3}\s+(?:\[[^\]]+\]\s+|Roadmap\s+|[✅🚧]\s*)?v(\d+)\.\d+(?:\s|:|\s*—)/iu;
+    // Migrated phase heading: ### Phase M-NN: Name  (M-NN or unpadded M-N form)
+    const PHASE_RE = /^#{2,4}\s*(?:\[[^\]]+\]\s*)?Phase\s+(\d+)-(\d+)(?:-\d+)*\s*:/i;
+    // Unprefixed legacy phase heading: ### Phase N: Name  (no hyphen sub-index)
+    const UNPREFIXED_PHASE_RE = /^#{2,4}\s*(?:\[[^\]]+\]\s*)?Phase\s+(\d+[A-Za-z]?(?:\.\d+)*)\s*:/i;
+    let currentMilestoneMajor = null;
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const milestoneMatch = line.match(MILESTONE_RE);
+        if (milestoneMatch) {
+            currentMilestoneMajor = parseInt(milestoneMatch[1], 10);
+            continue;
+        }
+        const phaseMatch = line.match(PHASE_RE);
+        if (phaseMatch) {
+            const phaseMajor = parseInt(phaseMatch[1], 10);
+            if (SENTINELS.has(phaseMajor))
+                continue; // exempt
+            if (currentMilestoneMajor !== null && phaseMajor !== currentMilestoneMajor) {
+                const phaseId = `${phaseMatch[1]}-${phaseMatch[2]}`;
+                warnings.push({
+                    code: 'W021',
+                    message: `Phase ID prefix mismatch: phase "${phaseId}" is listed under v${currentMilestoneMajor}.x ` +
+                        `but its prefix (${phaseMajor}) does not match. ` +
+                        `Run \`${MIGRATION_CMD}\` to fix.`,
+                });
+            }
+            continue;
+        }
+        // When the convention is active, an unprefixed heading (### Phase 1:) is itself a W021
+        // violation — it is missing the required M-NN prefix entirely.
+        const unprefixedMatch = line.match(UNPREFIXED_PHASE_RE);
+        if (unprefixedMatch && currentMilestoneMajor !== null) {
+            const rawId = unprefixedMatch[1];
+            // Skip if it matched PHASE_RE already (it didn't reach here in that case)
+            // Also skip if it looks like a bare integer whose prefix matches the section
+            // — those pass; only non-matching or non-prefixed forms fire W021.
+            const numericMajor = parseInt(rawId, 10);
+            if (!SENTINELS.has(numericMajor)) {
+                warnings.push({
+                    code: 'W021',
+                    message: `Phase ID "${rawId}" is not in M-NN form (milestone-prefixed convention is active). ` +
+                        `Run \`${MIGRATION_CMD}\` to migrate.`,
+                });
+            }
+        }
+    }
+    return warnings;
+}
+// ─── Router ───────────────────────────────────────────────────────────────────
+function routeRoadmapCommand({ roadmap, args, cwd, raw, error }) {
+    routeCjsCommandFamily({
+        args,
+        subcommands: command_aliases_cjs_1.ROADMAP_SUBCOMMANDS,
+        unsupported: {},
+        error,
+        unknownMessage: (_subcommand, available) => `Unknown roadmap subcommand. Available: ${available.join(', ')}`,
+        handlers: {
+            'get-phase': () => roadmap.cmdRoadmapGetPhase(cwd, args[2], raw),
+            analyze: () => roadmap.cmdRoadmapAnalyze(cwd, raw),
+            'update-plan-progress': () => roadmap.cmdRoadmapUpdatePlanProgress(cwd, args[2], raw),
+            'annotate-dependencies': () => roadmap.cmdRoadmapAnnotateDependencies(cwd, args[2], raw),
+            'validate': () => {
+                const roadmapPath = node_path_1.default.join(planningDir(cwd), 'ROADMAP.md');
+                let roadmapContent = '';
+                try {
+                    roadmapContent = node_fs_1.default.readFileSync(roadmapPath, 'utf8');
+                }
+                catch {
+                    // ROADMAP.md missing — return empty warnings
+                }
+                // W021 only fires when phase_id_convention is explicitly 'milestone-prefixed'.
+                // Authoritative source: .planning/config.json (set by the upgrade command).
+                // Fallback: ROADMAP.md frontmatter (for projects that set the field there directly).
+                let convention;
+                try {
+                    const cfg = loadConfig(cwd);
+                    convention = cfg['phase_id_convention'];
+                }
+                catch {
+                    convention = undefined;
+                }
+                if (convention === undefined || convention === null) {
+                    // Fallback: read from ROADMAP.md frontmatter
+                    const fmMatch = roadmapContent.match(/^---\r?\n([\s\S]+?)\r?\n---/);
+                    if (fmMatch) {
+                        const kvMatch = fmMatch[1].match(/^phase_id_convention:\s*(.*)$/m);
+                        if (kvMatch) {
+                            const val = kvMatch[1].trim();
+                            if (val !== 'null' && val !== '') {
+                                convention = val.replace(/^["']|["']$/g, '');
+                            }
+                        }
+                    }
+                }
+                const warnings = (convention === 'milestone-prefixed')
+                    ? checkW021(roadmapContent)
+                    : [];
+                const result = { warnings };
+                if (raw)
+                    process.stdout.write(JSON.stringify(result));
+                else
+                    process.stdout.write(JSON.stringify(result, null, 2));
+            },
+            'upgrade': () => {
+                const dryRun = !args.includes('--apply');
+                const convention = args.find((_a, i) => args[i - 1] === '--convention') || 'milestone-prefixed';
+                if (convention !== 'milestone-prefixed') {
+                    process.stderr.write('Only --convention milestone-prefixed is supported\n');
+                    process.exit(1);
+                }
+                const plan = roadmapUpgrade.computeMigrationPlan(cwd);
+                roadmapUpgrade.applyMigration(cwd, plan, { dryRun });
+            },
+        },
+    });
+}
+module.exports = {
+    routeRoadmapCommand,
+};