@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/runtime/commands/plan.js

@@ -0,0 +1,143 @@
+/**
+ * `pugi plan` / `/plan` — Leak L7 quick mode-switch shortcut.
+ *
+ * `/plan` is the slick UX shortcut for `/permissions plan`: one keystroke
+ * (well, five) puts the gate into plan mode + surfaces a banner so the
+ * operator knows write/dispatch tools are refused. The model goes off and
+ * thinks / researches without side effects until the operator types
+ * `/plan --back` (restore previous mode) or explicitly flips with
+ * `/permissions <mode>`.
+ *
+ * The slash and CLI surfaces both go through `runPlanCommand` — same
+ * separation as `runPermissionsCommand`. The runtime is I/O free w.r.t.
+ * the engine; the optional one-shot dispatch (`/plan <prompt>`) is
+ * handled by the CLI dispatcher AFTER this helper sets the workspace
+ * mode so the existing `runEngineTask('plan')` path sees plan mode as
+ * the workspace state without needing a parallel code path.
+ *
+ * Verdicts (the helper returns one so the caller can decide what to do
+ * after the mode write — print the banner, dispatch the engine, no-op):
+ *   - `entered`        — first `/plan` from a non-plan mode. Print the
+ *                        banner. Caller may then run a one-shot prompt.
+ *   - `already-in-plan` — `/plan` while already in plan. No-op + show
+ *                        current. No banner reprint.
+ *   - `reverted`        — `/plan --back` popped the snapshot. Print a
+ *                        one-line confirmation; no banner.
+ *   - `no-previous`     — `/plan --back` without a snapshot. Print a
+ *                        clear "nothing to revert" line.
+ *   - `persisted`       — `/plan --persist` wrote the global default
+ *                        AND set workspace state to plan. Banner +
+ *                        persistence-confirmation line.
+ *
+ * `previousMode` semantics: stashed BEFORE the workspace write on
+ * `entered` / `persisted`. Cleared after a successful `reverted` so a
+ * second `--back` reports `no-previous` instead of looping back to plan.
+ */
+import { PERMISSION_MODES, PERMISSION_MODE_GLOSS, getCurrentMode, getGlobalDefaultMode, getPreviousMode, setCurrentMode, setGlobalDefaultMode, setPreviousMode, } from '../../core/permissions/index.js';
+/**
+ * Run the `/plan` flow. Side effects:
+ *
+ *   command.back = true:
+ *     - If a previousMode snapshot exists → restore it, clear snapshot,
+ *       return `reverted`.
+ *     - Otherwise → no writes, return `no-previous`.
+ *
+ *   command.back = false, current mode is plan:
+ *     - If `--persist`, write global config (no workspace re-write — it
+ *       is already plan).
+ *     - Print "already in plan" + the banner-summary line. Return
+ *       `already-in-plan`.
+ *
+ *   command.back = false, current mode is NOT plan:
+ *     - Snapshot current mode → previousPermissionMode.
+ *     - Write workspace mode = plan.
+ *     - If `--persist`, also write global config.
+ *     - Print the banner + (if persisted) the persistence line.
+ *     - Return `entered` or `persisted`.
+ *
+ * --back + --persist is a no-op for persistence (revert never writes
+ * global config) but the revert itself fires.
+ */
+export async function runPlanCommand(command, ctx) {
+    const current = effectiveMode(ctx);
+    if (command.back) {
+        const prev = getPreviousMode(ctx.workspaceRoot);
+        if (!prev) {
+            ctx.writeOutput(`No previous mode to restore. Current: ${current}. Use \`/permissions <mode>\` to switch explicitly.`);
+            return { verdict: 'no-previous', mode: current };
+        }
+        setCurrentMode(ctx.workspaceRoot, prev);
+        setPreviousMode(ctx.workspaceRoot, null);
+        ctx.writeOutput(`Switched back to '${prev}' mode. ${PERMISSION_MODE_GLOSS[prev]}`);
+        return { verdict: 'reverted', mode: prev };
+    }
+    if (current === 'plan') {
+        // Repeat /plan in plan mode is a no-op for the mode write, but
+        // --persist still honours the operator's intent to lock plan as
+        // the global default for future sessions.
+        if (command.persist) {
+            setGlobalDefaultMode('plan', ctx.homeDir);
+            ctx.writeOutput('Already in plan mode. Persisted plan as the default for future sessions (~/.pugi/config.json).');
+            return { verdict: 'persisted', mode: 'plan' };
+        }
+        ctx.writeOutput(`Already in plan mode. ${PERMISSION_MODE_GLOSS.plan} Switch back with \`/plan --back\` or \`/permissions <mode>\`.`);
+        return { verdict: 'already-in-plan', mode: 'plan' };
+    }
+    // Entering plan mode from a non-plan baseline. Stash the current mode
+    // BEFORE the write so /plan --back can pop it. We intentionally use the
+    // observed effective mode (workspace || global || default) rather than
+    // strictly the workspace value — if the operator's previous mode was
+    // sourced from the global config, `--back` should restore that observed
+    // state, not silently degrade to default.
+    setPreviousMode(ctx.workspaceRoot, current);
+    setCurrentMode(ctx.workspaceRoot, 'plan');
+    if (command.persist) {
+        setGlobalDefaultMode('plan', ctx.homeDir);
+    }
+    for (const line of renderPlanBanner()) {
+        ctx.writeOutput(line);
+    }
+    if (command.persist) {
+        ctx.writeOutput('Persisted plan as the default for future sessions (~/.pugi/config.json).');
+        return { verdict: 'persisted', mode: 'plan' };
+    }
+    return { verdict: 'entered', mode: 'plan' };
+}
+/**
+ * Render the plan-mode banner as a sequence of lines. The slash + CLI
+ * surfaces both print these line-by-line through their respective
+ * `writeOutput` sinks so the Ink REPL conversation pane and the plain
+ * stdout pipeline render identically.
+ *
+ * The box-drawing uses light-line glyphs (U+2500 family) which render in
+ * every modern terminal we target (Linux/macOS/Windows Terminal/iTerm/
+ * Ghostty/Alacritty). No emoji per brand-voice gate.
+ */
+export function renderPlanBanner() {
+    return [
+        '┌─ Plan mode active ────────────────────────────────────────┐',
+        '│ Read-only tools allowed. Write/dispatch tools blocked.    │',
+        '│ Pugi will think + research without making changes.        │',
+        '│ Switch back: /plan --back  or  /permissions <mode>        │',
+        '└───────────────────────────────────────────────────────────┘',
+    ];
+}
+/**
+ * Resolve the effective mode at the moment the helper was invoked,
+ * mirroring `resolveMode` but without taking a CLI flag (the `/plan`
+ * helper is called AFTER the top-level `--mode` flag has been applied
+ * to the workspace, so the file state is the source of truth here).
+ */
+function effectiveMode(ctx) {
+    const workspace = getCurrentMode(ctx.workspaceRoot);
+    if (workspace)
+        return workspace;
+    const global = getGlobalDefaultMode(ctx.homeDir);
+    if (global)
+        return global;
+    // Defensive: PERMISSION_MODES[1] is 'ask' (the canonical default). We
+    // index off the canonical list rather than re-import DEFAULT_PERMISSION_MODE
+    // here to keep the symbol surface narrow.
+    return PERMISSION_MODES[1] ?? 'ask';
+}
+//# sourceMappingURL=plan.js.map

package/dist/runtime/commands/prd-check.js

@@ -0,0 +1,235 @@
+/**
+ * `pugi prd-check` — Pugi α7 Wave 6 verified-deliverable gate (2026-05-27).
+ *
+ * Runs a PRD ↔ delivered-artifact verification sweep BEFORE the
+ * operator (or an autonomous agent) claims a feature is done.
+ * Reads `docs/prd/<feature>.md` (or any explicit path), parses the
+ * acceptance-criteria section, and runs file / test / doc / command
+ * / route verifiers per criterion. Output mirrors `pugi doctor`:
+ * either a plain-text table or a JSON envelope (`--json`).
+ *
+ * Module contract (mirrors L17 doctor split):
+ *
+ *   - parser + verifiers + reporter are pure with respect to deps;
+ *     this file is the THIN wiring that resolves cwd, glob-expands
+ *     `--all`, loads each PRD, and forwards the structured result
+ *     к the supplied writeOutput sink.
+ *
+ *   - `runPrdCheckCommand` is the single entry point. Both the
+ *     top-level `pugi prd-check` shell command AND the in-REPL
+ *     `/prd-check` slash command call it. The function returns the
+ *     `PrdCheckEnvelope[]` so the REPL can render via Ink without
+ *     re-running the verification.
+ *
+ *   - Exit codes follow `exitCodeFor` from the reporter:
+ *       0 — healthy (every criterion PASS or SKIPPED)
+ *       1 — failing (≥1 FAIL across the scanned PRDs)
+ *       2 — unparsed (≥1 PRD missing the acceptance section)
+ *     When `--all` scans multiple PRDs the worst verdict wins (1 > 2 > 0).
+ *
+ *   - The `knownCommands` set is sourced from the CLI registry — we
+ *     accept it as an injected parameter so the spec can drive
+ *     command-verification without importing the entire cli.ts
+ *     module (which would pull the engine graph into the test).
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { parsePrd } from '../../core/prd-check/parser.js';
+import { buildEnvelope, exitCodeFor, renderTable, } from '../../core/prd-check/reporter.js';
+import { createDefaultDeps, verifyAll, } from '../../core/prd-check/verifiers.js';
+const DEFAULT_PRD_DIR = 'docs/prd';
+/**
+ * Run the gate. Resolves which PRDs to inspect, runs the parser +
+ * verifiers + reporter chain per PRD, emits the combined output,
+ * and sets `process.exitCode` to the worst verdict across the set.
+ */
+export async function runPrdCheckCommand(ctx) {
+    const paths = resolveTargets(ctx);
+    if (paths.length === 0) {
+        const result = {
+            command: 'prd-check',
+            overall: 'unparsed',
+            envelopes: [],
+        };
+        ctx.writeOutput(result, 'No PRD files found.');
+        process.exitCode = exitCodeFor('unparsed');
+        return result;
+    }
+    const deps = ctx.deps ??
+        createDefaultDeps({
+            workspaceRoot: ctx.cwd,
+            knownCommands: ctx.knownCommands,
+        });
+    const envelopes = [];
+    for (const path of paths) {
+        envelopes.push(checkSinglePrd(path, ctx.cwd, deps));
+    }
+    const overall = combineOverall(envelopes.map((e) => e.overall));
+    const result = {
+        command: 'prd-check',
+        overall,
+        envelopes,
+    };
+    const text = renderRun(result, ctx.cwd);
+    ctx.writeOutput(result, text);
+    process.exitCode = exitCodeFor(overall);
+    return result;
+}
+/**
+ * Render the combined plain-text view. Multi-PRD runs print one
+ * table per envelope separated by a divider; single-PRD runs print
+ * just the table to keep the output narrow.
+ */
+function renderRun(result, cwd) {
+    if (result.envelopes.length === 0) {
+        return 'No PRD files found.';
+    }
+    if (result.envelopes.length === 1) {
+        return renderTable(result.envelopes[0]);
+    }
+    const parts = [];
+    for (const envelope of result.envelopes) {
+        const relPath = relative(cwd, envelope.prdPath) || envelope.prdPath;
+        parts.push(renderTable({ ...envelope, prdPath: relPath }));
+        parts.push('');
+    }
+    parts.push('-'.repeat(50));
+    const summary = `${result.envelopes.length} PRD(s) scanned. Overall: ${result.overall.toUpperCase()}`;
+    parts.push(summary);
+    return parts.join('\n');
+}
+function checkSinglePrd(prdPath, workspaceRoot, deps) {
+    let source;
+    try {
+        source = readFileSync(prdPath, 'utf8');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            command: 'prd-check',
+            prdPath: relative(workspaceRoot, prdPath) || prdPath,
+            title: null,
+            overall: 'unparsed',
+            counts: { pass: 0, fail: 0, skipped: 0 },
+            criteria: [
+                {
+                    index: 0,
+                    text: `PRD file unreadable: ${message}`,
+                    status: 'fail',
+                    results: [],
+                },
+            ],
+        };
+    }
+    const parsed = parsePrd(source);
+    const verified = verifyAll(parsed.criteria, deps);
+    return buildEnvelope({
+        prdPath: relative(workspaceRoot, prdPath) || prdPath,
+        title: parsed.title,
+        hasAcceptanceSection: parsed.hasAcceptanceSection,
+        verified,
+    });
+}
+function resolveTargets(ctx) {
+    if (ctx.flags.all) {
+        const prdDir = resolve(ctx.cwd, DEFAULT_PRD_DIR);
+        return listMarkdownFiles(prdDir);
+    }
+    if (ctx.prdPath) {
+        const absolute = isAbsolute(ctx.prdPath)
+            ? ctx.prdPath
+            : resolve(ctx.cwd, ctx.prdPath);
+        return [absolute];
+    }
+    return [];
+}
+function listMarkdownFiles(dir) {
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const entry of entries) {
+        const full = join(dir, entry);
+        let isDirectory = false;
+        try {
+            isDirectory = statSync(full).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDirectory) {
+            out.push(...listMarkdownFiles(full));
+            continue;
+        }
+        if (entry.endsWith('.md')) {
+            out.push(full);
+        }
+    }
+    return out.sort();
+}
+/**
+ * Combine per-PRD verdicts into the run-wide one. failing > unparsed > healthy.
+ * Exported for the spec.
+ */
+export function combineOverall(verdicts) {
+    if (verdicts.length === 0)
+        return 'unparsed';
+    if (verdicts.some((v) => v === 'failing'))
+        return 'failing';
+    if (verdicts.some((v) => v === 'unparsed'))
+        return 'unparsed';
+    return 'healthy';
+}
+/**
+ * Parse the CLI argv tail. Accepts:
+ *
+ *   pugi prd-check                       -> error (no target)
+ *   pugi prd-check <path>                -> single PRD
+ *   pugi prd-check --all                 -> scan docs/prd/**.md
+ *   pugi prd-check <path> --json         -> single PRD, JSON envelope
+ *
+ * `--json` is also forwarded from the global flag set in cli.ts;
+ * the local parse re-honours it so the slash command can use the
+ * same parser without the global flag plumbing.
+ */
+export function parsePrdCheckArgs(args, options) {
+    let json = options.jsonDefault;
+    let all = false;
+    let prdPath;
+    for (const arg of args) {
+        if (arg === '--json') {
+            json = true;
+            continue;
+        }
+        if (arg === '--all') {
+            all = true;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            return { ok: false, error: `unknown flag: ${arg}` };
+        }
+        if (prdPath !== undefined) {
+            return { ok: false, error: `unexpected extra argument: ${arg}` };
+        }
+        prdPath = arg;
+    }
+    if (!all && prdPath === undefined) {
+        return {
+            ok: false,
+            error: 'pugi prd-check <prd-path> | --all   (pass a PRD path or --all to scan docs/prd/**.md)',
+        };
+    }
+    if (all && prdPath !== undefined) {
+        return { ok: false, error: 'cannot combine <path> with --all' };
+    }
+    return {
+        ok: true,
+        flags: { json, all },
+        ...(prdPath !== undefined ? { prdPath } : {}),
+    };
+}
+//# sourceMappingURL=prd-check.js.map

package/dist/runtime/commands/release-notes.js

@@ -0,0 +1,229 @@
+/**
+ * `pugi release-notes` — changelog diff between last-seen + current
+ * (Leak L24, 2026-05-27).
+ *
+ * Parity command with Claude Code's `/release-notes`, which shows
+ * what changed between the previously-installed CLI version and the
+ * currently-installed one. The Pugi variant reads the bundled
+ * `CHANGELOG.md`, slices it к the range `(last-seen, current]`, and
+ * renders the Markdown sections to the operator. After а successful
+ * render the marker is bumped к `current` so the next invocation is а
+ * no-op until the operator upgrades again.
+ *
+ * # Module contract
+ *
+ *   - This file owns the WIRING from CLI flags + ambient state к the
+ *     parser + state I/O helpers. The parser + state modules в
+ *     `core/release-notes/` have zero coupling к the CLI dispatch
+ *     surface.
+ *
+ *   - `runReleaseNotesCommand` is the single entry point. Both the
+ *     top-level `pugi release-notes` handler в `runtime/cli.ts` AND
+ *     the in-REPL `/release-notes` slash command call it. The
+ *     function returns а structured `ReleaseNotesResult` so the
+ *     slash dispatcher can route the lines к the system pane
+ *     without re-reading the changelog.
+ *
+ *   - Exit code is ALWAYS 0. The command is informational, never а
+ *     gate. Read failures, missing CHANGELOG, and write failures all
+ *     degrade к а structured envelope with а human-readable footer.
+ *
+ *   - The changelog source is captured behind а function so the spec
+ *     can stub it without touching disk. The default reads the file
+ *     bundled with the CLI install (resolved relative к the package
+ *     root); fixtures pass an in-memory string.
+ *
+ *   - `--reset` flag clears the last-seen marker AND re-renders the
+ *     full bundled changelog as if the operator had never run the
+ *     command. Distinct from а plain `--all` toggle because the
+ *     reset PERSISTS (the next invocation again shows everything
+ *     newer than the cleared marker — `none`).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseChangelog, sliceVersionsBetween, } from '../../core/release-notes/parser.js';
+import { clearLastSeenVersion, readLastSeenVersion, writeLastSeenVersion, } from '../../core/release-notes/state.js';
+import { PUGI_CLI_VERSION } from '../version.js';
+/**
+ * Default loader для the bundled `apps/pugi-cli/CHANGELOG.md`. The
+ * compiled bundle ships under `dist/runtime/commands/release-notes.js`;
+ * the CHANGELOG sits next к `package.json` at the package root, two
+ * directories up from `dist/runtime/commands/`. We also probe а
+ * couple of fallback locations so the dev path (running the source
+ * directly из `src/`) works без а compile step.
+ */
+export function defaultReadChangelog() {
+    const candidates = resolveChangelogCandidates();
+    for (const candidate of candidates) {
+        try {
+            if (existsSync(candidate)) {
+                return readFileSync(candidate, 'utf8');
+            }
+        }
+        catch {
+            // Permission errors, transient FS hiccups — keep probing the
+            // remaining candidates. Returning null at the end is fine; the
+            // renderer surfaces а "changelog-missing" envelope.
+        }
+    }
+    return null;
+}
+function resolveChangelogCandidates() {
+    // import.meta.url points к the compiled JS in production
+    // (`dist/runtime/commands/release-notes.js`) and к the source TS в
+    // tests / dev runs. We probe both relative ancestries so either
+    // path lands on `<package>/CHANGELOG.md`.
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        return [
+            resolve(here, '../../..', 'CHANGELOG.md'),
+            resolve(here, '../../../..', 'CHANGELOG.md'),
+            resolve(process.cwd(), 'apps/pugi-cli/CHANGELOG.md'),
+            resolve(process.cwd(), 'CHANGELOG.md'),
+        ];
+    }
+    catch {
+        // Some non-ESM contexts (very old node, eval'd code) reject
+        // `import.meta.url`. Fall back к cwd-relative probes — works for
+        // tests that run from the package root.
+        return [
+            resolve(process.cwd(), 'apps/pugi-cli/CHANGELOG.md'),
+            resolve(process.cwd(), 'CHANGELOG.md'),
+        ];
+    }
+}
+/**
+ * Default home dir resolver. Centralised so the CLI handler can call
+ * `runReleaseNotesCommand` without re-importing `os.homedir`.
+ */
+export function defaultReleaseNotesHome() {
+    return homedir();
+}
+/**
+ * Pick + render the release notes, hand the result к the output
+ * sink, persist the marker. Always exits 0.
+ */
+export function runReleaseNotesCommand(ctx) {
+    const readChangelog = ctx.readChangelog ?? defaultReadChangelog;
+    const currentVersion = ctx.currentVersion ?? PUGI_CLI_VERSION;
+    // `--reset` clears the marker before slicing. We capture the
+    // pre-clear value so the JSON envelope still shows the operator
+    // what their previous marker was, which makes scripting + bug
+    // reports easier.
+    const lastSeenBefore = readLastSeenVersion(ctx.home);
+    if (ctx.reset) {
+        clearLastSeenVersion(ctx.home);
+    }
+    const lastSeen = ctx.reset ? null : lastSeenBefore;
+    const raw = readChangelog();
+    if (raw === null) {
+        const result = {
+            command: 'release-notes',
+            currentVersion,
+            lastSeenVersion: lastSeenBefore ?? 'none',
+            sections: [],
+            status: 'changelog-missing',
+            markerPersisted: false,
+            persistFailure: null,
+            text: renderMissingChangelog(currentVersion),
+        };
+        ctx.writeOutput(result, result.text);
+        process.exitCode = 0;
+        return result;
+    }
+    const sections = parseChangelog(raw);
+    if (sections.length === 0) {
+        const result = {
+            command: 'release-notes',
+            currentVersion,
+            lastSeenVersion: lastSeenBefore ?? 'none',
+            sections: [],
+            status: 'changelog-empty',
+            markerPersisted: false,
+            persistFailure: null,
+            text: renderEmptyChangelog(currentVersion),
+        };
+        ctx.writeOutput(result, result.text);
+        process.exitCode = 0;
+        return result;
+    }
+    const slice = sliceVersionsBetween(sections, lastSeen, currentVersion);
+    if (slice.length === 0) {
+        // Nothing new — render the no-op message and DO NOT touch the
+        // marker (marker already equals current OR is newer; either way
+        // re-writing it is а no-op write we can avoid).
+        const result = {
+            command: 'release-notes',
+            currentVersion,
+            lastSeenVersion: lastSeenBefore ?? 'none',
+            sections: [],
+            status: 'up-to-date',
+            markerPersisted: false,
+            persistFailure: null,
+            text: renderUpToDate(currentVersion, lastSeenBefore),
+        };
+        ctx.writeOutput(result, result.text);
+        process.exitCode = 0;
+        return result;
+    }
+    const persist = writeLastSeenVersion(ctx.home, currentVersion);
+    const text = renderSections(slice, currentVersion, lastSeen, persist);
+    const result = {
+        command: 'release-notes',
+        currentVersion,
+        lastSeenVersion: lastSeenBefore ?? 'none',
+        sections: slice,
+        status: ctx.reset ? 'reset' : 'rendered',
+        markerPersisted: persist.status === 'ok',
+        persistFailure: persist.status === 'failed' ? persist.reason : null,
+        text,
+    };
+    ctx.writeOutput(result, text);
+    process.exitCode = 0;
+    return result;
+}
+function renderSections(sections, current, lastSeen, persist) {
+    const header = lastSeen
+        ? `Pugi release notes — ${lastSeen} → ${current}`
+        : `Pugi release notes — up to ${current}`;
+    const blocks = [header, '═'.repeat(Math.max(header.length, 30))];
+    for (const section of sections) {
+        const subhead = section.date
+            ? `## [${section.version}] - ${section.date}`
+            : `## [${section.version}]`;
+        blocks.push('');
+        blocks.push(subhead);
+        if (section.body.length > 0) {
+            blocks.push('');
+            blocks.push(section.body);
+        }
+    }
+    if (persist.status === 'failed') {
+        blocks.push('');
+        blocks.push(`Warning: could not persist last-seen marker (${persist.reason}). Next run will surface the same notes.`);
+    }
+    return blocks.join('\n');
+}
+function renderUpToDate(current, lastSeen) {
+    const lines = ['No new release notes.'];
+    lines.push(`Installed: ${current}`);
+    lines.push(`Last seen: ${lastSeen ?? 'none'}`);
+    return lines.join('\n');
+}
+function renderMissingChangelog(current) {
+    return [
+        'Release notes are not bundled with this install.',
+        `Installed: ${current}`,
+        'See https://pugi.io/changelog for the rendered changelog.',
+    ].join('\n');
+}
+function renderEmptyChangelog(current) {
+    return [
+        'Bundled changelog is empty — no parsed sections.',
+        `Installed: ${current}`,
+        'See https://pugi.io/changelog for the rendered changelog.',
+    ].join('\n');
+}
+//# sourceMappingURL=release-notes.js.map