@karmaniverous/stan-cli 0.11.1 → 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-CToKAifL.js → context-D1XMoxMA.js}

@@ -1,78 +1,64 @@
 #!/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';
+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
 /**
- * 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.
+ * 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.
  *
- * @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.
+ * 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).
  *
- * @param p - Absolute file path.
- * @returns Parsed value or `null` if the file is missing or invalid.
+ * @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.
  */
-const readJson = async (p) => {
+function resolveNamedOrDefaultFunction(mod, pickNamed, pickDefault, label) {
     try {
-        const raw = await readFile(p, 'utf8');
-        return JSON.parse(raw);
+        const named = pickNamed(mod);
+        if (typeof named === 'function')
+            return named;
     }
     catch {
-        return null;
+        /* ignore pickNamed errors */
     }
-};
-/**
- * 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');
-};
+    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).
@@ -91,7 +77,7 @@ async function resolveContext(cwd0) {
     let cwd = cwd0;
     let resolveStanPathSyncResolved = null;
     try {
-        const coreMod = (await import('./stan.js').then(function (n) { return n.j; }));
+        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;
@@ -107,7 +93,7 @@ async function resolveContext(cwd0) {
     // evaluation-order hazards during module import.
     let engine;
     try {
-        const effModUnknown = (await import('./effective-CXoq4vkL.js'));
+        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) => {
@@ -305,4 +291,4 @@ async function resolveContext(cwd0) {
     };
 }
 
-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 };
+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-TG0UHkTg.js → index-Dy6XnoRx.js}

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