@pugi/cli 0.1.0-beta.9 → 0.1.0-beta.90

package/dist/runtime/commands/recipe.js

@@ -0,0 +1,325 @@
+/**
+ * `pugi recipe` — saved parameterized multi-step workflows (backlog #62).
+ *
+ * Subcommands:
+ *  pugi recipe list                       Show recipes (repo + global).
+ *  pugi recipe show <id>                  Print recipe YAML.
+ *  pugi recipe run <id> [--param=value...] Execute recipe.
+ *  pugi recipe new <id>                   Scaffold a new template.
+ *
+ * Exit codes:
+ *  0 — happy path.
+ *  1 — recipe failed / denied / halted.
+ *  2 — argument / shape error (unknown subcommand, bad flag, etc.).
+ *  4 — recipe not found.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { loadSettings } from '../../core/settings.js';
+import { loadRecipes, resolveRecipe, repoRecipesDir, } from '../../core/recipes/loader.js';
+import { resolveParams, runRecipe, } from '../../core/recipes/runner.js';
+export async function runRecipeCommand(args, ctx) {
+    const flags = parseFlags(args);
+    const sub = flags.rest[0];
+    if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+        emitUsage(ctx, flags.json);
+        return sub ? 0 : 2;
+    }
+    if (sub === 'list')
+        return runList(ctx, flags.json);
+    if (sub === 'show')
+        return runShow(ctx, flags.rest.slice(1), flags.json);
+    if (sub === 'run')
+        return runRun(ctx, flags.rest.slice(1), flags.json);
+    if (sub === 'new')
+        return runNew(ctx, flags.rest.slice(1), flags.json);
+    ctx.writeOutput({ ok: false, error: `unknown subcommand: ${sub}` }, `pugi recipe: unknown subcommand '${sub}'. Try 'pugi recipe --help'.`);
+    return 2;
+}
+function parseFlags(args) {
+    const rest = [];
+    let json = false;
+    for (const arg of args) {
+        if (arg === '--json') {
+            json = true;
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, json };
+}
+function emitUsage(ctx, json) {
+    const lines = [
+        'pugi recipe — saved parameterized multi-step workflows.',
+        '',
+        'Subcommands:',
+        ' pugi recipe list                       List recipes (repo + global).',
+        ' pugi recipe show <id>                  Print a recipe in YAML.',
+        ' pugi recipe run <id> [--param=value]   Execute a recipe.',
+        ' pugi recipe new <id>                   Scaffold a new recipe template.',
+        '',
+        'Flags:',
+        ' --json   Emit a JSON envelope instead of human text.',
+        '',
+        'On-disk layout:',
+        ' .pugi/recipes/<id>.yml     repo-local (committed to project)',
+        ' ~/.pugi/recipes/<id>.yml   global (per-operator)',
+        '',
+        'Repo wins on id conflict — drop a same-id file in .pugi/recipes/ to override.',
+    ];
+    const text = lines.join('\n');
+    ctx.writeOutput({ ok: true, command: 'recipe', usage: text }, text);
+    void json;
+}
+function runList(ctx, json) {
+    const { recipes, errors, globalDir, repoDir } = loadRecipes({
+        workspaceRoot: ctx.workspaceRoot,
+        ...(ctx.home !== undefined ? { home: ctx.home } : {}),
+    });
+    const entries = Array.from(recipes.values()).sort((a, b) => a.id.localeCompare(b.id));
+    const payload = {
+        ok: true,
+        globalDir,
+        repoDir,
+        total: entries.length,
+        recipes: entries.map((r) => ({
+            id: r.id,
+            name: r.name,
+            description: r.description ?? '',
+            origin: r.origin,
+            source: r.source,
+            steps: r.steps.length,
+            params: r.params.map((p) => p.name),
+        })),
+        errors,
+    };
+    if (json) {
+        ctx.writeOutput(payload, JSON.stringify(payload, null, 2));
+        return errors.length > 0 ? 0 : 0;
+    }
+    const lines = [];
+    lines.push(`pugi recipes (${entries.length} configured)`);
+    lines.push(` global: ${globalDir}`);
+    lines.push(` repo:  ${repoDir}`);
+    if (entries.length === 0) {
+        lines.push(' no recipes found — `pugi recipe new <id>` scaffolds one.');
+    }
+    else {
+        for (const recipe of entries) {
+            const desc = recipe.description ? ` — ${recipe.description}` : '';
+            const tag = recipe.origin === 'repo' ? '[repo]' : '[global]';
+            lines.push(` ${recipe.id} ${tag}${desc}`);
+            lines.push(`   source: ${recipe.source}`);
+            lines.push(`   steps: ${recipe.steps.length}; params: ${recipe.params.map((p) => p.name).join(', ') || '(none)'}`);
+        }
+    }
+    if (errors.length > 0) {
+        lines.push('');
+        lines.push('Parse errors:');
+        for (const err of errors) {
+            lines.push(` ${err.source}: ${err.error}`);
+        }
+    }
+    ctx.writeOutput(payload, lines.join('\n'));
+    return 0;
+}
+function runShow(ctx, rest, json) {
+    const id = rest[0];
+    if (!id) {
+        ctx.writeOutput({ ok: false, error: 'recipe id is required' }, "pugi recipe show: needs a recipe id (try 'pugi recipe list').");
+        return 2;
+    }
+    const { recipes } = loadRecipes({
+        workspaceRoot: ctx.workspaceRoot,
+        ...(ctx.home !== undefined ? { home: ctx.home } : {}),
+    });
+    const resolved = resolveRecipe(id, recipes);
+    if (!resolved.ok) {
+        ctx.writeOutput({ ok: false, error: resolved.error }, `pugi recipe show: ${resolved.error}`);
+        return 4;
+    }
+    const body = readFileSync(resolved.recipe.source, 'utf8');
+    const payload = {
+        ok: true,
+        id: resolved.recipe.id,
+        source: resolved.recipe.source,
+        origin: resolved.recipe.origin,
+        body,
+    };
+    if (json) {
+        ctx.writeOutput(payload, JSON.stringify(payload, null, 2));
+        return 0;
+    }
+    const header = `# ${resolved.recipe.source} (${resolved.recipe.origin})`;
+    ctx.writeOutput(payload, `${header}\n${body}`);
+    return 0;
+}
+async function runRun(ctx, rest, json) {
+    const id = rest[0];
+    if (!id) {
+        ctx.writeOutput({ ok: false, error: 'recipe id is required' }, "pugi recipe run: needs a recipe id (try 'pugi recipe list').");
+        return 2;
+    }
+    const { recipes } = loadRecipes({
+        workspaceRoot: ctx.workspaceRoot,
+        ...(ctx.home !== undefined ? { home: ctx.home } : {}),
+    });
+    const resolved = resolveRecipe(id, recipes);
+    if (!resolved.ok) {
+        ctx.writeOutput({ ok: false, error: resolved.error }, `pugi recipe run: ${resolved.error}`);
+        return 4;
+    }
+    const paramArgs = parseParamArgs(rest.slice(1));
+    if (!paramArgs.ok) {
+        ctx.writeOutput({ ok: false, error: paramArgs.error }, `pugi recipe run: ${paramArgs.error}`);
+        return 2;
+    }
+    const resolvedParams = resolveParams(resolved.recipe, paramArgs.params);
+    if (!resolvedParams.ok) {
+        ctx.writeOutput({ ok: false, error: resolvedParams.error }, `pugi recipe run: ${resolvedParams.error}`);
+        return 2;
+    }
+    let permissionMode = ctx.permissionMode ?? 'ask';
+    if (ctx.permissionMode === undefined) {
+        try {
+            permissionMode = loadSettings(ctx.workspaceRoot).permissions.mode;
+        }
+        catch {
+            // Fall back to 'ask' when no settings file exists (recipes ran
+            // from a fresh checkout before `pugi init`).
+        }
+    }
+    const result = await runRecipe({
+        recipe: resolved.recipe,
+        params: resolvedParams.params,
+        workspaceRoot: ctx.workspaceRoot,
+        permissionMode,
+        ...(ctx.exec !== undefined ? { exec: ctx.exec } : {}),
+        ...(ctx.now !== undefined ? { now: ctx.now } : {}),
+    });
+    emitRunResult(ctx, result, json);
+    return result.status === 'success' ? 0 : 1;
+}
+function parseParamArgs(args) {
+    const out = {};
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        if (!arg.startsWith('--')) {
+            return { ok: false, error: `unexpected argument '${arg}'` };
+        }
+        const body = arg.slice(2);
+        const eq = body.indexOf('=');
+        let key;
+        let value;
+        if (eq >= 0) {
+            key = body.slice(0, eq);
+            value = body.slice(eq + 1);
+            i += 1;
+        }
+        else {
+            key = body;
+            const next = args[i + 1];
+            if (next === undefined || next.startsWith('--')) {
+                // Bare flag = boolean true (handy for `--skipTests`).
+                value = 'true';
+                i += 1;
+            }
+            else {
+                value = next;
+                i += 2;
+            }
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(key)) {
+            return { ok: false, error: `bad param name '${key}'` };
+        }
+        out[key] = value;
+    }
+    return { ok: true, params: out };
+}
+function emitRunResult(ctx, result, json) {
+    const payload = {
+        ok: result.status === 'success',
+        id: result.id,
+        status: result.status,
+        params: result.params,
+        durationMs: result.durationMs,
+        steps: result.steps.map((s) => ({
+            name: s.name,
+            status: s.status,
+            exitCode: s.exitCode,
+            command: s.command,
+            durationMs: s.durationMs,
+            stdoutBytes: s.stdout.length,
+            stderrBytes: s.stderr.length,
+            denyReason: s.denyReason || undefined,
+        })),
+    };
+    if (json) {
+        ctx.writeOutput(payload, JSON.stringify(payload, null, 2));
+        return;
+    }
+    const lines = [];
+    lines.push(`pugi recipe run ${result.id} — ${result.status}`);
+    for (const step of result.steps) {
+        const exit = step.exitCode === null ? '-' : String(step.exitCode);
+        const duration = step.durationMs > 0 ? `${step.durationMs}ms` : '-';
+        lines.push(` [${step.status}] ${step.name} exit=${exit} ${duration}`);
+        if (step.command)
+            lines.push(`   cmd: ${step.command}`);
+        if (step.denyReason)
+            lines.push(`   deny: ${step.denyReason}`);
+        if (step.stderr) {
+            const preview = step.stderr.split('\n').slice(0, 3).join('\n   ');
+            lines.push(`   stderr: ${preview}`);
+        }
+    }
+    ctx.writeOutput(payload, lines.join('\n'));
+}
+function runNew(ctx, rest, json) {
+    const id = rest[0];
+    if (!id) {
+        ctx.writeOutput({ ok: false, error: 'recipe id is required' }, 'pugi recipe new: needs an id (e.g. `pugi recipe new deploy-staging`).');
+        return 2;
+    }
+    if (!/^[a-z][a-z0-9-]*$/.test(id)) {
+        ctx.writeOutput({ ok: false, error: `bad recipe id '${id}'` }, `pugi recipe new: id must match [a-z][a-z0-9-]* (got '${id}').`);
+        return 2;
+    }
+    const dir = repoRecipesDir(ctx.workspaceRoot);
+    const target = join(dir, `${id}.yml`);
+    if (existsSync(target)) {
+        ctx.writeOutput({ ok: false, error: `${target} already exists` }, `pugi recipe new: ${target} already exists.`);
+        return 2;
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, recipeTemplate(id), 'utf8');
+    const payload = { ok: true, id, source: target };
+    if (json) {
+        ctx.writeOutput(payload, JSON.stringify(payload, null, 2));
+    }
+    else {
+        ctx.writeOutput(payload, `pugi recipe new: scaffolded ${target}.\nEdit it, then run \`pugi recipe run ${id}\`.`);
+    }
+    return 0;
+}
+function recipeTemplate(id) {
+    return [
+        `schema: 1`,
+        `name: ${id}`,
+        `description: TODO describe what this recipe does.`,
+        `params:`,
+        ` branch: { type: string, default: main, required: false }`,
+        ` skipTests: { type: boolean, default: false }`,
+        `steps:`,
+        ` - name: build`,
+        `   run: pnpm build`,
+        ` - name: test`,
+        `   run: pnpm test`,
+        `   when: "!params.skipTests"`,
+        ` - name: deploy`,
+        `   run: ./scripts/deploy.sh \${params.branch} staging`,
+        ``,
+    ].join('\n');
+}
+//# sourceMappingURL=recipe.js.map

package/dist/runtime/commands/redo-blob-store.js

@@ -0,0 +1,92 @@
+/**
+ * Redo blob store — .
+ *
+ * `/undo` walks the most recent successful mutating tool result and
+ * reverts each file on disk. `/redo` reapplies that change. To reapply,
+ * we need the post-mutation content — but the event log records only
+ * sha256 hashes, not content (see core/file-cache.ts comment).
+ *
+ * Solution: a content-addressable sidecar store at
+ * `<workspaceRoot>/.pugi/undo-blobs/<sha256>`. The undo runner captures
+ * each file's CURRENT content (which equals the original AFTER state)
+ * into the store BEFORE reverting on disk. The redo runner reads the
+ * blob keyed by `beforeHash` of the inverse mutation (which records
+ * the pre-revert hash = the original AFTER hash) and writes it back.
+ *
+ * The store is deliberately untracked (`.pugi/` already lives in
+ * .gitignore) and self-cleaning — after a successful redo we delete
+ * the blob so a second redo without a fresh undo is a noop. Stale
+ * blobs left behind by an interrupted undo are reaped after 7 days
+ * by the existing `.pugi/cleanup` cadence (best-effort; not a
+ * correctness requirement).
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { resolve } from 'node:path';
+import { hashContent } from '../../core/file-cache.js';
+/** Sha256-keyed blob path under `<root>/.pugi/undo-blobs/`. */
+export function blobPathFor(root, sha) {
+    return resolve(root, '.pugi/undo-blobs', sha);
+}
+/** Ensure the blob directory exists. Idempotent. */
+function ensureBlobDir(root) {
+    const dir = resolve(root, '.pugi/undo-blobs');
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    return dir;
+}
+/**
+ * Write `content` into the blob store. Returns the resolved blob path.
+ * Atomic tmp+rename so partial writes never present a half-blob к
+ * future redo invocations.
+ *
+ * Idempotent: if a blob with the same content already exists, the
+ * second write is a noop (the rename target already matches).
+ */
+export function writeBlob(root, content) {
+    ensureBlobDir(root);
+    const sha = hashContent(content);
+    const dst = blobPathFor(root, sha);
+    if (existsSync(dst)) {
+        // Same content already cached; nothing to do.
+        return { sha, path: dst };
+    }
+    const tmp = `${dst}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, content, { encoding: 'utf8', mode: 0o600 });
+    renameSync(tmp, dst);
+    return { sha, path: dst };
+}
+/**
+ * Read a blob by sha. Returns `undefined` when the blob is missing
+ * (cleanup ran, repo cloned fresh, blob never captured). Callers
+ * MUST treat undefined as "redo not available" rather than crashing.
+ */
+export function readBlob(root, sha) {
+    const path = blobPathFor(root, sha);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Best-effort blob deletion. Used by the redo runner after a successful
+ * reapply so the blob does not get reused on a second redo (which would
+ * be incorrect — once redone, the next undo must capture fresh state).
+ * Missing-file errors are swallowed — the store self-heals.
+ */
+export function deleteBlob(root, sha) {
+    const path = blobPathFor(root, sha);
+    if (!existsSync(path))
+        return;
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        // Best-effort.
+    }
+}
+//# sourceMappingURL=redo-blob-store.js.map