@pugi/cli 0.1.0-beta.1 → 0.1.0-beta.10

package/dist/runtime/commands/roster.js

@@ -0,0 +1,117 @@
+/**
+ * `pugi roster` command - α7.5 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 (ADR-0037): 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 α7.5+)'
+        : 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/worktree.js

@@ -0,0 +1,177 @@
+/**
+ * `pugi worktree <op>` — α7.7 Phase 1.
+ *
+ * Manual control over the scratch worktree primitive. Three subcommands:
+ *
+ *   pugi worktree create [branch]    # spawns `.pugi/worktrees/<uuid>`
+ *   pugi worktree promote <path>     # applies the worktree's diff back to cwd
+ *   pugi worktree drop <path>        # removes the worktree (idempotent)
+ *
+ * Output: human-readable by default, structured JSON under --json so
+ * scripted callers can chain (`pugi worktree create --json | jq .path`).
+ *
+ * The same primitives are used by the `pugi build` and
+ * `pugi review --consensus` paths internally; this surface is the
+ * operator escape hatch for debugging / manual experimentation.
+ *
+ * Brand voice: ASCII only, no emoji, no banned words.
+ */
+import { spawnSync } from 'node:child_process';
+import { resolve, sep } from 'node:path';
+import { createWorktree, dropWorktree, promoteWorktree } from '../../core/edits/worktree.js';
+/**
+ * R1 fix (2026-05-26, PR #413 r1, P2 #10): operator-facing path
+ * validation. The core `promoteWorktree` / `dropWorktree` primitives
+ * already gate their inputs, but mirroring the check at the CLI surface
+ * gives the operator a clean error message before we even attempt the
+ * git invocation (which would otherwise leak `git rev-parse HEAD` stderr).
+ */
+function isUnderScratchRoot(cwd, candidate) {
+    const scratchRoot = resolve(cwd, '.pugi', 'worktrees');
+    const abs = resolve(cwd, candidate);
+    return abs.startsWith(scratchRoot + sep) && abs !== scratchRoot;
+}
+export async function runWorktreeCommand(args, opts) {
+    const [op, ...rest] = args;
+    if (!op)
+        return usage();
+    if (op === 'create') {
+        const branch = rest[0];
+        const result = createWorktree({
+            cwd: opts.cwd,
+            ...(branch ? { branch } : {}),
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify(result, null, 2)
+                    : `worktree create failed: ${result.reason}: ${result.detail}`,
+                exitCode: 1,
+            };
+        }
+        const handle = result.value;
+        return {
+            ok: true,
+            text: opts.json
+                ? JSON.stringify({ path: handle.path, baseSha: handle.baseSha }, null, 2)
+                : `worktree created: ${handle.path}\nbase: ${handle.baseSha}`,
+            exitCode: 0,
+        };
+    }
+    if (op === 'promote') {
+        const worktreePath = rest[0];
+        if (!worktreePath) {
+            return {
+                ok: false,
+                text: 'Usage: pugi worktree promote <path>',
+                exitCode: 2,
+            };
+        }
+        if (!isUnderScratchRoot(opts.cwd, worktreePath)) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify({
+                        ok: false,
+                        reason: 'invalid_worktree_path',
+                        detail: `worktree path must live under <cwd>/.pugi/worktrees/`,
+                    }, null, 2)
+                    : `promote failed: invalid_worktree_path: ${worktreePath} is not under .pugi/worktrees/`,
+                exitCode: 3,
+            };
+        }
+        // Resolve the worktree path's base SHA from its own git HEAD so
+        // the operator never has to remember it after `worktree create`.
+        const abs = resolve(opts.cwd, worktreePath);
+        const head = spawnSync('git', ['rev-parse', 'HEAD'], { cwd: abs, encoding: 'utf8' });
+        if (head.status !== 0) {
+            return {
+                ok: false,
+                text: `cannot read HEAD of ${abs}: ${head.stderr.trim() || 'git rev-parse failed'}`,
+                exitCode: 1,
+            };
+        }
+        const baseSha = head.stdout.trim();
+        const result = promoteWorktree({
+            cwd: opts.cwd,
+            worktreePath: abs,
+            baseSha,
+            ...(opts.dryRun ? { dryRun: true } : {}),
+        });
+        if (!result.ok) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify(result, null, 2)
+                    : `promote failed: ${result.reason}: ${result.detail}`,
+                exitCode: result.reason === 'protected_file_in_worktree' ? 3 : 1,
+            };
+        }
+        const prefix = opts.dryRun ? 'dry-run: would promote' : 'promoted';
+        return {
+            ok: true,
+            text: opts.json
+                ? JSON.stringify({ filesChanged: result.value.filesChanged, dryRun: opts.dryRun ?? false }, null, 2)
+                : `${prefix} ${result.value.filesChanged} files from ${abs}`,
+            exitCode: 0,
+        };
+    }
+    if (op === 'drop') {
+        const worktreePath = rest[0];
+        if (!worktreePath) {
+            return {
+                ok: false,
+                text: 'Usage: pugi worktree drop <path>',
+                exitCode: 2,
+            };
+        }
+        if (!isUnderScratchRoot(opts.cwd, worktreePath)) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify({
+                        ok: false,
+                        reason: 'invalid_worktree_path',
+                        detail: `worktree path must live under <cwd>/.pugi/worktrees/`,
+                    }, null, 2)
+                    : `drop failed: invalid_worktree_path: ${worktreePath} is not under .pugi/worktrees/`,
+                exitCode: 3,
+            };
+        }
+        const abs = resolve(opts.cwd, worktreePath);
+        const result = dropWorktree(abs, opts.cwd);
+        if (!result.ok) {
+            return {
+                ok: false,
+                text: opts.json
+                    ? JSON.stringify(result, null, 2)
+                    : `drop failed: ${result.reason}: ${result.detail}`,
+                exitCode: result.reason === 'invalid_worktree_path' ? 3 : 1,
+            };
+        }
+        return {
+            ok: true,
+            text: opts.json
+                ? JSON.stringify({ dropped: abs }, null, 2)
+                : `worktree dropped: ${abs}`,
+            exitCode: 0,
+        };
+    }
+    return {
+        ok: false,
+        text: `unknown worktree operation: ${op}. Supported: create, promote, drop`,
+        exitCode: 2,
+    };
+}
+function usage() {
+    return {
+        ok: false,
+        text: 'Usage: pugi worktree <op>\n' +
+            '  pugi worktree create [branch]\n' +
+            '  pugi worktree promote <path>\n' +
+            '  pugi worktree drop <path>',
+        exitCode: 2,
+    };
+}
+//# sourceMappingURL=worktree.js.map