@karmaniverous/stan-cli 0.11.0 → 0.11.2

package/dist/cli/apply-BpKTYoHV.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { N as Nu } from './stan.js';
+import 'node:fs';
+import 'node:fs/promises';
+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:module';
+import 'node:os';
+import 'node:tty';
+import 'node:readline';
+import 'clipboardy';
+import 'child_process';
+
+/** Present for compatibility with older/mocked test shapes. */
+const buildApplyAttempts = () => {
+    return [];
+};
+/**
+ * Git-apply attempt wrapper (delegates to the engine pipeline).
+ * When mocked in tests, this function can force a failure path so the
+ * caller falls back to jsdiff.
+ */
+const runGitApply = async (args) => {
+    const { cwd, patchAbs, cleaned, stripOrder } = args;
+    const out = await Nu({
+        cwd,
+        patchAbs,
+        cleaned,
+        check: false,
+        stripOrder: Array.isArray(stripOrder) && stripOrder.length > 0 ? stripOrder : [1, 0],
+    });
+    return out.result;
+};
+
+export { buildApplyAttempts, runGitApply };

package/dist/cli/capture-qFIjLi_h.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, copyFile, rm } from 'node:fs/promises';
+import { w as within, e as ensureDirs, A as ARCH_DIR, d as readJson, f as writeJson, S as STATE_FILE, h as SNAP_DIR } from './stan.js';
+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:module';
+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;
+    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);
+};
+
+export { captureSnapshotAndArchives };

package/dist/cli/classifier-DeYwffC_-DftahF7h.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { stat, open, readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+
+const s=1048576,o=async(o,i)=>{const a=[],c=[],h=[];await Promise.all(i.map(async i=>{const l=i.replace(/\\/g,"/");const u=resolve(o,i);let p=0;try{p=(await stat(u)).size;}catch{return}let f,g=false;try{g=await(async t=>{try{const e=await open(t,"r");try{const t=Buffer.allocUnsafe(8192),{bytesRead:n}=await e.read(t,0,t.length,0);for(let e=0;e<n;e+=1)if(0===t[e])return !0;return !1}finally{await e.close().catch(()=>{});}}catch{return !1}})(u);}catch{g=false;}if(g)return void c.push({path:l,size:p});a.push(l);try{if(p<=s||p<5*s){f=(t=>{const e=t.replace(/\r\n/g,"\n");return 0===e.length?0:e.split("\n").length})(await readFile(u,"utf8"));}}catch{}(p>s||"number"==typeof f&&f>3e3)&&h.push({path:l,size:p,loc:f});}));const l=[];if(c.length>0){l.push(`Binary files excluded from archive (${c.length.toString()}):`);for(const t of c)l.push(`  - ${t.path}  (${t.size.toString()} bytes)`);l.push("");}if(h.length>0){l.push(`Large text files (included; consider excludes if unwanted) (${h.length.toString()}):`);for(const t of h){const e=[`  - ${t.path}`,`(${t.size.toString()} bytes)`];"number"==typeof t.loc&&e.push(`${t.loc.toString()} LOC`),l.push(e.join(" "));}l.push(""),l.push(`Thresholds: size > ${s.toString()} bytes or LOC > ${3e3.toString()}`);}0===l.length&&l.push("No archive warnings.");const u=l.join("\n")+(l.length?"\n":"");return {textFiles:a,excludedBinaries:c,largeText:h,warningsBody:u}};
+
+export { o as classifyForArchive };

package/dist/cli/config-fallback-S2V_I40B.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { c as readRawConfigSync, p as pickCliNode, n as normalizeScriptsNode } from './stan.js';
+import 'node:fs';
+import 'node:fs/promises';
+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:module';
+import 'node:os';
+import 'node:tty';
+import 'node:readline';
+import 'clipboardy';
+import 'child_process';
+
+// src/cli/run/config-fallback.ts
+/**
+ * SSR/mock‑robust fallbacks for reading CLI scripts and run.scripts defaults
+ * straight from stan.config.* when lazy import shapes are unavailable.
+ *
+ * Preference order (when a config is present):
+ * - namespaced:   root['stan-cli'].\{ scripts, cliDefaults.run.scripts \}
+ * - legacy root:  root.\{ scripts, cliDefaults.run.scripts \}
+ */
+const normalizeScripts = (node) => {
+    return normalizeScriptsNode(node);
+};
+const readCliScriptsFallback = (cwd) => {
+    const root = readRawConfigSync(cwd);
+    // Prefer namespaced stan-cli.scripts
+    const cliNode = pickCliNode(root);
+    if (cliNode && cliNode.scripts && typeof cliNode.scripts === 'object') {
+        return normalizeScripts(cliNode.scripts);
+    }
+    // Legacy root-level scripts
+    if (root.scripts && typeof root.scripts === 'object') {
+        return normalizeScripts(root.scripts);
+    }
+    return {};
+};
+const readRunScriptsDefaultFallback = (cwd) => {
+    const root = readRawConfigSync(cwd);
+    // Prefer namespaced stan-cli.cliDefaults.run.scripts
+    const cliNode = pickCliNode(root);
+    if (cliNode &&
+        cliNode.cliDefaults &&
+        typeof cliNode.cliDefaults === 'object') {
+        const runNode = cliNode.cliDefaults
+            .run;
+        const v = runNode?.scripts;
+        if (typeof v === 'boolean')
+            return v;
+        if (Array.isArray(v))
+            return v.filter((x) => typeof x === 'string');
+    }
+    // Legacy root-level cliDefaults.run.scripts
+    if (root.cliDefaults && typeof root.cliDefaults === 'object') {
+        const runNode = root.cliDefaults.run;
+        const v = runNode?.scripts;
+        if (typeof v === 'boolean')
+            return v;
+        if (Array.isArray(v))
+            return v.filter((x) => typeof x === 'string');
+    }
+    return undefined;
+};
+
+export { readCliScriptsFallback, readRunScriptsDefaultFallback };

package/dist/cli/context-D1XMoxMA.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+import path from 'node:path';
+import { D as DBG_SCOPE_SNAP_CONTEXT_LEGACY, l as loadCliConfig } from './stan.js';
+import 'node:fs';
+import 'node:fs/promises';
+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:module';
+import 'node:os';
+import 'node:tty';
+import 'node:readline';
+import 'clipboardy';
+import 'child_process';
+
+// src/common/interop/resolve.ts
+/**
+ * Resolve a function export from a module, preferring a named export and
+ * falling back to an identically named property on the module's default export.
+ *
+ * This helper avoids the use of `any`; callers provide the function type `F`
+ * and the pickers that extract the candidate from the module shape (typed or unknown).
+ *
+ * @typeParam F - Function type to resolve (e.g., typeof import('./mod')['foo']).
+ * @param mod - The imported module object (typed or unknown).
+ * @param pickNamed - Extractor for the named export (returns undefined when absent).
+ * @param pickDefault - Extractor for the default export's property (returns undefined when absent).
+ * @param label - Optional label for error messaging.
+ * @returns The resolved function of type F.
+ * @throws When neither the named nor the default export provides the function.
+ */
+function resolveNamedOrDefaultFunction(mod, pickNamed, pickDefault, label) {
+    try {
+        const named = pickNamed(mod);
+        if (typeof named === 'function')
+            return named;
+    }
+    catch {
+        /* ignore pickNamed errors */
+    }
+    try {
+        const viaDefault = pickDefault(mod);
+        if (typeof viaDefault === 'function')
+            return viaDefault;
+    }
+    catch {
+        /* ignore pickDefault errors */
+    }
+    const what = label && label.trim().length ? label.trim() : 'export';
+    throw new Error(`resolveNamedOrDefaultFunction: ${what} not found`);
+}
+
+/* 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.i; }));
+        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('./stan.js').then(function (n) { return n.j; }));
+        // 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 { resolveContext };

package/dist/cli/git-W31Nw3SI.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+
+/**
+ * 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 });
+    });
+});
+
+export { runGit };

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

@@ -2,7 +2,7 @@
 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 R from 'stream';
+import $ from 'stream';
 import { createRequire } from 'node:module';
 import process$1 from 'node:process';
 import { AsyncLocalStorage, AsyncResource } from 'node:async_hooks';
@@ -1404,7 +1404,7 @@ var hasRequiredLib$2;
 function requireLib$2 () {
 	if (hasRequiredLib$2) return lib$2;
 	hasRequiredLib$2 = 1;
-	const Stream = R;
+	const Stream = $;
 
 	class MuteStream extends Stream {
 	  #isTTY = null