@pugi/cli 0.1.0-beta.4 → 0.1.0-beta.40

package/dist/core/release-notes/parser.js

@@ -0,0 +1,241 @@
+/**
+ * Keep-a-Changelog parser — Leak L24 (2026-05-27).
+ *
+ * Parses a `CHANGELOG.md` written в the Keep-a-Changelog v1.1 layout
+ * (https://keepachangelog.com) into an ordered list of version
+ * sections. The parser is intentionally minimal — it understands the
+ * `## [<version>] - <date>` header marker and the section body up к
+ * the next header, and ignores every other Markdown construct (links,
+ * footnotes, sub-sub-headers). That is enough к drive the
+ * `pugi release-notes` diff between last-seen and current.
+ *
+ * # Module contract
+ *
+ *   - Pure function. Takes the raw CHANGELOG text + returns parsed
+ *     sections. Zero IO; the file read happens at the call site so the
+ *     spec can pin fixtures without touching disk.
+ *
+ *   - Header grammar: `## [<version>] - <YYYY-MM-DD>`. The leading
+ *     `## ` is required (h2). The version is everything between the
+ *     square brackets — semver-shaped strings are not validated
+ *     beyond non-emptiness so pre-release tags like `0.1.0-beta.21`
+ *     parse correctly. The date is captured verbatim; the comparator
+ *     does not parse it — version ordering is enough.
+ *
+ *   - Section body: every line from the header (exclusive) up к the
+ *     next `## [...] - ...` header (exclusive). Lines are joined
+ *     verbatim with `\n`; leading + trailing blank lines are trimmed
+ *     so the renderer can paste sections back-to-back without double
+ *     blank lines piling up.
+ *
+ *   - Pre-header content (the leading `# Changelog` + introduction
+ *     blurb) is discarded. The parser only surfaces version sections;
+ *     callers that want к render the introduction read the source
+ *     file directly.
+ *
+ *   - Sections appear в the order they are written in the file. The
+ *     Keep-a-Changelog convention is newest-first; the parser does
+ *     NOT re-sort. The slicing helpers (`sliceVersionsBetween`) trust
+ *     the input order so a malformed CHANGELOG with shuffled
+ *     versions produces a deterministic — if surprising — diff
+ *     instead of silently swallowing entries.
+ *
+ *   - Semver comparison (`compareSemver`) handles the canonical
+ *     `MAJOR.MINOR.PATCH[-PRERELEASE]` shape. The pre-release tail
+ *     is compared lexicographically by dot-separated identifier per
+ *     semver §11. Unknown / malformed input compares lower than any
+ *     valid semver so an accidental `unknown` last-seen marker
+ *     never blocks the operator from seeing new notes.
+ */
+const SECTION_HEADER_RE = /^##\s+\[([^\]]+)\](?:\s*-\s*(.+))?\s*$/u;
+/**
+ * Parse the raw `CHANGELOG.md` text into ordered version sections.
+ *
+ * Returns sections in the same order they appear in the source. The
+ * Keep-a-Changelog convention is newest-first; the parser does not
+ * re-sort.
+ */
+export function parseChangelog(raw) {
+    const lines = raw.split(/\r?\n/u);
+    const sections = [];
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        sections.push({
+            version: current.version,
+            date: current.date,
+            body: trimBlankEdges(current.lines).join('\n'),
+        });
+        current = null;
+    };
+    for (const line of lines) {
+        const match = SECTION_HEADER_RE.exec(line);
+        if (match) {
+            flush();
+            const version = (match[1] ?? '').trim();
+            const date = (match[2] ?? '').trim();
+            if (version.length === 0) {
+                // Malformed `## []` header — skip entirely instead of
+                // emitting a zero-version row that would corrupt the diff.
+                continue;
+            }
+            current = { version, date, lines: [] };
+            continue;
+        }
+        if (current) {
+            current.lines.push(line);
+        }
+    }
+    flush();
+    return sections;
+}
+/**
+ * Slice the section list к those strictly newer than `lastSeen` and
+ * up к (and including) `current`. Both bounds are matched on the
+ * verbatim version string — the comparator runs on every section к
+ * decide membership.
+ *
+ * Semantics:
+ *
+ *   - If `lastSeen` is null OR empty OR matches no section, every
+ *     section ≤ current is returned. This is the first-run path —
+ *     the operator has never run the command before, so the entire
+ *     bundled changelog is fair game.
+ *
+ *   - If `lastSeen` equals `current`, the empty array is returned.
+ *     The caller renders the "no new release notes" copy.
+ *
+ *   - If `lastSeen` is newer than `current`, the empty array is
+ *     returned. This is the dev-build path — operators running a
+ *     local build of `0.1.0-beta.30` against a registry that
+ *     publishes `0.1.0-beta.22` would otherwise see the stale
+ *     bundled notes; the caller still surfaces the same no-op copy.
+ *
+ *   - Otherwise: sections strictly newer than `lastSeen` and ≤
+ *     `current`, in the source order (newest-first by convention).
+ *
+ * The function is pure — no IO, no clock — so the spec can pin every
+ * branch with hand-rolled fixtures.
+ */
+export function sliceVersionsBetween(sections, lastSeen, current) {
+    if (sections.length === 0)
+        return [];
+    // Treat а blank / sentinel last-seen as "never seen".
+    const lastSeenValue = typeof lastSeen === 'string' && lastSeen.trim().length > 0 && lastSeen !== 'none'
+        ? lastSeen.trim()
+        : null;
+    // Dev-build path: operator's last-seen marker is strictly newer than
+    // the installed CLI version. This happens when running а local build
+    // older than the registry, or when the operator manually edited the
+    // marker. Either way, return the empty array — re-rendering the
+    // bundled notes would be misleading. The renderer surfaces the same
+    // "no new release notes" copy as the up-to-date branch.
+    if (lastSeenValue !== null && compareSemver(lastSeenValue, current) > 0) {
+        return [];
+    }
+    // Diff path: surface sections strictly newer than the marker and ≤
+    // current. The comparator drives every section — а marker that does
+    // not appear in the bundled changelog (operator on а stale build,
+    // hand-edited marker, version no longer published) still bisects
+    // correctly because every comparison runs against the marker value
+    // directly, not the matching-section guard.
+    const out = [];
+    for (const section of sections) {
+        // Anything newer than current is а future entry that should not
+        // surface until the operator actually upgrades — guards against а
+        // dev build of CHANGELOG.md leaking unreleased notes к а customer
+        // install.
+        if (compareSemver(section.version, current) > 0)
+            continue;
+        if (lastSeenValue !== null && compareSemver(section.version, lastSeenValue) <= 0) {
+            continue;
+        }
+        out.push(section);
+    }
+    return out;
+}
+/**
+ * Semver comparator. Returns a negative number when `a < b`, zero
+ * when equal, and a positive number when `a > b`. Pre-release tags
+ * compare lexicographically by dot-separated identifier per semver §11.
+ *
+ * Unknown / malformed input compares lower than any valid semver so
+ * an accidental sentinel like `unknown` or `none` never accidentally
+ * blocks the diff from surfacing newer entries.
+ */
+export function compareSemver(a, b) {
+    const left = parseSemver(a);
+    const right = parseSemver(b);
+    if (!left && !right)
+        return 0;
+    if (!left)
+        return -1;
+    if (!right)
+        return 1;
+    for (let i = 0; i < 3; i += 1) {
+        const cmp = (left.core[i] ?? 0) - (right.core[i] ?? 0);
+        if (cmp !== 0)
+            return cmp;
+    }
+    // A version without a pre-release tag is newer than the same core
+    // with a pre-release tag (per semver §11: 1.0.0 > 1.0.0-rc).
+    if (left.pre.length === 0 && right.pre.length === 0)
+        return 0;
+    if (left.pre.length === 0)
+        return 1;
+    if (right.pre.length === 0)
+        return -1;
+    const len = Math.max(left.pre.length, right.pre.length);
+    for (let i = 0; i < len; i += 1) {
+        const li = left.pre[i];
+        const ri = right.pre[i];
+        if (li === undefined)
+            return -1;
+        if (ri === undefined)
+            return 1;
+        const ln = Number.parseInt(li, 10);
+        const rn = Number.parseInt(ri, 10);
+        const liNumeric = Number.isFinite(ln) && String(ln) === li;
+        const riNumeric = Number.isFinite(rn) && String(rn) === ri;
+        if (liNumeric && riNumeric) {
+            if (ln !== rn)
+                return ln - rn;
+            continue;
+        }
+        if (liNumeric)
+            return -1; // numeric < alphanumeric per §11
+        if (riNumeric)
+            return 1;
+        if (li < ri)
+            return -1;
+        if (li > ri)
+            return 1;
+    }
+    return 0;
+}
+function parseSemver(raw) {
+    if (typeof raw !== 'string')
+        return null;
+    const trimmed = raw.trim();
+    if (trimmed.length === 0)
+        return null;
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/u.exec(trimmed);
+    if (!match)
+        return null;
+    const major = Number.parseInt(match[1] ?? '0', 10);
+    const minor = Number.parseInt(match[2] ?? '0', 10);
+    const patch = Number.parseInt(match[3] ?? '0', 10);
+    const pre = match[4] ? match[4].split('.') : [];
+    return { core: [major, minor, patch], pre };
+}
+function trimBlankEdges(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && (lines[start] ?? '').trim().length === 0)
+        start += 1;
+    while (end > start && (lines[end - 1] ?? '').trim().length === 0)
+        end -= 1;
+    return lines.slice(start, end);
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/release-notes/state.js

@@ -0,0 +1,116 @@
+/**
+ * `~/.pugi/.last-seen-version` state I/O — Leak L24 (2026-05-27).
+ *
+ * The `pugi release-notes` command renders the diff between the
+ * version the operator last saw notes for and the currently
+ * installed CLI version. This module owns the on-disk marker that
+ * tracks the last-seen value.
+ *
+ * # Module contract
+ *
+ *   - File path: `<home>/.pugi/.last-seen-version`. The leading dot
+ *     keeps it out of casual `ls` output; the file is plain ASCII
+ *     (one line, the version string) so operators can edit it by
+ *     hand when reproducing scenarios. Missing parent dir is
+ *     created on write.
+ *
+ *   - Reads: missing file → null. Unreadable / blank file → null.
+ *     The caller treats null as "operator has never run the command"
+ *     and surfaces every bundled section. Read failures NEVER throw —
+ *     the command surface is informational and must keep working on
+ *     a read-only mount or a misconfigured permission bit.
+ *
+ *   - Writes: best-effort. EACCES / EROFS / ENOSPC log а warning к
+ *     the caller-supplied logger and return the failure code so the
+ *     command renderer can footer the output with "could not persist
+ *     last-seen — re-run will show the same notes". The command
+ *     itself stays exit 0 because the value of the render did not
+ *     depend on the write succeeding.
+ *
+ *   - The helpers are pure I/O wrappers — no clock, no random, no
+ *     env reads. Callers pass `home` explicitly so the spec can
+ *     pin a tmp dir without monkey-patching `os.homedir`.
+ */
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+/** Filename inside `<home>/.pugi/` that holds the last-seen marker. */
+export const LAST_SEEN_VERSION_FILE = '.last-seen-version';
+/**
+ * Resolve the absolute path of the last-seen marker file inside the
+ * passed home directory. Pure helper — no IO.
+ */
+export function lastSeenVersionPath(home) {
+    return resolve(home, '.pugi', LAST_SEEN_VERSION_FILE);
+}
+/**
+ * Read the last-seen marker. Returns null when the file is missing,
+ * unreadable, or empty. Never throws.
+ */
+export function readLastSeenVersion(home) {
+    const path = lastSeenVersionPath(home);
+    try {
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, 'utf8').trim();
+        if (raw.length === 0)
+            return null;
+        return raw;
+    }
+    catch {
+        // Read-only mount, permission denied, race with another process
+        // unlinking the file — every read failure degrades к null so the
+        // command treats the operator as a first-time viewer instead of
+        // dropping out of the slash dispatcher with an unhandled error.
+        return null;
+    }
+}
+/**
+ * Persist the last-seen marker. Creates `<home>/.pugi/` if it does
+ * not exist. Returns a structured envelope describing success or the
+ * failure reason so the renderer can footer а warning when the write
+ * could not be made durable.
+ */
+export function writeLastSeenVersion(home, version) {
+    const path = lastSeenVersionPath(home);
+    try {
+        const dir = resolve(home, '.pugi');
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+        // Trailing newline so `cat ~/.pugi/.last-seen-version` reads
+        // nicely in shells that do not auto-append one for the prompt.
+        writeFileSync(path, `${version}\n`, { encoding: 'utf8', mode: 0o600 });
+        return { status: 'ok', path };
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            path,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Clear the last-seen marker — used by `pugi release-notes --reset`
+ * so the operator can force the full bundled changelog к re-render.
+ * Returns `absent` when the marker did not exist, `cleared` on
+ * success, `failed` on permission errors.
+ */
+export function clearLastSeenVersion(home) {
+    const path = lastSeenVersionPath(home);
+    try {
+        if (!existsSync(path)) {
+            return { status: 'absent', path };
+        }
+        unlinkSync(path);
+        return { status: 'cleared', path };
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            path,
+            reason: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+//# sourceMappingURL=state.js.map

package/dist/core/repl/history.js

@@ -31,6 +31,7 @@
  * keys stay readable English (`brief`, `ts`). No forbidden words.
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync, unlinkSync, } from 'node:fs';
+import { randomBytes } from 'node:crypto';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 /** Cap on stored entries per workspace. Drops oldest on overflow. */
@@ -77,7 +78,16 @@ export function append(input) {
     // sibling guarantees that). P2 fix from PR #335 triple-review.
     if (existing.length + 1 > MAX_HISTORY_ENTRIES) {
         const trimmed = [...existing.slice(existing.length + 1 - MAX_HISTORY_ENTRIES), entry];
-        const tmpPath = `${path}.tmp`;
+        // β1b #52 (2026-05-26): unique-per-call tmp suffix.
+        // Previous form was a fixed `${path}.tmp`, which means two CLI
+        // processes hitting the overflow rewrite at the same moment race
+        // on the same sibling file. Whichever writeFileSync lands second
+        // can corrupt the renameSync target's content (one process's
+        // serialized buffer overwrites the other mid-flight). Append a
+        // pid + monotonic-ish timestamp + 8 hex random bytes so the tmp
+        // names are collision-proof across PIDs, concurrent calls inside
+        // one PID, and rapid re-runs that share the same ms timestamp.
+        const tmpPath = `${path}.${process.pid}.${Date.now()}.${randomBytes(4).toString('hex')}.tmp`;
         try {
             writeFileSync(tmpPath, trimmed.map(serialize).join('\n') + '\n', { mode: 0o600 });
             renameSync(tmpPath, path);

package/dist/core/repl/model-pricing.js

@@ -0,0 +1,135 @@
+/**
+ * Static price ladder keyed by exact model slug.
+ *
+ * Source: provider list-price pages as of 2026-05-26. Keep prefix lookup
+ * (`priceForModel`) for forward compat — a `claude-opus-4-8` from a future
+ * model-router rebind falls back onto the `claude-opus-` family entry.
+ */
+const PRICE_LADDER = new Map([
+    // Anthropic Claude family
+    ['claude-opus-4-7', { inputUsdPerM: 15.0, outputUsdPerM: 75.0 }],
+    ['claude-opus-4-6', { inputUsdPerM: 15.0, outputUsdPerM: 75.0 }],
+    ['claude-sonnet-4-6', { inputUsdPerM: 3.0, outputUsdPerM: 15.0 }],
+    ['claude-sonnet-4-5', { inputUsdPerM: 3.0, outputUsdPerM: 15.0 }],
+    ['claude-haiku-4-5', { inputUsdPerM: 0.8, outputUsdPerM: 4.0 }],
+    // OpenAI family — sentinel entries so a `pugi config set` override lands clean.
+    ['gpt-4o', { inputUsdPerM: 2.5, outputUsdPerM: 10.0 }],
+    ['gpt-4o-mini', { inputUsdPerM: 0.15, outputUsdPerM: 0.6 }],
+    ['o3', { inputUsdPerM: 10.0, outputUsdPerM: 40.0 }],
+    ['o3-mini', { inputUsdPerM: 1.1, outputUsdPerM: 4.4 }],
+    // Mistral
+    ['mistral-large', { inputUsdPerM: 2.0, outputUsdPerM: 6.0 }],
+    ['mistral-small', { inputUsdPerM: 0.2, outputUsdPerM: 0.6 }],
+    // Embeddings — input-only; output is zero so the meter shows a
+    // flat per-call cost without inflating the "output" column.
+    ['voyage-3', { inputUsdPerM: 0.12, outputUsdPerM: 0 }],
+    ['voyage-3-large', { inputUsdPerM: 0.18, outputUsdPerM: 0 }],
+]);
+/**
+ * Family-prefix fallback. Used when an unknown slug starts with a
+ * known family stem (e.g. `claude-sonnet-4-7`).
+ */
+const FAMILY_PREFIX = [
+    ['claude-opus-', { inputUsdPerM: 15.0, outputUsdPerM: 75.0 }],
+    ['claude-sonnet-', { inputUsdPerM: 3.0, outputUsdPerM: 15.0 }],
+    ['claude-haiku-', { inputUsdPerM: 0.8, outputUsdPerM: 4.0 }],
+    ['gpt-4o', { inputUsdPerM: 2.5, outputUsdPerM: 10.0 }],
+    ['o3', { inputUsdPerM: 10.0, outputUsdPerM: 40.0 }],
+    ['mistral-', { inputUsdPerM: 2.0, outputUsdPerM: 6.0 }],
+    ['voyage-', { inputUsdPerM: 0.12, outputUsdPerM: 0 }],
+];
+/**
+ * Default ladder when no model slug is known (e.g. the older admin-api
+ * still on the pre-α7 event shape that does not carry `model`). Pinned
+ * to Sonnet-tier so the meter is "honestly conservative" — close to the
+ * default dispatch lane for `reason` + `codegen` tags.
+ */
+const DEFAULT_PRICE = { inputUsdPerM: 3.0, outputUsdPerM: 15.0 };
+/**
+ * Look up the price for a model slug. Resolution order:
+ *   1. Exact match in `PRICE_LADDER`.
+ *   2. Family-prefix match (`startsWith`).
+ *   3. Default Sonnet-tier rate.
+ *
+ * Pure — never throws. The cost meter calls this on every `agent.tokens`
+ * frame so it must stay branch-cheap.
+ */
+export function priceForModel(model) {
+    if (!model || typeof model !== 'string')
+        return DEFAULT_PRICE;
+    const exact = PRICE_LADDER.get(model);
+    if (exact)
+        return exact;
+    for (const [prefix, price] of FAMILY_PREFIX) {
+        if (model.startsWith(prefix))
+            return price;
+    }
+    return DEFAULT_PRICE;
+}
+/**
+ * Compute the USD cost for a single (input, output, model) triple.
+ * Returns a finite number, never NaN/Infinity, capped at zero floor so
+ * a buggy upstream that emits negative deltas (theoretically impossible
+ * via Anvil but we stay defensive) does not credit the operator's meter.
+ *
+ * Pure, deterministic, branch-cheap — called on every `agent.tokens`
+ * event so the hot path keeps the math inline.
+ */
+export function computeCostUsd(tokensIn, tokensOut, model) {
+    const price = priceForModel(model);
+    const safeIn = Number.isFinite(tokensIn) && tokensIn > 0 ? tokensIn : 0;
+    const safeOut = Number.isFinite(tokensOut) && tokensOut > 0 ? tokensOut : 0;
+    const usd = (safeIn * price.inputUsdPerM + safeOut * price.outputUsdPerM) / 1_000_000;
+    return Number.isFinite(usd) && usd > 0 ? usd : 0;
+}
+/**
+ * Format a token count for the status row. Spec (CEO 2026-05-26):
+ *   - `<1000` → raw integer (e.g. `42`)
+ *   - `≥1000` → one-decimal `k` (e.g. `1.2k`)
+ *   - `≥1_000_000` → one-decimal `m` (e.g. `1.0m`)
+ *
+ * Negative / NaN inputs render as `0`.
+ */
+export function formatTokens(value) {
+    if (!Number.isFinite(value) || value <= 0)
+        return '0';
+    if (value < 1_000)
+        return Math.floor(value).toString();
+    if (value < 1_000_000)
+        return `${(value / 1_000).toFixed(1)}k`;
+    return `${(value / 1_000_000).toFixed(1)}m`;
+}
+/**
+ * Format USD cost for the status row. Spec (CEO 2026-05-26):
+ *   - `≥ $0.01` → `$X.XX` (two decimals)
+ *   - `<  $0.01` (but > 0) → `$X.XXX` (three decimals, shows fractions
+ *     of a cent honestly instead of rounding to `$0.00`)
+ *   - `0` / NaN → `$0.00`
+ */
+export function formatCostUsd(usd) {
+    if (!Number.isFinite(usd) || usd <= 0)
+        return '$0.00';
+    if (usd >= 0.01)
+        return `$${usd.toFixed(2)}`;
+    return `$${usd.toFixed(3)}`;
+}
+/**
+ * Format an elapsed-ms duration as `1m2s` / `45s` / `2h3m`. Used by the
+ * status row's session-duration slot. Floors aggressively — we don't
+ * want sub-second decimals stealing column width.
+ */
+export function formatDuration(elapsedMs) {
+    if (!Number.isFinite(elapsedMs) || elapsedMs <= 0)
+        return '0s';
+    const totalSec = Math.floor(elapsedMs / 1000);
+    if (totalSec < 60)
+        return `${totalSec}s`;
+    const min = Math.floor(totalSec / 60);
+    const sec = totalSec % 60;
+    if (min < 60)
+        return `${min}m${sec.toString().padStart(2, '0')}s`;
+    const hr = Math.floor(min / 60);
+    const restMin = min % 60;
+    return `${hr}h${restMin.toString().padStart(2, '0')}m`;
+}
+//# sourceMappingURL=model-pricing.js.map