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

package/dist/runtime/commands/rewind.js

@@ -1,333 +0,0 @@
-/**
- * `/rewind` runtime — .
- *
- * Three invocation modes, sharing one runner:
- *
- *  - `/rewind N`             drop the last N operator turns + every
- *                             tool call that landed between.
- *  - `/rewind --to <id>`     rewind to a specific event index from the
- *                             visible (post-mask) transcript.
- *  - `/rewind`               interactive picker — surfaces the last 10
- *                             user-turn boundaries (newest-first) and
- *                             returns a payload the caller can use to
- *                             mount a select prompt.
- *
- * The rewind is APPEND-ONLY: we never delete events. `applyRewindMask`
- * elides the masked range on read; `pugi sessions undo-rewind` appends
- * an inverse marker that nullifies the latest rewind so operators have
- * a reliable escape hatch.
- *
- * Surface contract (same shape as `runCompactCommand`):
- *
- *  - Returns a structured result for the JSON path.
- *  - Calls `ctx.writeOutput(payload, text)` once per invocation.
- *  - Throws ONLY on programmer-error. Store failures, missing
- *    sessions, etc. are surfaced as `failed_*` statuses.
- *
- * Exit codes (mapped by the dispatcher in cli.ts):
- *
- *  0 — marker appended OR picker surfaced
- *  1 — store unavailable / session not found
- *  2 — noop (asked to drop 0 turns, nothing to rewind, etc.)
- */
-import { homedir } from 'node:os';
-import { slugForCwd } from '../../core/repl/history.js';
-import { appendRewindMarker, buildRewindPickerRows, pickRewindTargetForTurns, resolveEventIdToIndex, } from '../../core/checkpoint/rewinder.js';
-import { loadFromStore } from '../../core/checkpoint/resumer.js';
-import { SqliteSessionStore, resolveProjectStoreDir, } from '../../core/repl/store/session-store.js';
-/**
- * Entry point reused by the slash command + the top-level dispatcher.
- *
- * `args` accepts:
- *  - `[]`             picker mode
- *  - `["N"]`          drop last N turns
- *  - `["--to", "<id>"]` rewind to event id
- *
- * Both `-N` and `--turns N` are accepted for parity with the upstream tool's
- * `--turns` flag.
- */
-export async function runRewindCommand(args, ctx) {
-    const parsed = parseRewindArgs(args);
-    if (parsed.kind === 'error') {
-        return emit(ctx, {
-            command: 'rewind',
-            status: 'failed_parse',
-            reason: parsed.message,
-        }, parsed.message);
-    }
-    // Resolve session + store.
-    const slug = slugForCwd(ctx.workspaceRoot);
-    let store = ctx.store ?? null;
-    let sessionId = ctx.sessionId ?? null;
-    let storeOpenedHere = false;
-    if (store === null) {
-        sessionId = sessionId ?? (await pickMostRecentSessionIdReadOnly(slug));
-        if (!sessionId) {
-            return emit(ctx, {
-                command: 'rewind',
-                status: 'failed_no_session',
-                reason: 'No active session to rewind. Start a REPL with `pugi`.',
-            });
-        }
-        const opened = await openLiveStore(slug, sessionId);
-        if (!opened) {
-            return emit(ctx, {
-                command: 'rewind',
-                status: 'failed_store',
-                sessionId,
-                reason: 'Could not open local session store (lock held by another REPL?).',
-            });
-        }
-        store = opened;
-        storeOpenedHere = true;
-    }
-    else if (sessionId === null) {
-        const rows = await store.listSessions({ project: slug, limit: 1, status: 'active' });
-        if (rows.length === 0) {
-            return emit(ctx, {
-                command: 'rewind',
-                status: 'failed_no_session',
-                reason: 'No active session to rewind.',
-            });
-        }
-        sessionId = rows[0].id;
-    }
-    try {
-        const loaded = await loadFromStore(store, sessionId);
-        if (!loaded) {
-            return emit(ctx, {
-                command: 'rewind',
-                status: 'failed_no_session',
-                sessionId,
-                reason: `Session '${sessionId}' not found.`,
-            });
-        }
-        // Picker mode: surface the last 10 user-turn boundaries.
-        if (parsed.kind === 'picker') {
-            const rows = buildRewindPickerRows(loaded.rawEvents, 10);
-            if (rows.length === 0) {
-                return emit(ctx, {
-                    command: 'rewind',
-                    status: 'noop_empty',
-                    sessionId,
-                    reason: 'No operator turns to rewind to.',
-                }, 'Nothing to rewind — no operator turns yet.');
-            }
-            const pickerRows = rows.map((r) => ({
-                visibleIndex: r.visibleIndex,
-                turnsAgo: r.turnsAgo,
-                preview: r.preview,
-                timestampEpochMs: r.timestampEpochMs,
-            }));
-            const text = renderPicker(pickerRows);
-            return emit(ctx, {
-                command: 'rewind',
-                status: 'picker',
-                sessionId,
-                pickerRows,
-            }, text);
-        }
-        // Resolve target index.
-        let toEventIndex;
-        let turnsRewound;
-        if (parsed.kind === 'turns') {
-            if (parsed.n <= 0) {
-                return emit(ctx, {
-                    command: 'rewind',
-                    status: 'noop_zero',
-                    sessionId,
-                    reason: 'Asked to drop 0 turns — nothing to do.',
-                }, 'Asked to drop 0 turns — nothing to do.');
-            }
-            const target = pickRewindTargetForTurns(loaded.rawEvents, parsed.n);
-            if (target.turnsRewound === 0) {
-                return emit(ctx, {
-                    command: 'rewind',
-                    status: 'noop_empty',
-                    sessionId,
-                    reason: 'No operator turns to rewind.',
-                }, 'No operator turns to rewind.');
-            }
-            toEventIndex = target.toEventIndex;
-            turnsRewound = target.turnsRewound;
-        }
-        else {
-            // mode === 'to-event'
-            const resolvedIdx = resolveEventIdToIndex(loaded.rawEvents, parsed.eventId);
-            if (resolvedIdx === null) {
-                return emit(ctx, {
-                    command: 'rewind',
-                    status: 'failed_parse',
-                    sessionId,
-                    reason: `Could not resolve event id '${parsed.eventId}'. Try \`/rewind\` for the picker.`,
-                });
-            }
-            toEventIndex = resolvedIdx;
-            // Count user turns in the masked range to report turnsRewound.
-            turnsRewound = countUserTurnsAfter(loaded.rawEvents, toEventIndex);
-        }
-        const fromEventIndex = loaded.rawEvents.length;
-        await appendRewindMarker({
-            store,
-            toEventIndex,
-            fromEventIndex,
-            turnsRewound,
-            reason: parsed.kind === 'turns' ? 'manual' : 'to-event',
-            ...(ctx.now !== undefined ? { now: ctx.now } : {}),
-        });
-        // Reload + recompute visible count for the operator banner.
-        const after = await loadFromStore(store, sessionId);
-        const visibleAfter = after?.visibleEvents.length ?? 0;
-        const banner = `Rewound ${turnsRewound} turn${turnsRewound === 1 ? '' : 's'} ` +
-            `(to event ${toEventIndex < 0 ? 'start' : `#${toEventIndex + 1}`}). ` +
-            `${visibleAfter} event${visibleAfter === 1 ? '' : 's'} now visible. ` +
-            `Undo with \`pugi sessions undo-rewind\`.`;
-        return emit(ctx, {
-            command: 'rewind',
-            status: 'rewound',
-            sessionId,
-            turnsRewound,
-            toEventIndex,
-            fromEventIndex,
-            visibleAfter,
-        }, banner);
-    }
-    finally {
-        if (storeOpenedHere && store) {
-            try {
-                await store.close();
-            }
-            catch {
-                /* idempotent */
-            }
-        }
-    }
-}
-/**
- * Accepts:
- *  pugi rewind           -> picker
- *  pugi rewind 3         -> drop 3 turns
- *  pugi rewind --turns 3 -> same
- *  pugi rewind --to 12   -> rewind to event index 12 (1-based visible)
- *  pugi rewind --to #12  -> rewind to event index 12 (0-based hidden)
- */
-function parseRewindArgs(args) {
-    if (args.length === 0)
-        return { kind: 'picker' };
-    const head = args[0];
-    // --to <id>
-    if (head === '--to' || head === '-t') {
-        const eventId = args[1];
-        if (!eventId) {
-            return {
-                kind: 'error',
-                message: 'Usage: pugi rewind --to <event-id>',
-            };
-        }
-        return { kind: 'to-event', eventId };
-    }
-    if (head.startsWith('--to=')) {
-        const eventId = head.slice('--to='.length);
-        if (eventId.length === 0) {
-            return {
-                kind: 'error',
-                message: 'Usage: pugi rewind --to <event-id>',
-            };
-        }
-        return { kind: 'to-event', eventId };
-    }
-    // --turns N OR -N OR positional N
-    if (head === '--turns' || head === '-n') {
-        const n = Number.parseInt(args[1] ?? '', 10);
-        if (!Number.isFinite(n) || n < 0) {
-            return {
-                kind: 'error',
-                message: 'Usage: pugi rewind --turns <N>',
-            };
-        }
-        return { kind: 'turns', n };
-    }
-    if (head.startsWith('--turns=')) {
-        const n = Number.parseInt(head.slice('--turns='.length), 10);
-        if (!Number.isFinite(n) || n < 0) {
-            return {
-                kind: 'error',
-                message: 'Usage: pugi rewind --turns <N>',
-            };
-        }
-        return { kind: 'turns', n };
-    }
-    // Bare integer: positional turns count.
-    const positional = Number.parseInt(head, 10);
-    if (Number.isFinite(positional) && positional >= 0) {
-        return { kind: 'turns', n: positional };
-    }
-    return {
-        kind: 'error',
-        message: `Unknown argument '${head}'. Try \`pugi rewind\`, \`pugi rewind <N>\`, or \`pugi rewind --to <id>\`.`,
-    };
-}
-function emit(ctx, payload, text) {
-    const human = text ?? payload.reason ?? `rewind: ${payload.status}`;
-    ctx.writeOutput(payload, human);
-    return payload;
-}
-function renderPicker(rows) {
-    const lines = ['Rewind picker — pick a turn boundary:', ''];
-    for (const r of rows) {
-        const tag = `[#${r.visibleIndex.toString().padStart(3)}]`;
-        const ago = `${r.turnsAgo}t ago`.padStart(8);
-        lines.push(` ${tag} ${ago} ${r.preview}`);
-    }
-    lines.push('', 'Rewind with: pugi rewind --to <#N> (or `pugi rewind <turnsToDrop>`).');
-    return lines.join('\n');
-}
-function countUserTurnsAfter(events, toEventIndex) {
-    let count = 0;
-    for (let i = toEventIndex + 1; i < events.length; i += 1) {
-        if (events[i].kind === 'user')
-            count += 1;
-    }
-    return count;
-}
-/**
- * Open the SqliteSessionStore for the workspace's project slug, bound
- * to `sessionId`. Returns null when the lock is held by another REPL.
- */
-async function openLiveStore(projectSlug, sessionId) {
-    try {
-        const store = new SqliteSessionStore({ projectSlug, home: homedir() });
-        await store.open({
-            id: sessionId,
-            workspaceRoot: process.cwd(),
-            projectSlug,
-        });
-        return store;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Discover the most recent active session id for a project slug,
- * without taking the writer lockfile. Used by the standalone CLI path
- * (no `--session` flag) so a live REPL holding the lock does not block
- * the lookup.
- */
-async function pickMostRecentSessionIdReadOnly(projectSlug) {
-    try {
-        const dir = resolveProjectStoreDir(projectSlug, homedir());
-        const view = await SqliteSessionStore.openReadOnly(dir);
-        try {
-            const rows = await view.list({ project: projectSlug, limit: 1, status: 'active' });
-            return rows.length > 0 ? rows[0].id : null;
-        }
-        finally {
-            await view.close();
-        }
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=rewind.js.map

package/dist/runtime/commands/roster.js

@@ -1,117 +0,0 @@
-/**
- * `pugi roster` command - Tier 1 instantiation Phase 1.
- *
- * Lists the live Tier 1 personas with display name, role, and routing
- * tag. The CLI walks two sources in order:
- *
- *  1. The local @pugi/personas roster (THE_TEN). Always succeeds; the
- *     ten brand-canonical personas are baked into the SDK.
- *  2. The remote `GET /api/pugi/sessions/roster` endpoint when the
- *     operator has a valid credential. The remote response carries the
- *     server-side dispatch role + dispatchTag for each slug so the
- *     operator sees the actual routing decision the dispatcher will
- *     apply on a `pugi delegate <slug>` call.
- *
- * The command never fails if the network is unreachable - it falls back
- * to local-only output with a one-line warning. This matches the
- * local-first contract : the operator can still see who is on
- * the team without an API key.
- *
- * Output:
- *  - text default: a 3-column table (slug | name | role).
- *  - --json:       a structured array of { slug, name, role, totem,
- *                   dispatchTag } records, used by scripted callers.
- */
-import { THE_TEN } from '@pugi/personas';
-import { fetchPersonaRoster, } from '@pugi/sdk';
-/**
- * Fallback role + tag table the CLI uses when the runtime is unreachable
- * (no credentials, network error, older runtime without the
- * /sessions/roster endpoint). Mirrors the server-side
- * persona-dispatch.ts PERSONA_REGISTRY so a CLI that ran without
- * credentials still shows the operator the right routing intent.
- */
-const FALLBACK_ROLE_BY_SLUG = Object.freeze({
-    main: { role: 'orchestrator', dispatchTag: 'reason' },
-    architect: { role: 'architect', dispatchTag: 'reason' },
-    dev: { role: 'coder', dispatchTag: 'codegen' },
-    qa: { role: 'verifier', dispatchTag: 'reason' },
-    pm: { role: 'release', dispatchTag: 'reason' },
-    devops: { role: 'devops', dispatchTag: 'reason' },
-    researcher: { role: 'researcher', dispatchTag: 'reason' },
-    analyst: { role: 'analyst', dispatchTag: 'summarize' },
-    designer: { role: 'design_qa', dispatchTag: 'reason' },
-    frontend: { role: 'frontend', dispatchTag: 'codegen' },
-});
-/**
- * Build the roster rows by merging the local @pugi/personas brand
- * roster with the remote dispatch metadata when a credential is
- * available. Pure function so the runtime CLI command can unit-test it
- * without standing up an Anvil endpoint.
- */
-export function mergeRoster(brandRoster, remote) {
-    const remoteIndex = new Map((remote ?? []).map((entry) => [entry.slug, entry]));
-    return brandRoster.map((persona) => {
-        const fromRemote = remoteIndex.get(persona.slug);
-        const fallback = FALLBACK_ROLE_BY_SLUG[persona.slug] ?? {
-            role: persona.role,
-            dispatchTag: 'reason',
-        };
-        return {
-            slug: persona.slug,
-            name: persona.name,
-            totem: persona.animal,
-            role: fromRemote?.role ?? fallback.role,
-            dispatchTag: fromRemote?.dispatchTag ?? fallback.dispatchTag,
-            oneLiner: persona.oneLiner,
-            source: fromRemote ? 'remote' : 'local-fallback',
-        };
-    });
-}
-/**
- * Render a roster as a plain-text 3-column table the operator reads in
- * the terminal. The column widths grow to fit the longest cell so a
- * future displayName drift does not truncate silently.
- */
-export function renderRosterTable(rows) {
-    if (rows.length === 0)
-        return 'Roster is empty.';
-    const head = { slug: 'slug', name: 'name', totem: 'totem', role: 'role', dispatchTag: 'tag' };
-    const widths = {
-        slug: Math.max(head.slug.length, ...rows.map((r) => r.slug.length)),
-        name: Math.max(head.name.length, ...rows.map((r) => r.name.length)),
-        totem: Math.max(head.totem.length, ...rows.map((r) => r.totem.length)),
-        role: Math.max(head.role.length, ...rows.map((r) => r.role.length)),
-        dispatchTag: Math.max(head.dispatchTag.length, ...rows.map((r) => r.dispatchTag.length)),
-    };
-    const pad = (s, width) => s + ' '.repeat(Math.max(0, width - s.length));
-    const line = (r) => [pad(r.slug, widths.slug), pad(r.name, widths.name), pad(r.totem, widths.totem), pad(r.role, widths.role), pad(r.dispatchTag, widths.dispatchTag)].join(' ');
-    const header = line(head);
-    const sep = '-'.repeat(header.length);
-    return [header, sep, ...rows.map((r) => line(r))].join('\n');
-}
-/**
- * Resolve the roster by walking remote + local sources. The CLI command
- * is a thin wrapper around this function so unit tests can exercise the
- * merge logic without hitting the runtime.
- */
-export async function resolveRoster(config) {
-    if (!config) {
-        return {
-            rows: mergeRoster(THE_TEN, null),
-            warning: 'no credential configured; showing local @pugi/personas roster only',
-        };
-    }
-    const result = await fetchPersonaRoster(config);
-    if (result.status === 'ok') {
-        return { rows: mergeRoster(THE_TEN, result.response.personas), warning: null };
-    }
-    const reason = result.status === 'endpoint_missing'
-        ? 'runtime does not expose /api/pugi/sessions/roster (upgrade admin-api to +)'
-        : result.message;
-    return {
-        rows: mergeRoster(THE_TEN, null),
-        warning: `roster fetch failed (${result.status}): ${reason}; showing local roster only`,
-    };
-}
-//# sourceMappingURL=roster.js.map

package/dist/runtime/commands/sessions.js

@@ -1,163 +0,0 @@
-/**
- * `pugi sessions` extensions — .
- *
- * The legacy `pugi sessions` handler lives inline in `runtime/cli.ts`
- * (it predates the per-command runner pattern). This module exposes the
- * new sub-commands the L9 sprint adds:
- *
- *  - `pugi sessions undo-rewind [<session-id>]`
- *      Append an inverse marker that nullifies the latest 'rewind'
- *      marker on the target session. Operator escape hatch: nothing
- *      is destroyed, the masked range simply becomes visible again.
- *
- * Wire pattern matches `runCompactCommand` / `runRewindCommand`: one
- * structured payload + one human line per invocation, returned to the
- * caller for the JSON path.
- */
-import { homedir } from 'node:os';
-import { slugForCwd } from '../../core/repl/history.js';
-import { appendRewindMarker, findLatestActiveRewind, } from '../../core/checkpoint/rewinder.js';
-import { loadFromStore } from '../../core/checkpoint/resumer.js';
-import { SqliteSessionStore, resolveProjectStoreDir, } from '../../core/repl/store/session-store.js';
-/**
- * Sub-command router. The caller passes the full positional args; we
- * peel `args[0]` as the sub-command name and forward the tail. Unknown
- * sub-commands surface a usage hint at exit code 2.
- */
-export async function runSessionsCommand(args, ctx) {
-    const sub = args[0];
-    if (sub === 'undo-rewind') {
-        return runUndoRewind(args.slice(1), ctx);
-    }
-    // Other sub-commands (the legacy `pugi sessions` list path) are
-    // owned by runtime/cli.ts — return null so the caller knows to fall
-    // through to that handler.
-    return null;
-}
-async function runUndoRewind(args, ctx) {
-    const explicitId = args[0] && !args[0].startsWith('--') ? args[0] : undefined;
-    const slug = slugForCwd(ctx.workspaceRoot);
-    let store = ctx.store ?? null;
-    let sessionId = ctx.sessionId ?? explicitId ?? null;
-    let storeOpenedHere = false;
-    if (store === null) {
-        sessionId = sessionId ?? (await pickMostRecentSessionIdReadOnly(slug));
-        if (!sessionId) {
-            return emit(ctx, {
-                command: 'sessions',
-                sub: 'undo-rewind',
-                status: 'failed_no_session',
-                reason: 'No session to undo-rewind. Start a REPL with `pugi`.',
-            });
-        }
-        const opened = await openLiveStore(slug, sessionId);
-        if (!opened) {
-            return emit(ctx, {
-                command: 'sessions',
-                sub: 'undo-rewind',
-                status: 'failed_store',
-                sessionId,
-                reason: 'Could not open local session store (lock held by another REPL?).',
-            });
-        }
-        store = opened;
-        storeOpenedHere = true;
-    }
-    else if (sessionId === null) {
-        const rows = await store.listSessions({ project: slug, limit: 1, status: 'active' });
-        if (rows.length === 0) {
-            return emit(ctx, {
-                command: 'sessions',
-                sub: 'undo-rewind',
-                status: 'failed_no_session',
-                reason: 'No active session to undo-rewind.',
-            });
-        }
-        sessionId = rows[0].id;
-    }
-    try {
-        const loaded = await loadFromStore(store, sessionId);
-        if (!loaded) {
-            return emit(ctx, {
-                command: 'sessions',
-                sub: 'undo-rewind',
-                status: 'failed_no_session',
-                sessionId,
-                reason: `Session '${sessionId}' not found.`,
-            });
-        }
-        const latest = findLatestActiveRewind(loaded.rawEvents);
-        if (latest === null) {
-            return emit(ctx, {
-                command: 'sessions',
-                sub: 'undo-rewind',
-                status: 'noop_no_rewind',
-                sessionId,
-                reason: 'No active rewind to undo on this session.',
-            }, 'No active rewind to undo.');
-        }
-        const fromEventIndex = loaded.rawEvents.length;
-        await appendRewindMarker({
-            store,
-            mode: 'undo-rewind',
-            toEventIndex: latest.payload.toEventIndex,
-            fromEventIndex,
-            turnsRewound: latest.payload.turnsRewound,
-            reason: 'undo',
-            ...(ctx.now !== undefined ? { now: ctx.now } : {}),
-        });
-        return emit(ctx, {
-            command: 'sessions',
-            sub: 'undo-rewind',
-            status: 'undone',
-            sessionId,
-            undoneTurns: latest.payload.turnsRewound,
-        }, `Undid the latest rewind (${latest.payload.turnsRewound} turn${latest.payload.turnsRewound === 1 ? '' : 's'} restored).`);
-    }
-    finally {
-        if (storeOpenedHere && store) {
-            try {
-                await store.close();
-            }
-            catch {
-                /* idempotent */
-            }
-        }
-    }
-}
-function emit(ctx, payload, text) {
-    const human = text ?? payload.reason ?? `sessions ${payload.sub}: ${payload.status}`;
-    ctx.writeOutput(payload, human);
-    return payload;
-}
-async function openLiveStore(projectSlug, sessionId) {
-    try {
-        const store = new SqliteSessionStore({ projectSlug, home: homedir() });
-        await store.open({
-            id: sessionId,
-            workspaceRoot: process.cwd(),
-            projectSlug,
-        });
-        return store;
-    }
-    catch {
-        return null;
-    }
-}
-async function pickMostRecentSessionIdReadOnly(projectSlug) {
-    try {
-        const dir = resolveProjectStoreDir(projectSlug, homedir());
-        const view = await SqliteSessionStore.openReadOnly(dir);
-        try {
-            const rows = await view.list({ project: projectSlug, limit: 1, status: 'active' });
-            return rows.length > 0 ? rows[0].id : null;
-        }
-        finally {
-            await view.close();
-        }
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=sessions.js.map