@karmaniverous/stan-cli 0.12.1 → 0.12.3

package/dist/cli/stan.js

@@ -19728,6 +19728,9 @@ const printHeader = (kind, last) => {
  */
 /** Return true to proceed; false to abort. */
 const confirmLoopReversal = async () => {
+    // Tests must never block on interactive prompts.
+    if (process.env.NODE_ENV === 'test')
+        return true;
     // Non-interactive: proceed by default (CI-compatible; matches other prompts).
     const isTTY = Boolean(process.stdout.isTTY);
     if (!isTTY)
@@ -30049,23 +30052,15 @@ const resolveCorePromptPath = () => {
     catch {
         /* ignore */
     }
-    // Fallback A: resolve core's main entry, walk up to the module root "stan-core", then join dist/stan.system.md
+    // Fallback A: resolve core's entry, then use package-directory to locate its package root.
     try {
         const req = createRequire(import.meta.url);
         const mainEntry = req.resolve('@karmaniverous/stan-core');
-        let dir = path.dirname(mainEntry);
-        for (let i = 0; i < 10; i += 1) {
-            const base = path.basename(dir);
-            if (base === 'stan-core') {
-                const candidate = path.join(dir, 'dist', 'stan.system.md');
-                if (existsSync(candidate))
-                    return candidate;
-                break;
-            }
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
+        const pkgRoot = packageDirectorySync({ cwd: path.dirname(mainEntry) }) ?? null;
+        if (pkgRoot) {
+            const candidate = path.join(pkgRoot, 'dist', 'stan.system.md');
+            if (existsSync(candidate))
+                return candidate;
         }
     }
     catch {
@@ -30090,17 +30085,11 @@ const resolveCorePromptPath = () => {
 const getCliPackagedSystemPromptPath = () => {
     try {
         const here = fileURLToPath(import.meta.url);
-        let dir = path.dirname(here);
-        // Walk upward to find a "dist/stan.system.md" near the package root.
-        for (let i = 0; i < 8; i += 1) {
-            const distDir = path.join(dir, 'dist');
-            const candidate = path.join(distDir, 'stan.system.md');
+        const pkgRoot = packageDirectorySync({ cwd: path.dirname(here) }) ?? null;
+        if (pkgRoot) {
+            const candidate = path.join(pkgRoot, 'dist', 'stan.system.md');
             if (existsSync(candidate))
                 return candidate;
-            const parent = path.dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
         }
     }
     catch {
@@ -32022,27 +32011,28 @@ const isSubtreePattern = (s) => {
     const p = posix(s.trim());
     return p.endsWith('/**') || p.endsWith('/*');
 };
-/** Extract the "tail" (after last '/') from a glob (e.g., '**\/*.test.ts' -\> '*.test.ts'). */
-const globTail = (s) => {
-    const p = posix(s.trim());
-    const idx = p.lastIndexOf('/');
-    return idx >= 0 ? p.slice(idx + 1) : p;
-};
 /** Normalize subtree roots from a list of exclude patterns. */
 const collectSubtreeRoots = (patterns) => (patterns ?? [])
     .filter((p) => isSubtreePattern(p))
     .map(stripGlobTail)
     .filter((r) => r.length > 0);
-/** Collect leaf‑glob tails (e.g., '**\/*.test.ts' -\> '*.test.ts') from a list of exclude patterns. */
-const collectLeafGlobTails = (patterns) => (patterns ?? [])
-    .filter((p) => !isSubtreePattern(p))
-    .map(globTail)
-    .filter((t) => t.length > 0);
 const isUnder = (childRel, root) => {
     const c = posix(childRel);
     const r = posix(root);
     return c === r || c.startsWith(r.length ? r + '/' : '');
 };
+const toSubtreeGlob = (root) => `${posix(root)}/**`;
+const segmentUnderRoot = (root, p) => {
+    const r = posix(root);
+    const full = posix(p);
+    if (!isUnder(full, r))
+        return null;
+    const rest = full.slice(r.length).replace(/^\/+/, '');
+    if (!rest.length)
+        return null;
+    const first = rest.split('/')[0];
+    return first && first.length ? first : null;
+};
 const readFacetMeta = async (cwd, stanPath) => {
     const abs = toAbs(cwd, path.join(stanPath, 'system', 'facet.meta.json'));
     const meta = await safeReadJson(abs);
@@ -32096,14 +32086,10 @@ const computeFacetOverlay = async (input) => {
     const anchorsOverlaySet = new Set();
     // Final excludes overlay entries (subtree roots only; leaf-globs are not propagated here).
     const excludesOverlayArr = [];
-    // Track subtree-root entries for enabled-wins filtering.
-    const excludesOverlayRoots = [];
     const autosuspended = [];
     const anchorsKeptCounts = {};
     // Track per-facet inactive subtree roots for overlap-kept diagnostics.
     const inactiveEntries = [];
-    // Collect leaf‑glob tails from active facets (protected patterns).
-    const activeLeafTails = new Set();
     // Precompute active subtree roots across all facets (for tie-breakers and scoped anchors).
     const activeRoots = new Set();
     for (const name of facetNames) {
@@ -32112,15 +32098,7 @@ const computeFacetOverlay = async (input) => {
         if (isActive)
             for (const r of exRoots)
                 activeRoots.add(posix(r));
-        // Also collect leaf‑glob tails for active facets so they can be protected
-        // under inactive subtree roots (enabled‑wins across leaf‑glob vs subtree).
-        if (isActive) {
-            for (const tail of collectLeafGlobTails(meta[name].exclude))
-                activeLeafTails.add(tail);
-        }
     }
-    // Collect leaf-glob tails from inactive facets (for scoped anchors under active roots).
-    const inactiveLeafTails = new Set();
     // Always include all anchors (keep docs breadcrumbs visible even when overlay off)
     for (const name of facetNames) {
         const def = defOf(name);
@@ -32177,7 +32155,6 @@ const computeFacetOverlay = async (input) => {
             .filter(isSubtreePattern)
             .map(stripGlobTail)
             .filter(Boolean);
-        const leafGlobs = excludes.filter((p) => !isSubtreePattern(p));
         const inc = Array.isArray(def.include) ? def.include.map(posix) : [];
         // Count anchors present on disk (for metadata)
         anchorsKeptCounts[name] = inc.filter((a) => existsSync(toAbs(cwd, a))).length;
@@ -32205,75 +32182,80 @@ const computeFacetOverlay = async (input) => {
             if (!root)
                 continue;
             inactiveEntries.push({ facet: name, root });
-            excludesOverlayRoots.push(root.endsWith('/') ? root : root);
-        }
-        // Collect leaf-glob tails for scoped re-inclusions under active roots.
-        for (const g of leafGlobs) {
-            const tail = globTail(g);
-            if (tail)
-                inactiveLeafTails.add(tail);
         }
     }
-    // Subtree tie-breaker: enabled facet wins (drop inactive roots that equal/overlap with active roots).
+    // Nested structural facets: carve-out inactive roots that contain active descendant roots.
+    // - Keep exact-match "enabled wins" behavior (drop inactive root when the same root is active).
+    // - If an inactive root contains one or more active descendant subtree roots, exclude all
+    //   immediate children under the inactive root that are NOT ancestors of any active root.
+    //   This expresses "B on, rest of A off" without using anchors as filter machinery.
     const overlapKeptCounts = {};
-    if (inactiveEntries.length > 0 && activeRoots.size > 0) {
-        const act = Array.from(activeRoots);
-        const keptRoots = [];
-        const keptEntries = [];
-        for (const entry of inactiveEntries) {
-            const r = entry.root;
-            const drop = act.some((ar) => ar === r || isUnder(r, ar) || isUnder(ar, r));
-            if (!drop) {
-                keptRoots.push(r);
-                keptEntries.push(entry);
-            }
-        }
-        // Replace with filtered roots only.
-        excludesOverlayArr.length = 0;
-        excludesOverlayArr.push(...keptRoots);
-        // Count kept roots per facet
-        for (const { facet } of keptEntries) {
-            overlapKeptCounts[facet] = (overlapKeptCounts[facet] ?? 0) + 1;
-        }
-    }
-    else {
-        // No filtering occurred (no active roots or no excludes); consider all inactive entries as kept.
-        for (const { facet } of inactiveEntries) {
-            overlapKeptCounts[facet] = (overlapKeptCounts[facet] ?? 0) + 1;
-        }
-        // Append the raw subtree roots only.
-        const uniq = Array.from(new Set(excludesOverlayRoots));
-        excludesOverlayArr.length = 0;
-        excludesOverlayArr.push(...uniq);
-    }
-    // Enabled‑wins for leaf‑glob patterns: protect ACTIVE facets' leaf‑glob tails
-    // under any remaining inactive subtree roots by adding scoped anchors
-    // "<inactiveRoot>/**/<tail>" so those files remain visible.
-    if (activeLeafTails.size > 0 && excludesOverlayArr.length > 0) {
+    const activeRootsArr = Array.from(activeRoots);
+    const carveOutOrExcludeRoot = async (root) => {
+        const protectedRoots = activeRootsArr.filter((ar) => ar !== root && isUnder(ar, root));
+        if (protectedRoots.length === 0)
+            return [toSubtreeGlob(root)];
+        // Compute which immediate child entries are "keepers".
+        const keep = new Set();
+        for (const pr of protectedRoots) {
+            const seg = segmentUnderRoot(root, pr);
+            if (seg)
+                keep.add(seg);
+        }
+        // Enumerate immediate children under the inactive root and exclude everything
+        // except the keeper segments. Keep deterministic output ordering.
+        const abs = toAbs(cwd, root);
+        let dirents = null;
         try {
-            for (const root of excludesOverlayArr) {
-                for (const tail of activeLeafTails) {
-                    const scoped = posix(`${root}/**/${tail}`);
-                    anchorsOverlaySet.add(scoped);
-                }
-            }
+            dirents = (await readdir(abs, { withFileTypes: true }));
         }
         catch {
-            /* best-effort */
+            dirents = null;
         }
-    }
-    // Leaf-glob scoped re-inclusion: add anchors "<activeRoot>/**/<tail>" for every collected tail.
-    if (inactiveLeafTails.size > 0 && activeRoots.size > 0) {
-        for (const ar of activeRoots) {
-            for (const tail of inactiveLeafTails) {
-                const scoped = posix(`${ar}/**/${tail}`);
-                anchorsOverlaySet.add(scoped);
+        // If we can't enumerate, fall back to excluding the full root and
+        // anchor-rescuing the protected roots. This preserves correctness without
+        // reintroducing leaf-glob anchor tricks.
+        if (!dirents) {
+            try {
+                for (const pr of protectedRoots)
+                    anchorsOverlaySet.add(toSubtreeGlob(pr));
             }
+            catch {
+                /* best-effort */
+            }
+            return [toSubtreeGlob(root)];
+        }
+        const entries = dirents
+            .map((d) => ({ name: d.name, isDir: d.isDirectory() }))
+            .sort((a, b) => a.name.localeCompare(b.name));
+        const out = [];
+        for (const e of entries) {
+            if (keep.has(e.name))
+                continue;
+            const rel = posix(path.join(root, e.name));
+            out.push(e.isDir ? toSubtreeGlob(rel) : rel);
         }
+        return out;
+    };
+    if (inactiveEntries.length > 0) {
+        const patterns = new Set();
+        for (const entry of inactiveEntries) {
+            const r = entry.root;
+            // Enabled-wins (exact match only): if the same subtree root is active, do not apply the inactive drop.
+            if (activeRoots.has(r))
+                continue;
+            overlapKeptCounts[entry.facet] =
+                (overlapKeptCounts[entry.facet] ?? 0) + 1;
+            const ps = await carveOutOrExcludeRoot(r);
+            for (const p of ps)
+                patterns.add(posix(p));
+        }
+        excludesOverlayArr.length = 0;
+        excludesOverlayArr.push(...Array.from(patterns).sort((a, b) => a.localeCompare(b)));
     }
     // Deduplicate anchors overlay
     const anchorsOverlay = Array.from(anchorsOverlaySet);
-    // Excludes overlay contains subtree roots only (already deduped above).
+    // Excludes overlay contains engine-ready patterns (subtree globs and/or exact paths).
     return {
         enabled: true,
         excludesOverlay: excludesOverlayArr,
@@ -32285,11 +32267,6 @@ const computeFacetOverlay = async (input) => {
     };
 };
 
-const hasGlob = (s) => s.includes('*') || s.includes('?') || s.includes('[');
-const ensureSubtreeGlob = (p) => {
-    const s = p.replace(/\/+$/, '');
-    return hasGlob(s) ? s : `${s}/**`;
-};
 const toPosix = (p) => p.replace(/\\+/g, '/');
 const buildOverlayInputs = async (args) => {
     const { cwd, stanPath, enabled, activateNames, deactivateNames } = args;
@@ -32317,12 +32294,9 @@ const buildOverlayInputs = async (args) => {
         };
     }
     const shouldMap = enabled;
-    // Map overlay excludes to effective deny-list globs for the engine:
-    // - subtree roots like "docs" -> "docs/**"
-    // - existing glob patterns (contain *, ?, or [) pass through unchanged.
-    const overlayExcludesRaw = shouldMap ? overlay.excludesOverlay : [];
-    const overlayExcludes = overlayExcludesRaw.map(ensureSubtreeGlob);
-    // Also include leaf-glob excludes from inactive facets (e.g., "**/*.test.ts").
+    // Overlay structural excludes are already engine-ready patterns (subtree globs and/or exact paths).
+    const overlayExcludes = shouldMap ? overlay.excludesOverlay : [];
+    // Also include leaf‑glob excludes from inactive facets (e.g., "**/*.test.ts").
     // Read facet.meta.json directly and derive leaf-globs for facets that are
     // currently inactive per overlay.effective.
     const leafGlobs = [];
@@ -32350,7 +32324,10 @@ const buildOverlayInputs = async (args) => {
     catch {
         /* best-effort only */
     }
-    const engineExcludes = Array.from(new Set([...overlayExcludes, ...leafGlobs]));
+    const engineExcludes = Array.from(new Set([
+        ...overlayExcludes.map(toPosix),
+        ...leafGlobs.map(toPosix),
+    ]));
     // Facet view lines for plan (same as before; keep compact)
     const overlayPlan = (() => {
         const lines = [];
@@ -32825,6 +32802,51 @@ const writeJson = async (p, v) => {
  */
 const clamp = (n, lo, hi) => Math.max(lo, Math.min(hi, n));
 const statePath = (cwd, stanPath) => path.join(cwd, stanPath, 'diff', STATE_FILE);
+const snapshotBaselinePath = (diffDirAbs) => path.join(diffDirAbs, '.archive.snapshot.json');
+const findConfigPathUpwards = (start) => {
+    const names = ['stan.config.yml', 'stan.config.yaml', 'stan.config.json'];
+    let cur = start;
+    for (;;) {
+        for (const n of names) {
+            try {
+                const p = path.join(cur, n);
+                if (existsSync(p))
+                    return p;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        const parent = path.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return null;
+};
+const readStanPathFromConfig = (cfgPath) => {
+    try {
+        const raw = readFileSync(cfgPath, 'utf8');
+        const rootUnknown = parseText(cfgPath, raw);
+        if (!rootUnknown || typeof rootUnknown !== 'object')
+            return null;
+        const root = rootUnknown;
+        const core = root['stan-core'];
+        if (core && typeof core === 'object') {
+            const sp = core.stanPath;
+            if (typeof sp === 'string' && sp.trim().length > 0)
+                return sp.trim();
+        }
+        // Legacy fallback (ensure tests/older configs still work)
+        const legacy = root.stanPath;
+        if (typeof legacy === 'string' && legacy.trim().length > 0)
+            return legacy.trim();
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+};
 const readSnapState = async (p) => {
     return (await readJson(p)) ?? null;
 };
@@ -32836,48 +32858,107 @@ const writeSnapState = async (p, s) => {
 const setIndexSnap = async (p, rawIndex) => {
     const cur = await readSnapState(p);
     if (!cur)
-        return;
+        return null;
     const n = Number.parseInt(rawIndex, 10);
     const max = cur.entries.length > 0 ? cur.entries.length - 1 : 0;
     const next = Number.isFinite(n) ? clamp(n, 0, max) : cur.index;
     await writeSnapState(p, { ...cur, index: next });
+    return (await readSnapState(p)) ?? null;
 };
 const undoSnap = async (p) => {
     const cur = await readSnapState(p);
     if (!cur)
-        return;
+        return null;
     const max = cur.entries.length > 0 ? cur.entries.length - 1 : 0;
     const next = clamp(cur.index - 1, 0, max);
     await writeSnapState(p, { ...cur, index: next });
+    return (await readSnapState(p)) ?? null;
 };
 const redoSnap = async (p) => {
     const cur = await readSnapState(p);
     if (!cur)
-        return;
+        return null;
     const max = cur.entries.length > 0 ? cur.entries.length - 1 : 0;
     const next = clamp(cur.index + 1, 0, max);
     await writeSnapState(p, { ...cur, index: next });
+    return (await readSnapState(p)) ?? null;
+};
+/**
+ * Restore the active diff snapshot baseline (<stanPath>/diff/.archive.snapshot.json)
+ * from the currently selected snap entry in <stanPath>/diff/.snap.state.json.
+ *
+ * This is the missing link that makes undo/redo/set affect `stan run` diffs.
+ */
+const restoreSnapshotBaseline = async (snapStateAbs, st) => {
+    // Guard: nothing to restore
+    const entry = st.entries[st.index];
+    if (!entry.snapshot)
+        return { restored: false };
+    const diffDirAbs = path.dirname(snapStateAbs);
+    const src = path.join(diffDirAbs, entry.snapshot);
+    const dest = snapshotBaselinePath(diffDirAbs);
+    try {
+        if (!existsSync(src))
+            return { restored: false, ts: entry.ts };
+    }
+    catch {
+        return { restored: false, ts: entry.ts };
+    }
+    try {
+        await copyFile(src, dest);
+        return { restored: true, ts: entry.ts };
+    }
+    catch {
+        return { restored: false, ts: entry.ts };
+    }
 };
 /**
  * CLI handlers (snap subcommands)
  * - resolve stanPath robustly
  * - operate on the history file under <stanPath>/diff/.snap.state.json
  */
-const resolveHistoryPath = () => {
+const resolveRepoRoot = () => {
     const cwd = process.cwd();
+    // Prefer core's resolver, but it may return null without throwing.
+    // Fall back to a direct upward scan for repos/tests without package.json.
+    const cfgPath = (() => {
+        try {
+            return ke(cwd);
+        }
+        catch {
+            return null;
+        }
+    })();
+    const chosen = cfgPath ?? findConfigPathUpwards(cwd);
+    return chosen ? path.dirname(chosen) : cwd;
+};
+const resolveHistoryPath = () => {
+    const repoRoot = resolveRepoRoot();
     // Prefer the configured stanPath; probe legacy/common names for existing files.
     let configured = '.stan';
     try {
-        configured = Wc(cwd);
+        configured = Wc(repoRoot);
     }
     catch {
-        /* keep default */
+        // Fallback: derive stanPath by parsing stan.config.* directly when core
+        // resolution cannot locate config from the current working directory.
+        const cfgPath = (() => {
+            try {
+                return ke(repoRoot);
+            }
+            catch {
+                return null;
+            }
+        })() ?? findConfigPathUpwards(repoRoot);
+        const fromCfg = cfgPath ? readStanPathFromConfig(cfgPath) : null;
+        if (fromCfg)
+            configured = fromCfg;
     }
-    // Probe order: prefer "out" first (common in tests), then configured, then legacy names.
-    const ordered = ['out', configured, 'stan', '.stan'];
+    // Probe order: configured first (real repos), then common test/legacy names.
+    const ordered = [configured, 'out', 'stan', '.stan'];
     const candidates = Array.from(new Set(ordered.filter(Boolean).map((s) => s)));
     for (const sp of candidates) {
-        const p = statePath(cwd, sp);
+        const p = statePath(repoRoot, sp);
         try {
             if (existsSync(p))
                 return p;
@@ -32887,12 +32968,22 @@ const resolveHistoryPath = () => {
         }
     }
     // None exist yet: select the configured workspace path.
-    return statePath(cwd, configured);
+    return statePath(repoRoot, configured);
+};
+const printMove = (action, st, restore) => {
+    const base = `stan: snap history: ${action} -> index ${st.index.toString()} of ${st.entries.length.toString()}`;
+    const ts = restore.ts ? ` (ts ${restore.ts})` : '';
+    const note = restore.restored ? '' : ' (baseline not restored)';
+    console.log(`${base}${ts}${note}`);
 };
 const handleUndo = async () => {
     try {
         const p = resolveHistoryPath();
-        await undoSnap(p);
+        const st = await undoSnap(p);
+        if (!st)
+            return;
+        const restore = await restoreSnapshotBaseline(p, st);
+        printMove('undo', st, restore);
     }
     catch {
         /* best‑effort */
@@ -32901,7 +32992,11 @@ const handleUndo = async () => {
 const handleRedo = async () => {
     try {
         const p = resolveHistoryPath();
-        await redoSnap(p);
+        const st = await redoSnap(p);
+        if (!st)
+            return;
+        const restore = await restoreSnapshotBaseline(p, st);
+        printMove('redo', st, restore);
     }
     catch {
         /* best‑effort */
@@ -32910,7 +33005,11 @@ const handleRedo = async () => {
 const handleSet = async (indexArg) => {
     try {
         const p = resolveHistoryPath();
-        await setIndexSnap(p, indexArg);
+        const st = await setIndexSnap(p, indexArg);
+        if (!st)
+            return;
+        const restore = await restoreSnapshotBaseline(p, st);
+        printMove('set', st, restore);
     }
     catch {
         /* best‑effort */