@karmaniverous/stan-cli 0.11.0 → 0.11.1

package/dist/cli/snap-run-DIWU31M8.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+import { V as Vc, s as su, l as loadCliConfig, r as resolvePromptSource, a as sha256File, u as updateDocsMetaPrompt } from './stan.js';
+import { w as within, e as ensureDirs, A as ARCH_DIR, r as readJson, a as writeJson, S as SNAP_DIR, b as STATE_FILE, c as resolveContext, u as utcStamp } from './context-CToKAifL.js';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, copyFile, rm } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import 'node:module';
+import 'node:path';
+import 'fs-extra';
+import 'node:process';
+import 'node:url';
+import 'process';
+import 'buffer';
+import 'node:crypto';
+import 'os';
+import 'path';
+import 'util';
+import 'stream';
+import 'events';
+import 'fs';
+import 'node:os';
+import 'node:tty';
+import 'node:readline';
+import 'clipboardy';
+import 'child_process';
+
+// src/stan/snap/capture.ts
+/**
+ * Capture the current snapshot and (optionally) current archives into history,
+ * then update diff/.snap.state.json with bounded retention.
+ *
+ * - Copies <stanPath>/diff/.archive.snapshot.json to diff/snapshots/snap-<ts>.json
+ * - If present, copies <stanPath>/output/archive.tar and archive.diff.tar to diff/archives/
+ * - Pushes a new entry, clears any redos, and trims to maxUndos (oldest first),
+ *   deleting dropped files best-effort.
+ */
+const captureSnapshotAndArchives = async ({ cwd, stanPath, ts, maxUndos, }) => {
+    const diffDir = within(cwd, stanPath, 'diff');
+    const outDir = within(cwd, stanPath, 'output');
+    // ensureDirs will create as needed below
+    const statePath = within(diffDir, STATE_FILE);
+    const snapsDir = within(diffDir, SNAP_DIR);
+    const archDir = within(diffDir, ARCH_DIR);
+    await ensureDirs([diffDir, snapsDir, archDir]);
+    // Copy current snapshot body into history file
+    const currentSnapAbs = within(diffDir, '.archive.snapshot.json');
+    const snapRel = within(SNAP_DIR, `snap-${ts}.json`);
+    const snapAbs = within(diffDir, snapRel);
+    try {
+        const body = await readFile(currentSnapAbs, 'utf8');
+        await writeFile(snapAbs, body, 'utf8');
+    }
+    catch {
+        // best-effort
+    }
+    // Optionally capture current archives if present
+    let archRel;
+    let archDiffRel;
+    const outArchive = within(outDir, 'archive.tar');
+    const outDiff = within(outDir, 'archive.diff.tar');
+    try {
+        if (existsSync(outArchive)) {
+            archRel = within(ARCH_DIR, `archive-${ts}.tar`);
+            await copyFile(outArchive, within(diffDir, archRel));
+        }
+        if (existsSync(outDiff)) {
+            archDiffRel = within(ARCH_DIR, `archive-${ts}.diff.tar`);
+            await copyFile(outDiff, within(diffDir, archDiffRel));
+        }
+    }
+    catch {
+        // best-effort
+    }
+    // Load or initialize state
+    const st = (await readJson(statePath)) ?? {
+        entries: [],
+        index: -1,
+        maxUndos,
+    };
+    // Drop redos when we’re not at tip
+    if (st.index >= 0 && st.index < st.entries.length - 1) {
+        st.entries = st.entries.slice(0, st.index + 1);
+    }
+    // Push new entry and advance pointer
+    const entry = {
+        ts,
+        snapshot: snapRel,
+        archive: archRel,
+        archiveDiff: archDiffRel,
+    };
+    st.entries.push(entry);
+    st.index = st.entries.length - 1;
+    // Trim oldest beyond retention; remove dropped files best-effort
+    const maxKeep = st.maxUndos ?? maxUndos;
+    while (st.entries.length > maxKeep) {
+        const drop = st.entries.shift();
+        if (drop) {
+            try {
+                await rm(within(diffDir, drop.snapshot), { force: true });
+            }
+            catch {
+                // ignore
+            }
+            if (drop.archive) {
+                try {
+                    await rm(within(diffDir, drop.archive), { force: true });
+                }
+                catch {
+                    // ignore
+                }
+            }
+            if (drop.archiveDiff) {
+                try {
+                    await rm(within(diffDir, drop.archiveDiff), { force: true });
+                }
+                catch {
+                    // ignore
+                }
+            }
+        }
+        st.index = Math.max(0, st.entries.length - 1);
+    }
+    await writeJson(statePath, st);
+};
+
+/**
+ * Run a `git` command and capture its exit code, stdout, and stderr.
+ *
+ * Streams are buffered in memory; when `STAN_DEBUG=1`, output is mirrored
+ * to the current process.
+ *
+ * @param cwd - Working directory for the git process.
+ * @param args - Arguments to pass to `git`.
+ * @returns `{ code, stdout, stderr }` from the completed process.
+ */
+const runGit = async (cwd, args) => new Promise((resolve) => {
+    const child = spawn('git', args, {
+        cwd,
+        shell: false,
+        windowsHide: true,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    let stdout = '';
+    let stderr = '';
+    const cp = child;
+    cp.stdout?.on('data', (d) => {
+        const s = d.toString('utf8');
+        stdout += s;
+        if (process.env.STAN_DEBUG === '1')
+            process.stdout.write(s);
+    });
+    cp.stderr?.on('data', (d) => {
+        const s = d.toString('utf8');
+        stderr += s;
+        if (process.env.STAN_DEBUG === '1')
+            process.stderr.write(s);
+    });
+    child.on('close', (code) => resolve({ code: code ?? 0, stdout, stderr }));
+});
+
+// src/stan/snap/selection.ts
+// Helper to read selection context (stanPath, includes, excludes) from repo config.
+const readSelection = async (cwd) => {
+    try {
+        const cfg = await Vc(cwd);
+        return {
+            stanPath: cfg.stanPath,
+            includes: Array.isArray(cfg.includes) ? cfg.includes : [],
+            excludes: Array.isArray(cfg.excludes) ? cfg.excludes : [],
+        };
+    }
+    catch {
+        // Best-effort fallback (aligns with transitional defaults elsewhere)
+        return {
+            stanPath: '.stan',
+            includes: [],
+            excludes: [],
+        };
+    }
+};
+
+/* src/stan/snap/snap-run.ts
+ * Snapshot capture operation with optional stash.
+ */
+const handleSnap = async (opts) => {
+    const { cwd, stanPath, maxUndos } = await resolveContext(process.cwd());
+    const wantStash = Boolean(opts?.stash);
+    let attemptPop = false;
+    if (wantStash) {
+        const res = await runGit(cwd, ['stash', '-u']);
+        if (res.code === 0 && !/No local changes to save/i.test(res.stdout)) {
+            attemptPop = true;
+            console.log('stan: stash saved changes');
+        }
+        else if (res.code === 0) {
+            // Nothing to stash is a successful no-op; print a concise confirmation.
+            console.log('stan: no local changes to stash');
+        }
+        else if (res.code !== 0) {
+            console.error('stan: git stash -u failed; snapshot aborted (no changes made)');
+            // Visual separation from next prompt
+            console.log('');
+            return;
+        }
+    }
+    // Resolve selection from repo config so the snapshot and diff use the same rules
+    const { includes: cfgIncludes, excludes: cfgExcludes } = await readSelection(cwd).catch(() => ({
+        stanPath,
+        includes: [],
+        excludes: [],
+    }));
+    try {
+        await su({
+            cwd,
+            stanPath,
+            includes: cfgIncludes,
+            excludes: cfgExcludes,
+        });
+    }
+    catch (e) {
+        console.error('stan: snapshot write failed', e);
+        if (wantStash && attemptPop) {
+            const pop = await runGit(cwd, ['stash', 'pop']);
+            if (pop.code !== 0) {
+                console.error('stan: git stash pop failed');
+            }
+        }
+        // Visual separation from next prompt
+        console.log('');
+        return;
+    }
+    // Record effective prompt identity (baseline-at-snap): source/hash/path?
+    try {
+        const cli = await loadCliConfig(cwd);
+        const choice = typeof cli.cliDefaults?.run?.prompt === 'string' &&
+            cli.cliDefaults.run.prompt.trim().length
+            ? cli.cliDefaults.run.prompt.trim()
+            : 'auto';
+        const rp = resolvePromptSource(cwd, stanPath, choice);
+        // Hash the effective source bytes
+        let hash;
+        try {
+            hash = await sha256File(rp.abs);
+        }
+        catch {
+            hash = undefined;
+        }
+        const pathForMeta = rp.kind === 'path' ? rp.abs : undefined;
+        await updateDocsMetaPrompt(cwd, stanPath, {
+            source: rp.kind,
+            hash,
+            path: pathForMeta,
+        });
+    }
+    catch {
+        // best-effort; missing hash/path is acceptable
+    }
+    const ts = utcStamp();
+    await captureSnapshotAndArchives({
+        cwd,
+        stanPath,
+        ts,
+        maxUndos,
+    });
+    if (wantStash && attemptPop) {
+        const pop = await runGit(cwd, ['stash', 'pop']);
+        if (pop.code !== 0) {
+            console.error('stan: git stash pop failed');
+        }
+        else {
+            console.log('stan: stash pop restored changes');
+        }
+    }
+    console.log('stan: snapshot updated');
+    // Visual separation from next prompt
+    console.log('');
+};
+
+export { handleSnap };