@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.10

package/dist/commands/jobs-watch.js

@@ -1,201 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-/**
- * `pugi jobs --watch` Ink TUI — live progress .
- *
- * Tails `~/.pugi/agent-progress/*.json` via chokidar and re-renders a
- * grid of <AgentProgressCard> components. Mirrors the the upstream tool
- * `/compact` layout pattern — one card per agent, sorted by status
- * (running → completed → failed) then by lastUpdate descending so the
- * freshest activity floats к the top.
- *
- * Lifecycle:
- *  1. Resolve dir via resolveProgressDir() (env-aware).
- *  2. Initial scan with readdirSync — populate the map.
- *  3. chokidar.watch(dir, { ignoreInitial: true }) for add/change/unlink.
- *  4. setInterval(1000) tick re-renders to keep elapsed labels live
- *     WITHOUT re-reading files.
- *  5. SIGINT (Ctrl+C) triggers `app.unmount()` + process.exit(0).
- *
- * Layout: single column under 100 cols, two columns at 100+ cols
- * (Ink's flexbox computes the responsive split automatically — we just
- * set `flexDirection="row" flexWrap="wrap"` and bound each card к 50%
- * width when stdout is wide enough).
- *
- * The TUI is opt-in (operator runs `pugi jobs --watch`); the bare
- * `pugi jobs` continues to print the legacy job-registry table.
- */
-import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { join } from 'node:path';
-import chokidar from 'chokidar';
-import { useEffect, useMemo, useState } from 'react';
-import { Box, Text, render, useApp, useInput, useStdout } from 'ink';
-import { resolveProgressDir } from '../core/agent-progress/writer.js';
-import { runCleanup } from '../core/agent-progress/cleanup.js';
-import { validateAgentProgress, } from '../core/agent-progress/schema.js';
-import { AgentProgressCard } from '../tui/agent-progress-card.js';
-/** Cleanup pass cadence inside the watcher. Cheap (readdir on a small
- * dir); 60s is the operator-tested sweet spot — fast enough to feel
- * live, slow enough к never burn CPU. */
-const CLEANUP_INTERVAL_MS = 60_000;
-const STATUS_RANK = {
-    running: 0,
-    completed: 1,
-    failed: 2,
-};
-/**
- * Read + validate one progress file. Returns undefined on any failure
- * — the watcher prefers к skip a malformed entry rather than crash.
- * Exported for the spec.
- */
-export function readProgressFile(path) {
-    if (!existsSync(path))
-        return undefined;
-    try {
-        const body = readFileSync(path, 'utf8');
-        const parsed = JSON.parse(body);
-        const result = validateAgentProgress(parsed);
-        return result.ok ? result.value : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Sort progress entries for stable, operator-friendly display:
- *  1. Running first.
- *  2. Then by lastUpdate (most recent first).
- *  3. Tiebreak on agentId for snapshot stability.
- */
-export function sortProgressEntries(entries) {
-    return [...entries].sort((a, b) => {
-        const rank = STATUS_RANK[a.status] - STATUS_RANK[b.status];
-        if (rank !== 0)
-            return rank;
-        const tsDiff = Date.parse(b.lastUpdate) - Date.parse(a.lastUpdate);
-        if (tsDiff !== 0)
-            return tsDiff;
-        return a.agentId.localeCompare(b.agentId);
-    });
-}
-export function JobsWatch(props) {
-    const { dir, nowEpochMs, staticMode = false } = props;
-    const resolvedDir = useMemo(() => resolveProgressDir(dir), [dir]);
-    const [agents, setAgents] = useState(() => initialScan(resolvedDir));
-    const [tick, setTick] = useState(0);
-    const { exit } = useApp();
-    const { stdout } = useStdout();
-    const cols = stdout?.columns ?? 80;
-    const twoColumns = cols >= 100;
-    useInput((_input, key) => {
-        if (key.escape || key.ctrl) {
-            // Ink's useInput passes ctrl=true for Ctrl+<x>; we exit on Ctrl+C
-            // (key.ctrl alone is too broad — actual key char arrives in `input`).
-            // Practically, raw mode passes Ctrl+C as SIGINT to the process so
-            // this is a belt-and-suspenders catch.
-            if (key.escape)
-                exit();
-        }
-    });
-    useEffect(() => {
-        if (staticMode)
-            return;
-        let watcher;
-        try {
-            watcher = chokidar.watch(resolvedDir, {
-                ignoreInitial: true,
-                depth: 0,
-                // The agent writer uses atomic rename — chokidar reports `add`
-                // when the final filename appears, never the *.tmp-* intermediate.
-                ignored: /\.tmp-/,
-            });
-            const onChange = (path) => {
-                if (!/\.json$/.test(path))
-                    return;
-                const progress = readProgressFile(path);
-                if (!progress)
-                    return;
-                setAgents((prev) => ({ ...prev, [progress.agentId]: progress }));
-            };
-            const onRemove = (path) => {
-                const match = /([^/\\]+)\.json$/.exec(path);
-                if (!match)
-                    return;
-                const id = match[1];
-                if (!id)
-                    return;
-                setAgents((prev) => {
-                    if (!(id in prev))
-                        return prev;
-                    const next = { ...prev };
-                    delete next[id];
-                    return next;
-                });
-            };
-            watcher.on('add', onChange);
-            watcher.on('change', onChange);
-            watcher.on('unlink', onRemove);
-        }
-        catch {
-            // Watcher failures degrade gracefully — initial scan still rendered.
-        }
-        const interval = setInterval(() => setTick((t) => t + 1), 1000);
-        // Auto-cleanup completed/failed entries older than the TTL. The
-        // sweep moves them к `<dir>/archive/` so operators can still
-        // forensic; the watcher's chokidar `unlink` handler drops them
-        // from the live grid as the rename fires.
-        const cleanupInterval = setInterval(() => {
-            try {
-                runCleanup({ dir: resolvedDir });
-            }
-            catch {
-                // best-effort housekeeping; never crash the TUI
-            }
-        }, CLEANUP_INTERVAL_MS);
-        return () => {
-            clearInterval(interval);
-            clearInterval(cleanupInterval);
-            if (watcher) {
-                void watcher.close();
-            }
-        };
-    }, [resolvedDir, staticMode]);
-    const sorted = useMemo(() => sortProgressEntries(Object.values(agents)), [agents]);
-    const effectiveNow = nowEpochMs ?? Date.now() + tick * 0; // tick triggers re-render only
-    if (sorted.length === 0) {
-        return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Text, { dimColor: true, children: ["No agents broadcasting progress yet. Watching", ' ', _jsx(Text, { bold: true, children: resolvedDir }), " for `<id>.json` files\u2026"] }), _jsx(Text, { dimColor: true, children: "(Press Esc / Ctrl+C \u043A exit.)" })] }));
-    }
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { marginBottom: 1, children: [_jsx(Text, { bold: true, children: "pugi jobs --watch" }), _jsxs(Text, { dimColor: true, children: [' ', "\u00B7 ", sorted.length, " ", sorted.length === 1 ? 'agent' : 'agents', " \u00B7", ' ', resolvedDir] })] }), _jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: sorted.map((progress) => (_jsx(Box, { width: twoColumns ? '50%' : '100%', flexDirection: "column", children: _jsx(AgentProgressCard, { progress: progress, nowEpochMs: effectiveNow }) }, progress.agentId))) }), _jsx(Text, { dimColor: true, children: "(Esc / Ctrl+C \u043A exit.)" })] }));
-}
-function initialScan(dir) {
-    const map = {};
-    if (!existsSync(dir))
-        return map;
-    let entries;
-    try {
-        entries = readdirSync(dir);
-    }
-    catch {
-        return map;
-    }
-    for (const name of entries) {
-        if (!name.endsWith('.json'))
-            continue;
-        if (/\.tmp-/.test(name))
-            continue;
-        const progress = readProgressFile(join(dir, name));
-        if (progress)
-            map[progress.agentId] = progress;
-    }
-    return map;
-}
-/**
- * Entry-point for `pugi jobs --watch`. Mounts the Ink app and returns
- * a Promise that resolves when the user exits (Ctrl+C / Esc).
- */
-export async function runJobsWatch(options = {}) {
-    return new Promise((resolve) => {
-        const app = render(_jsx(JobsWatch, { dir: options.dir }), { exitOnCtrlC: true });
-        void app.waitUntilExit().then(() => resolve(0));
-    });
-}
-//# sourceMappingURL=jobs-watch.js.map

package/dist/commands/jobs.js

@@ -1,260 +0,0 @@
-/**
- * `pugi jobs` command surface — Sprint .
- *
- * Subcommands:
- *  pugi jobs list                — table of all tracked jobs (or JSON envelope)
- *  pugi jobs status <id>         — full record + tail of overflow artifact
- *  pugi jobs tail <id>           — stream the overflow artifact
- *  pugi jobs kill <id>           — SIGTERM then SIGKILL after a grace
- *  pugi jobs kill --all          — kill every running job in this session
- *
- * Power-word voice rules (per Pugi brand guide):
- *  - status names render as "on watch" (running), "shipped" (finished),
- *    "stood down" (killed), "blocked" (failed), "lost" (abandoned).
- *  - JSON envelopes keep the machine-friendly enum so consumers do
- *    not have to map back.
- */
-import { existsSync, readFileSync } from 'node:fs';
-import { formatDuration, getJobRegistry, relativeAge, } from '../core/jobs/registry.js';
-import { runJobsWatch } from './jobs-watch.js';
-const HUMAN_STATUS = {
-    running: 'on watch',
-    finished: 'shipped',
-    killed: 'stood down',
-    failed: 'blocked',
-    abandoned: 'lost',
-};
-export async function runJobsCommand(args, flags, io, sessionId) {
-    // live progress : `pugi jobs --watch` mounts the live
-    // agent-progress TUI. The flag may sit anywhere in the arg list
-    // (`pugi jobs --watch` or `pugi jobs watch`) — both forms route к
-    // the watcher. JSON mode is incompatible (it would never return); we
-    // bail with a helpful error instead of silently swallowing the flag.
-    const wantsWatch = args.includes('--watch') || args[0] === 'watch';
-    if (wantsWatch) {
-        if (flags.json) {
-            io.writeError('pugi jobs --watch is interactive; --json is not supported.');
-            return 2;
-        }
-        return runJobsWatch();
-    }
-    const sub = args[0] ?? 'list';
-    switch (sub) {
-        case 'list':
-            return runList(flags, io);
-        case 'status':
-            return runStatus(args[1], flags, io);
-        case 'tail':
-            return runTail(args[1], flags, io);
-        case 'kill':
-            return runKill(args.slice(1), flags, io, sessionId);
-        default:
-            io.writeError(`Unknown subcommand: ${sub}`);
-            io.writeError(usage());
-            return 2;
-    }
-}
-function usage() {
-    return [
-        'Usage:',
-        ' pugi jobs list [--json]                 Table of background jobs.',
-        ' pugi jobs status <id> [--json]          Full record + tail of artifact.',
-        ' pugi jobs tail <id>                     Stream the captured artifact.',
-        ' pugi jobs kill <id> [--json]            SIGTERM, escalate to SIGKILL.',
-        ' pugi jobs kill --all [--json]           Stand down every running job.',
-        ' pugi jobs --watch                       Live Ink TUI of agent progress.',
-    ].join('\n');
-}
-async function runList(flags, io) {
-    const registry = getJobRegistry();
-    const entries = await registry.list();
-    if (flags.json) {
-        io.write(`${JSON.stringify({
-            command: 'jobs.list',
-            count: entries.length,
-            jobs: entries.map(serializeForJson),
-        }, null, 2)}\n`);
-        return 0;
-    }
-    io.write(`${renderTable(entries)}\n`);
-    return 0;
-}
-async function runStatus(id, flags, io) {
-    if (!id) {
-        io.writeError('pugi jobs status requires a job id');
-        return 2;
-    }
-    const registry = getJobRegistry();
-    const entry = await registry.get(id);
-    if (!entry) {
-        if (flags.json) {
-            io.write(`${JSON.stringify({ command: 'jobs.status', error: 'not_found', id }, null, 2)}\n`);
-        }
-        else {
-            io.writeError(`Job not found: ${id}`);
-        }
-        return 1;
-    }
-    const tail = entry.outputArtifactRef ? readArtifactTail(entry.outputArtifactRef, 4_096) : '';
-    if (flags.json) {
-        io.write(`${JSON.stringify({
-            command: 'jobs.status',
-            job: serializeForJson(entry),
-            tail,
-        }, null, 2)}\n`);
-        return 0;
-    }
-    const lines = [
-        `Job ${entry.id}`,
-        ` PID:       ${entry.pid}`,
-        ` Command:   ${entry.command}`,
-        ` Class:     ${entry.bashClass}`,
-        ` Status:    ${HUMAN_STATUS[entry.status]} (${entry.status})`,
-        ` CWD:       ${entry.cwd}`,
-        ` Started:   ${entry.startedAt} (${relativeAge(entry.startedAt)} ago)`,
-        ` Duration:  ${formatDuration(entry.startedAt, entry.finishedAt)}`,
-    ];
-    if (entry.finishedAt)
-        lines.push(` Finished:  ${entry.finishedAt}`);
-    if (entry.exitCode !== undefined)
-        lines.push(` Exit code: ${entry.exitCode}`);
-    if (entry.outputArtifactRef)
-        lines.push(` Artifact:  ${entry.outputArtifactRef}`);
-    if (tail) {
-        lines.push('', '--- output tail ---', tail);
-    }
-    io.write(`${lines.join('\n')}\n`);
-    return 0;
-}
-async function runTail(id, _flags, io) {
-    if (!id) {
-        io.writeError('pugi jobs tail requires a job id');
-        return 2;
-    }
-    const registry = getJobRegistry();
-    const entry = await registry.get(id);
-    if (!entry) {
-        io.writeError(`Job not found: ${id}`);
-        return 1;
-    }
-    if (!entry.outputArtifactRef) {
-        io.writeError(`Job ${id} has no captured output artifact yet (background jobs spawn with stdio=ignore by default).`);
-        return 1;
-    }
-    if (!existsSync(entry.outputArtifactRef)) {
-        io.writeError(`Artifact missing on disk: ${entry.outputArtifactRef}`);
-        return 1;
-    }
-    const body = readFileSync(entry.outputArtifactRef, 'utf8');
-    io.write(body.endsWith('\n') ? body : `${body}\n`);
-    return 0;
-}
-async function runKill(args, flags, io, sessionId) {
-    const registry = getJobRegistry();
-    const killAll = flags.all || args.includes('--all');
-    if (killAll) {
-        const entries = await registry.list();
-        const targets = entries.filter((entry) => {
-            if (entry.status !== 'running')
-                return false;
-            if (sessionId && entry.sessionId !== sessionId)
-                return false;
-            return true;
-        });
-        const results = [];
-        for (const target of targets) {
-            const result = await registry.kill(target.id);
-            results.push({ id: target.id, ...result });
-        }
-        if (flags.json) {
-            io.write(`${JSON.stringify({ command: 'jobs.kill', scope: 'all', results }, null, 2)}\n`);
-        }
-        else if (results.length === 0) {
-            io.write('No running jobs to stand down.\n');
-        }
-        else {
-            for (const result of results) {
-                io.write(` ${result.id} ${result.killed ? 'stood down' : 'noop'} (${result.method})\n`);
-            }
-        }
-        return 0;
-    }
-    const id = args[0];
-    if (!id) {
-        io.writeError('pugi jobs kill requires a job id (or --all)');
-        return 2;
-    }
-    const result = await registry.kill(id);
-    if (flags.json) {
-        io.write(`${JSON.stringify({ command: 'jobs.kill', id, ...result }, null, 2)}\n`);
-        return result.killed || result.method === 'noop' ? 0 : 1;
-    }
-    if (result.killed) {
-        io.write(`Job ${id} stood down (${result.method}).\n`);
-        return 0;
-    }
-    io.writeError(`Job ${id} was not running or could not be signalled.`);
-    return 1;
-}
-function serializeForJson(entry) {
-    const ageSeconds = Math.max(0, Math.floor((Date.now() - Date.parse(entry.startedAt)) / 1000));
-    let durationSeconds;
-    if (entry.finishedAt) {
-        const start = Date.parse(entry.startedAt);
-        const end = Date.parse(entry.finishedAt);
-        if (!Number.isNaN(start) && !Number.isNaN(end) && end >= start) {
-            durationSeconds = Math.floor((end - start) / 1000);
-        }
-    }
-    return {
-        ...entry,
-        humanStatus: HUMAN_STATUS[entry.status],
-        ageSeconds,
-        durationSeconds,
-    };
-}
-function readArtifactTail(path, byteBudget) {
-    if (!existsSync(path))
-        return '';
-    try {
-        const body = readFileSync(path, 'utf8');
-        if (body.length <= byteBudget)
-            return body;
-        return `(...truncated; tail ${byteBudget} bytes of ${body.length})\n${body.slice(-byteBudget)}`;
-    }
-    catch {
-        return '';
-    }
-}
-function renderTable(entries) {
-    if (entries.length === 0) {
-        return 'No background jobs tracked. Spawn one via the bash tool (background: true) and it lands here.';
-    }
-    const header = ['ID', 'COMMAND', 'CLASS', 'STATUS', 'STARTED', 'DURATION'];
-    const rows = [header];
-    for (const entry of entries) {
-        rows.push([
-            entry.id.replace(/^pj-/, '').slice(0, 8),
-            truncate(entry.command, 24),
-            entry.bashClass,
-            HUMAN_STATUS[entry.status],
-            `${relativeAge(entry.startedAt)} ago`,
-            formatDuration(entry.startedAt, entry.finishedAt),
-        ]);
-    }
-    const widths = header.map((_, i) => Math.max(...rows.map((row) => (row[i] ?? '').length)));
-    // Reserve a little headroom so the right-hand columns do not bleed
-    // past 80 chars when the command column hits its 24-char ceiling.
-    return rows
-        .map((row) => row
-        .map((cell, i) => cell.padEnd(widths[i] ?? cell.length))
-        .join(' ')
-        .trimEnd())
-        .join('\n');
-}
-function truncate(value, max) {
-    if (value.length <= max)
-        return value;
-    return `${value.slice(0, max - 1)}…`;
-}
-//# sourceMappingURL=jobs.js.map

package/dist/commands/retro.js

@@ -1,210 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text, render } from 'ink';
-import { collectGitContext, countCommitsAheadOfBase, } from '../core/retro/git-collector.js';
-import { ensurePugiGitIgnore } from '../core/pugi-gitignore.js';
-import { computeMetrics } from '../core/retro/metrics.js';
-import { persistRetro } from '../core/retro/narrative.js';
-import { collectPlaneSlice, postRetroToPlane, resolvePlaneConfig, } from '../core/retro/plane-collector.js';
-import { enrichLinks } from '../core/retro/pr-issue-link.js';
-import { computeHealthCard } from '../core/retro/health-card.js';
-/** Parse `7d` | `14d` | `30d` | `24h` into a duration in days
- * (fractional for sub-day windows). Defaults to 7 days when omitted.
- */
-function parseDurationToken(token) {
-    if (!token)
-        return undefined;
-    const match = /^(\d+)(h|d)$/.exec(token);
-    if (!match)
-        return undefined;
-    const value = Number.parseInt(match[1] ?? '0', 10);
-    const unit = match[2];
-    if (!Number.isFinite(value) || value <= 0)
-        return undefined;
-    const days = unit === 'h' ? value / 24 : value;
-    return { days, label: token };
-}
-function buildWindow(durationDays, label, now) {
-    const until = now;
-    const sinceMs = until.getTime() - durationDays * 24 * 60 * 60 * 1000;
-    const since = new Date(sinceMs);
-    // Midnight-align the lower bound to keep `--since` deterministic per day.
-    since.setHours(0, 0, 0, 0);
-    return { since, until, label, days: Math.max(1, Math.round(durationDays)) };
-}
-function buildPriorWindow(current) {
-    const until = new Date(current.since.getTime());
-    const sinceMs = until.getTime() - current.days * 24 * 60 * 60 * 1000;
-    const since = new Date(sinceMs);
-    since.setHours(0, 0, 0, 0);
-    return { since, until, label: `prior ${current.label}`, days: current.days };
-}
-function parseRetroArgs(rawArgs, now) {
-    const args = [...rawArgs];
-    const postPlane = args.includes('--post-plane');
-    const enrichPlane = args.includes('--plane') || postPlane;
-    const positional = args.filter((a) => !a.startsWith('-'));
-    let compare = false;
-    let durationToken;
-    if (positional[0] === 'compare') {
-        compare = true;
-        durationToken = positional[1];
-    }
-    else {
-        durationToken = positional[0];
-    }
-    const parsed = parseDurationToken(durationToken) ?? { days: 7, label: '7d' };
-    return {
-        window: buildWindow(parsed.days, parsed.label, now),
-        compare,
-        enrichPlane,
-        postPlane,
-    };
-}
-function SummaryCard(props) {
-    const { persisted, metrics, plane, planePostUrl } = props;
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderRight: false, borderTop: false, borderBottom: false, paddingLeft: 1, children: [_jsxs(Text, { bold: true, children: ["pugi retro \u00B7 ", metrics.window.label] }), _jsxs(Text, { dimColor: true, children: ["Branch ", metrics.branch.current, " over ", metrics.branch.base] }), _jsxs(Text, { children: [metrics.commits.total, " commits \u00B7 +", metrics.loc.insertions, " / -", metrics.loc.deletions, " LOC \u00B7 ", metrics.activeDays, " active days"] }), _jsxs(Text, { children: ["Focus ", metrics.focus.score, "% on ", metrics.focus.topDir ?? 'n/a', " \u00B7 Streak ", metrics.streak.personalDays, "d personal / ", metrics.streak.teamDays, "d team"] }), metrics.shipOfTheWeek ? (_jsxs(Text, { children: ["Ship of the week: ", metrics.shipOfTheWeek.subject.slice(0, 60)] })) : null, plane ? (_jsxs(Text, { children: ["Plane: closed ", plane.closedIssues.length, " \u00B7 created ", plane.createdIssues.length, " \u00B7 oversized modules ", plane.oversizedModules.length] })) : null, _jsxs(Text, { dimColor: true, children: ["Markdown: ", persisted.markdownPath] }), _jsxs(Text, { dimColor: true, children: ["JSON:     ", persisted.jsonPath] }), planePostUrl ? _jsxs(Text, { children: ["Posted to Plane: ", planePostUrl] }) : null] }));
-}
-function renderSummary(props) {
-    const app = render(_jsx(SummaryCard, { ...props }));
-    app.unmount();
-}
-export async function runRetroCommand(ctx) {
-    const now = ctx.now ?? new Date();
-    const parsed = parseRetroArgs(ctx.args, now);
-    const gitCtx = await collectGitContext({ cwd: ctx.cwd, window: parsed.window });
-    if (!gitCtx.hasGit) {
-        const msg = 'pugi retro: not a git workspace - initialise git or cd into one.';
-        if (ctx.flags.json) {
-            ctx.io.write(`${JSON.stringify({ ok: false, error: 'no_git_workspace' })}\n`);
-        }
-        else {
-            ctx.io.writeError(msg);
-        }
-        return 2;
-    }
-    // Triple-review P1.2 (): before we write anything
-    // under `.pugi/retros/`, guarantee `.gitignore` covers `.pugi/`. Without
-    // this, the first customer run of `pugi retro` in a fresh repo would
-    // leave retros (and any future `.pugi/settings.json` secret store)
-    // tracked by git on the next `git add -A`. Idempotent.
-    //
-    // Round 2 P1 (2026-06-04): surface failure к stderr — silent catch
-    // defeats the gate's purpose. If `.gitignore` is read-only or perms
-    // refuse, the operator must know retros may be tracked by git.
-    const gitIgnoreCreated = [];
-    const gitIgnoreSkipped = [];
-    try {
-        ensurePugiGitIgnore(ctx.cwd, gitIgnoreCreated, gitIgnoreSkipped);
-    }
-    catch (err) {
-        const reason = err instanceof Error ? err.message : String(err);
-        ctx.io.writeError(`pugi retro: could not update .gitignore (${reason}). ` +
-            `Manually add ".pugi/" to .gitignore so retros are not tracked.`);
-    }
-    const toBaseHeadCount = await countCommitsAheadOfBase(ctx.cwd, gitCtx.baseBranch, parsed.window.since);
-    const metrics = computeMetrics({
-        window: parsed.window,
-        currentBranch: gitCtx.currentBranch,
-        baseBranch: gitCtx.baseBranch,
-        toBaseHeadCount,
-        currentUserName: gitCtx.userName,
-        currentUserEmail: gitCtx.userEmail,
-        commits: gitCtx.commits,
-    });
-    let compare;
-    if (parsed.compare) {
-        const priorWindow = buildPriorWindow(parsed.window);
-        const priorCtx = await collectGitContext({ cwd: ctx.cwd, window: priorWindow });
-        const priorAhead = await countCommitsAheadOfBase(ctx.cwd, gitCtx.baseBranch, priorWindow.since);
-        const priorMetrics = computeMetrics({
-            window: priorWindow,
-            currentBranch: gitCtx.currentBranch,
-            baseBranch: gitCtx.baseBranch,
-            toBaseHeadCount: priorAhead,
-            currentUserName: gitCtx.userName,
-            currentUserEmail: gitCtx.userEmail,
-            commits: priorCtx.commits,
-        });
-        compare = { current: metrics, prior: priorMetrics };
-    }
-    let plane;
-    let planeUnavailableReason;
-    if (parsed.enrichPlane) {
-        const cfgResult = resolvePlaneConfig(ctx.cwd);
-        if (!cfgResult.ok) {
-            planeUnavailableReason = cfgResult.reason;
-        }
-        else {
-            try {
-                const slice = await collectPlaneSlice({
-                    config: cfgResult.config,
-                    since: parsed.window.since,
-                });
-                const links = enrichLinks(gitCtx.commits, slice.closedIssues.concat(slice.createdIssues));
-                const health = computeHealthCard(slice.modules);
-                plane = {
-                    ...slice,
-                    prToIssueLinks: links,
-                    oversizedModules: health.oversized,
-                };
-            }
-            catch (err) {
-                planeUnavailableReason = err instanceof Error ? err.message : String(err);
-            }
-        }
-    }
-    const persisted = persistRetro({
-        root: ctx.cwd,
-        metrics,
-        plane,
-        compare,
-        now,
-    });
-    let planePostUrl;
-    if (parsed.postPlane) {
-        if (!plane) {
-            ctx.io.writeError(`pugi retro --post-plane: Plane unavailable (${planeUnavailableReason ?? 'unknown'}).`);
-        }
-        else {
-            const cfgResult = resolvePlaneConfig(ctx.cwd);
-            if (cfgResult.ok) {
-                try {
-                    const result = await postRetroToPlane({
-                        config: cfgResult.config,
-                        markdown: persisted.markdown,
-                        sequence: persisted.sequence,
-                        dateLabel: persisted.dateLabel,
-                    });
-                    planePostUrl = result.url;
-                    if (result.alreadyExists) {
-                        ctx.io.write(`pugi retro: already exists at ${result.url}\n`);
-                    }
-                }
-                catch (err) {
-                    const msg = err instanceof Error ? err.message : String(err);
-                    ctx.io.writeError(`pugi retro --post-plane failed: ${msg}`);
-                }
-            }
-        }
-    }
-    if (ctx.flags.json) {
-        ctx.io.write(`${JSON.stringify({
-            ok: true,
-            markdownPath: persisted.markdownPath,
-            jsonPath: persisted.jsonPath,
-            sequence: persisted.sequence,
-            metrics,
-            plane: plane ?? null,
-            planePostUrl: planePostUrl ?? null,
-            planeUnavailableReason: planeUnavailableReason ?? null,
-        }, null, 2)}\n`);
-    }
-    else {
-        renderSummary({ persisted, metrics, plane, planePostUrl });
-        if (planeUnavailableReason && !plane) {
-            ctx.io.writeError(`pugi retro: Plane integration unavailable (${planeUnavailableReason}).`);
-        }
-    }
-    return 0;
-}
-//# sourceMappingURL=retro.js.map