@karmaniverous/stan-cli 0.11.0 → 0.11.1

package/dist/cli/context-CToKAifL.js

@@ -0,0 +1,308 @@
+#!/usr/bin/env node
+import { writeFile, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { ensureDir } from 'fs-extra';
+import { b as resolveNamedOrDefaultFunction, D as DBG_SCOPE_SNAP_CONTEXT_LEGACY, l as loadCliConfig } from './stan.js';
+
+/**
+ * UTC timestamp in YYYYMMDD-HHMMSS for filenames and logs.
+ */
+function utcStamp() {
+    const d = new Date();
+    const pad = (n) => n.toString().padStart(2, '0');
+    return `${d.getUTCFullYear()}${pad(d.getUTCMonth() + 1)}${pad(d.getUTCDate())}-${pad(d.getUTCHours())}${pad(d.getUTCMinutes())}${pad(d.getUTCSeconds())}`;
+}
+/**
+ * Convert a UTC stamp (YYYYMMDD-HHMMSS) to a local time string.
+ * Falls back to the original stamp if parsing fails.
+ *
+ * @param ts - UTC stamp in the form YYYYMMDD-HHMMSS.
+ * @returns Local time string "YYYY-MM-DD HH:MM:SS", or the original input if parsing fails.
+ */
+function formatUtcStampLocal(ts) {
+    const m = ts.match(/^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})(\d{2})$/);
+    if (!m)
+        return ts;
+    const [, y, mo, d, h, mi, s] = m.map((x) => Number.parseInt(x ?? '', 10));
+    const dt = new Date(Date.UTC(y, mo - 1, d, h, mi, s));
+    // Fixed-width local: YYYY-MM-DD HH:MM:SS
+    const pad = (n) => n.toString().padStart(2, '0');
+    const yyyy = dt.getFullYear();
+    const MM = pad(dt.getMonth() + 1);
+    const DD = pad(dt.getDate());
+    const HH = pad(dt.getHours());
+    const MMi = pad(dt.getMinutes());
+    const SS = pad(dt.getSeconds());
+    return `${yyyy}-${MM}-${DD} ${HH}:${MMi}:${SS}`;
+}
+
+const STATE_FILE = '.snap.state.json';
+const SNAP_DIR = 'snapshots';
+const ARCH_DIR = 'archives';
+const within = (...parts) => path.join(...parts);
+/**
+ * Ensure all provided directories exist (best‑effort).
+ *
+ * @param paths - Absolute directory paths to create (recursively).
+ * @returns A promise that resolves when creation attempts finish.
+ */
+const ensureDirs = async (paths) => {
+    await Promise.all(paths.map((p) => ensureDir(p)));
+};
+/**
+ * Read and parse a JSON file, returning `null` on failure.
+ *
+ * @param p - Absolute file path.
+ * @returns Parsed value or `null` if the file is missing or invalid.
+ */
+const readJson = async (p) => {
+    try {
+        const raw = await readFile(p, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Write a JSON value to a file with 2‑space indentation.
+ *
+ * @param p - Absolute destination path.
+ * @param v - Value to serialize.
+ */
+const writeJson = async (p, v) => {
+    await writeFile(p, JSON.stringify(v, null, 2), 'utf8');
+};
+
+/* src/stan/snap/context.ts
+ * Resolve execution context for snap commands (cwd, stanPath, maxUndos).
+ */
+/**
+ * Resolve the effective execution context for snapshot operations.
+ * Starting from `cwd0`, locates the nearest `stan.config.*` and returns:
+ * - `cwd`: the directory containing that config (or `cwd0` if none found),
+ * - `stanPath`: configured workspace folder (defaults to ".stan"),
+ * - `maxUndos`: normalized retention for snapshot history (default 10).
+ *
+ * @param cwd0 - Directory to start searching from.
+ * @returns Resolved `{ cwd, stanPath, maxUndos }`.
+ */
+async function resolveContext(cwd0) {
+    let cwd = cwd0;
+    let resolveStanPathSyncResolved = null;
+    try {
+        const coreMod = (await import('./stan.js').then(function (n) { return n.j; }));
+        const findConfigPathSyncResolved = resolveNamedOrDefaultFunction(coreMod, (m) => m.findConfigPathSync, (m) => m.default?.findConfigPathSync, 'findConfigPathSync');
+        const cfgPath = findConfigPathSyncResolved(cwd0);
+        cwd = cfgPath ? path.dirname(cfgPath) : cwd0;
+        // Keep a resolved handle for fallback stanPath derivation
+        resolveStanPathSyncResolved =
+            resolveNamedOrDefaultFunction(coreMod, (m) => m.resolveStanPathSync, (m) => m.default?.resolveStanPathSync, 'resolveStanPathSync');
+    }
+    catch {
+        // best‑effort; keep cwd=cwd0 and derive stanPath in the general fallback below
+        resolveStanPathSyncResolved = null;
+    }
+    // Engine context (namespaced or legacy), resolved lazily to avoid SSR/ESM
+    // evaluation-order hazards during module import.
+    let engine;
+    try {
+        const effModUnknown = (await import('./effective-CXoq4vkL.js'));
+        // Decide if we should print a single success trace when STAN_DEBUG=1.
+        const debugOn = () => process.env.STAN_DEBUG === '1';
+        const debugTrace = (kind) => {
+            if (!debugOn())
+                return;
+            try {
+                // concise, single-line marker for CI logs
+                console.error(`stan: debug: snap.context: candidate=${kind}`);
+            }
+            catch {
+                /* ignore */
+            }
+        };
+        // Candidate caller: try multiple signatures and short-circuit on first valid config.
+        const tryCall = async (fnMaybe, kind) => {
+            if (typeof fnMaybe !== 'function')
+                return null;
+            const invoke = async (...args) => {
+                try {
+                    const out = await fnMaybe(...args);
+                    if (out &&
+                        typeof out === 'object' &&
+                        typeof out.stanPath === 'string') {
+                        return out;
+                    }
+                }
+                catch {
+                    /* try next signature */
+                }
+                return null;
+            };
+            // Prefer 2+ arity with scope when declared suggests it.
+            const declared = fnMaybe.length;
+            if (typeof declared === 'number' && declared >= 2) {
+                const a2 = await invoke(cwd, DBG_SCOPE_SNAP_CONTEXT_LEGACY);
+                if (a2) {
+                    debugTrace(kind);
+                    return a2;
+                }
+            }
+            // Always try (cwd)
+            const a1 = await invoke(cwd);
+            if (a1) {
+                debugTrace(kind);
+                return a1;
+            }
+            // Finally, no-arg call
+            const a0 = await invoke();
+            if (a0) {
+                debugTrace(kind);
+                return a0;
+            }
+            return null;
+        };
+        // Build ordered candidates (short‑circuit on first success).
+        const mod = effModUnknown;
+        // Immediate fast path: function-as-default — call directly before building the list
+        try {
+            const dAny = mod.default;
+            if (typeof dAny === 'function') {
+                const fast = await tryCall(dAny, 'default-fn');
+                if (fast) {
+                    engine = fast;
+                }
+            }
+        }
+        catch {
+            /* best-effort */
+        }
+        const candidates = [];
+        if (!engine) {
+            // Prefer default‑only shapes first (matches common test/mock shapes):
+            // 1) function‑as‑default (still include in list for completeness)
+            const dAny = mod.default;
+            if (typeof dAny === 'function')
+                candidates.push({ fn: dAny, kind: 'default-fn' });
+            // 2) default.resolveEffectiveEngineConfig
+            const dObj = dAny && typeof dAny === 'object'
+                ? dAny
+                : undefined;
+            if (dObj && typeof dObj.resolveEffectiveEngineConfig === 'function') {
+                candidates.push({
+                    fn: dObj.resolveEffectiveEngineConfig,
+                    kind: 'default.resolve',
+                });
+            }
+            // 3) named export
+            if (typeof mod.resolveEffectiveEngineConfig === 'function') {
+                candidates.push({
+                    fn: mod.resolveEffectiveEngineConfig,
+                    kind: 'named',
+                });
+            }
+            // 4) nested default.default function (rare)
+            if (dObj && typeof dObj.default === 'function') {
+                candidates.push({ fn: dObj.default, kind: 'default.default-fn' });
+            }
+            // 5) module‑as‑function (edge mocks)
+            if (typeof mod === 'function') {
+                candidates.push({
+                    fn: mod,
+                    kind: 'module-fn',
+                });
+            }
+            // Also scan the immediate default object for any function-valued properties.
+            // This catches odd default-only mock shapes without waiting for the deeper walk.
+            if (dObj && typeof dObj === 'object') {
+                try {
+                    for (const [, v] of Object.entries(dObj)) {
+                        if (typeof v === 'function') {
+                            // Avoid duplicate candidates (simple identity/label guard)
+                            if (!candidates.some((c) => c.fn === v)) {
+                                candidates.push({ fn: v, kind: 'default.obj-fn' });
+                            }
+                        }
+                    }
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            // Try in order
+            for (const c of candidates) {
+                const out = await tryCall(c.fn, c.kind);
+                if (out) {
+                    engine = out;
+                    break;
+                }
+            }
+            // As a last‑resort, walk nested defaults a couple of levels to catch exotic shapes.
+            if (!engine) {
+                const seen = new Set();
+                const walk = (obj, depth = 0) => {
+                    if (!obj || seen.has(obj) || depth > 3)
+                        return;
+                    seen.add(obj);
+                    if (typeof obj === 'function')
+                        candidates.push({
+                            fn: obj,
+                            kind: 'nested.fn',
+                        });
+                    if (typeof obj !== 'object' && typeof obj !== 'function')
+                        return;
+                    const o = obj;
+                    if (typeof o.resolveEffectiveEngineConfig === 'function')
+                        candidates.push({
+                            fn: o.resolveEffectiveEngineConfig,
+                            kind: 'nested.resolve',
+                        });
+                    if ('default' in o)
+                        walk(o.default, depth + 1);
+                };
+                walk(mod);
+                for (const c of candidates) {
+                    const out = await tryCall(c.fn ?? c, c.kind ?? 'nested-fn');
+                    if (out) {
+                        engine = out;
+                        break;
+                    }
+                }
+                if (!engine)
+                    throw new Error('resolveEffectiveEngineConfig not found');
+            }
+        }
+    }
+    catch {
+        // Minimal, safe fallback: derive stanPath only. This preserves snap
+        // behavior even when the effective-config module cannot be resolved
+        // (e.g., SSR/mock edge cases). Downstream consumers treat includes/
+        // excludes as optional and default to [].
+        let stanPath = '.stan';
+        try {
+            stanPath = resolveStanPathSyncResolved
+                ? resolveStanPathSyncResolved(cwd)
+                : stanPath;
+        }
+        catch {
+            /* keep default */
+        }
+        engine = { stanPath };
+    }
+    // CLI config for snap retention
+    let maxUndos;
+    try {
+        const cli = await loadCliConfig(cwd);
+        maxUndos = cli.maxUndos;
+    }
+    catch {
+        /* ignore */
+    }
+    return {
+        cwd,
+        stanPath: engine.stanPath,
+        maxUndos: maxUndos ?? 10,
+    };
+}
+
+export { ARCH_DIR as A, SNAP_DIR as S, writeJson as a, STATE_FILE as b, resolveContext as c, ensureDirs as e, formatUtcStampLocal as f, readJson as r, utcStamp as u, within as w };

package/dist/cli/effective-CXoq4vkL.js

@@ -0,0 +1,149 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { c as DBG_SCOPE_EFFECTIVE_ENGINE_LEGACY, V as Vc, $ as $e, p as parseText, Y as Yc, w as we, d as debugFallback, e as DBG_SCOPE_EFFECTIVE_STANPATH_FALLBACK } from './stan.js';
+import 'node:module';
+import 'node:fs';
+import 'node:path';
+import 'fs-extra';
+import 'node:process';
+import 'node:url';
+import 'process';
+import 'buffer';
+import 'node:crypto';
+import 'node:child_process';
+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/runner/config/effective.ts
+// Resolve effective engine ContextConfig (stanPath, includes, excludes, imports),
+// with a transitional legacy extractor. Callers pass a debug scope label so
+// debugFallback messages remain stable for existing tests.
+const isObj = (v) => v !== null && typeof v === 'object';
+const toStringArray = (v) => Array.isArray(v) ? v.filter((x) => typeof x === 'string') : [];
+const normalizeImports = (raw) => {
+    if (!isObj(raw))
+        return undefined;
+    const out = {};
+    for (const [k, v] of Object.entries(raw)) {
+        if (typeof k !== 'string')
+            continue;
+        if (Array.isArray(v)) {
+            const arr = v.filter((x) => typeof x === 'string');
+            if (arr.length)
+                out[k] = arr;
+        }
+        else if (typeof v === 'string' && v.trim().length) {
+            out[k] = [v];
+        }
+    }
+    return Object.keys(out).length ? out : undefined;
+};
+/** Phase‑2: accept legacy engine shape only when explicitly enabled by env. */
+const legacyAccepted = () => {
+    try {
+        const v = String(process.env.STAN_ACCEPT_LEGACY ?? '')
+            .trim()
+            .toLowerCase();
+        return v === '1' || v === 'true';
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Resolve effective engine ContextConfig with a legacy extractor.
+ *
+ * @param cwd - Repo root (or descendant). The nearest config is used.
+ * @param debugScope - Label for debugFallback when synthesizing from legacy root keys.
+ */
+async function resolveEffectiveEngineConfig(cwd, debugScope = DBG_SCOPE_EFFECTIVE_ENGINE_LEGACY) {
+    // Happy path — namespaced engine loader
+    try {
+        return await Vc(cwd);
+    }
+    catch {
+        // continue to fallback
+    }
+    const p = $e(cwd);
+    if (p) {
+        try {
+            const raw = await readFile(p, 'utf8');
+            const rootUnknown = parseText(p, raw);
+            const root = isObj(rootUnknown) ? rootUnknown : {};
+            const stanCore = isObj(root['stan-core']) ? root['stan-core'] : null;
+            if (stanCore) {
+                // Minimal fallback when loader failed but stan-core node exists:
+                // prefer stan-core.stanPath; otherwise resolve or default.
+                const sp = stanCore['stanPath'];
+                const stanPath = typeof sp === 'string' && sp.trim().length
+                    ? sp
+                    : (() => {
+                        try {
+                            return Yc(cwd);
+                        }
+                        catch {
+                            return we;
+                        }
+                    })();
+                return { stanPath };
+            }
+            // Phase‑2 gate: config file exists but top‑level "stan-core" is missing.
+            // Accept legacy only when env allows; otherwise fail early with clear guidance.
+            if (!legacyAccepted()) {
+                const rel = p.replace(/\\/g, '/');
+                throw new Error([
+                    `stan: legacy engine configuration detected in ${rel} (missing top-level "stan-core").`,
+                    `Run "stan init" to migrate your config,`,
+                    `or set STAN_ACCEPT_LEGACY=1 to temporarily accept legacy keys during the transition.`,
+                ].join(' '));
+            }
+            // Legacy root keys extractor (transitional)
+            const stanPathRaw = root['stanPath'];
+            const stanPath = typeof stanPathRaw === 'string' && stanPathRaw.trim().length
+                ? stanPathRaw
+                : (() => {
+                    try {
+                        return Yc(cwd);
+                    }
+                    catch {
+                        return we;
+                    }
+                })();
+            const includes = toStringArray(root['includes']);
+            const excludes = toStringArray(root['excludes']);
+            const imports = normalizeImports(root['imports']);
+            debugFallback(debugScope, `synthesized engine config from legacy root keys in ${p.replace(/\\/g, '/')}`);
+            return { stanPath, includes, excludes, imports };
+        }
+        catch {
+            // fall through to default
+        }
+    }
+    // No config file found or parse error — default stanPath
+    let stanPathFallback = we;
+    try {
+        stanPathFallback = Yc(cwd);
+    }
+    catch {
+        /* ignore */
+    }
+    try {
+        // Concise, opt-in notice for fallback path resolution
+        debugFallback(DBG_SCOPE_EFFECTIVE_STANPATH_FALLBACK, `using fallback stanPath "${stanPathFallback}" (no config found or parse failed)`);
+    }
+    catch {
+        /* ignore */
+    }
+    return { stanPath: stanPathFallback };
+}
+
+export { resolveEffectiveEngineConfig };

package/dist/cli/history-9hg6BFgc.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { c as resolveContext, a as writeJson, f as formatUtcStampLocal, w as within, r as readJson, b as STATE_FILE } from './context-CToKAifL.js';
+import 'fs-extra';
+import './stan.js';
+import 'node:module';
+import 'node:fs';
+import 'node:process';
+import 'node:url';
+import 'process';
+import 'buffer';
+import 'node:crypto';
+import 'node:child_process';
+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/history.ts
+ * Snapshot history operations: undo, redo, set, info.
+ * Keeps the CLI-visible API compatible with previous handlers.
+ */
+const getStatePaths = (cwd, stanPath) => {
+    const diffDir = path.join(cwd, stanPath, 'diff');
+    const statePath = within(diffDir, STATE_FILE);
+    const snapPath = within(diffDir, '.archive.snapshot.json');
+    return { diffDir, statePath, snapPath };
+};
+/** Restore the snapshot for a target index and update the in-memory state. */
+const restoreEntryAt = async (st, nextIndex, diffDir, snapPath) => {
+    if (nextIndex < 0 || nextIndex >= st.entries.length)
+        return null;
+    const entry = st.entries[nextIndex];
+    const snapAbs = within(diffDir, entry.snapshot);
+    const body = await readFile(snapAbs, 'utf8');
+    await writeFile(snapPath, body, 'utf8');
+    st.index = nextIndex;
+    return { st, ts: entry.ts };
+};
+const ensureState = async (statePath, maxUndos) => {
+    const st = (await readJson(statePath)) ?? {
+        entries: [],
+        index: -1,
+        maxUndos,
+    };
+    // normalize maxUndos if missing
+    if (!st.maxUndos)
+        st.maxUndos = maxUndos;
+    return st;
+};
+/**
+ * Revert to the previous snapshot in the history stack.
+ * Restores `.archive.snapshot.json`, updates the state file, and logs a summary.
+ *
+ * @returns A promise that resolves when the operation completes.
+ */
+const handleUndo = async () => {
+    const { cwd, stanPath, maxUndos } = await resolveContext(process.cwd());
+    const { diffDir, statePath, snapPath } = getStatePaths(cwd, stanPath);
+    const st = await ensureState(statePath, maxUndos);
+    if (st.entries.length === 0 || st.index <= 0) {
+        console.log('stan: nothing to undo');
+        return;
+    }
+    const next = await restoreEntryAt(st, st.index - 1, diffDir, snapPath).catch((err) => {
+        console.error('stan: failed to restore snapshot', err);
+        return null;
+    });
+    if (!next)
+        return;
+    await writeJson(statePath, st);
+    const undos = st.index;
+    const redos = st.entries.length - 1 - st.index;
+    console.log(`stan: undo -> ${next.ts} (undos left ${undos.toString()}, redos left ${redos.toString()})`);
+};
+/**
+ * Advance to the next snapshot in the history stack.
+ * Restores `.archive.snapshot.json`, updates the state file, and logs a summary.
+ *
+ * @returns A promise that resolves when the operation completes.
+ */
+const handleRedo = async () => {
+    const { cwd, stanPath, maxUndos } = await resolveContext(process.cwd());
+    const { diffDir, statePath, snapPath } = getStatePaths(cwd, stanPath);
+    const st = await ensureState(statePath, maxUndos);
+    if (st.entries.length === 0 || st.index >= st.entries.length - 1) {
+        console.log('stan: nothing to redo');
+        return;
+    }
+    const next = await restoreEntryAt(st, st.index + 1, diffDir, snapPath).catch((err) => {
+        console.error('stan: failed to restore snapshot', err);
+        return null;
+    });
+    if (!next)
+        return;
+    await writeJson(statePath, st);
+    const undos = st.index;
+    const redos = st.entries.length - 1 - st.index;
+    console.log(`stan: redo -> ${next.ts} (undos left ${undos.toString()}, redos left ${redos.toString()})`);
+};
+/**
+ * Activate a specific snapshot by index and make it current.
+ * Overwrites the active `.archive.snapshot.json` with the selected entry
+ * and updates the state file.
+ *
+ * @param indexArg - Index string (0‑based) to select; must be within range.
+ * @returns A promise that resolves when the operation completes.
+ */
+const handleSet = async (indexArg) => {
+    const idx = Number.parseInt(indexArg, 10);
+    if (!Number.isFinite(idx) || idx < 0) {
+        console.error('stan: invalid index');
+        return;
+    }
+    const { cwd, stanPath, maxUndos } = await resolveContext(process.cwd());
+    const { diffDir, statePath, snapPath } = getStatePaths(cwd, stanPath);
+    const st = await ensureState(statePath, maxUndos);
+    if (idx < 0 || idx >= st.entries.length) {
+        console.error('stan: index out of range');
+        return;
+    }
+    const next = await restoreEntryAt(st, idx, diffDir, snapPath).catch(() => null);
+    if (!next)
+        return;
+    await writeJson(statePath, st);
+    const undos = st.index;
+    const redos = st.entries.length - 1 - st.index;
+    console.log(`stan: set -> ${next.ts} (undos left ${undos.toString()}, redos left ${redos.toString()})`);
+};
+/**
+ * Print a summary of the snapshot stack with the current index highlighted.
+ *
+ * @returns A promise that resolves when printing is complete.
+ */
+const handleInfo = async () => {
+    const { cwd, stanPath, maxUndos } = await resolveContext(process.cwd());
+    const { statePath } = getStatePaths(cwd, stanPath);
+    const st = await ensureState(statePath, maxUndos);
+    const undos = Math.max(0, st.index);
+    const redos = st.entries.length > 0 ? Math.max(0, st.entries.length - 1 - st.index) : 0;
+    console.log('stan: snap stack (newest → oldest)');
+    if (st.entries.length === 0) {
+        console.log('  (empty)');
+    }
+    else {
+        st.entries
+            .map((e, i) => ({ e, i }))
+            .reverse()
+            .forEach(({ e, i }) => {
+            const mark = i === st.index ? '*' : ' ';
+            const hasArch = Boolean(e.archive);
+            const hasDiff = Boolean(e.archiveDiff);
+            const local = formatUtcStampLocal(e.ts);
+            const file = path.basename(e.snapshot);
+            console.log(`  ${mark} [${i.toString()}] ${local}  file: ${file}  archive: ${hasArch ? 'yes' : 'no'}  diff: ${hasDiff ? 'yes' : 'no'}`);
+        });
+    }
+    console.log(`  current index: ${st.index.toString()}  undos left: ${undos.toString()}  redos left: ${redos.toString()}`);
+};
+
+export { handleInfo, handleRedo, handleSet, handleUndo };

package/dist/cli/{index-CoyGQCX9.js → index-TG0UHkTg.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import * as readline$1 from 'node:readline';
 import readline__default from 'node:readline';
-import { g as getDefaultExportFromCjs, r as requireIsFullwidthCodePoint, a as requireEmojiRegex, b as requireColorConvert, o as onExit } from './stan.js';
+import { g as getDefaultExportFromCjs, f as requireIsFullwidthCodePoint, h as requireEmojiRegex, i as requireColorConvert, o as onExit } from './stan.js';
 import R from 'stream';
 import { createRequire } from 'node:module';
 import process$1 from 'node:process';