@karmaniverous/stan-cli 0.12.0 → 0.12.1

package/dist/cli/stan.js

@@ -18664,16 +18664,60 @@ const readExistingConfig = async (existingPath) => {
     }
 };
 
+// src/runner/selection/implicit-imports.ts
+/**
+ * Implicit selection helpers for STAN's staged imports.
+ *
+ * Policy:
+ * - <stanPath>/imports/ is gitignored by default (stan init).
+ * - The CLI must still include <stanPath>/imports/** automatically in:
+ *   - snapshot baselines (stan init / stan snap),
+ *   - archive creation (full + diff),
+ *   so that changes to staged imports show up in archive.diff.tar without
+ *   requiring users to declare includes in config.
+ *
+ * Option A semantics:
+ * - Implemented as an additive include pattern.
+ * - Users can still opt out by explicitly excluding <stanPath>/imports/**.
+ */
+const posix$1 = (p) => p.replace(/\\+/g, '/');
+const normalizeStanPath = (stanPath) => {
+    const raw = typeof stanPath === 'string' ? stanPath.trim() : '';
+    const cleaned = posix$1(raw).replace(/\/+$/, '');
+    if (cleaned.length > 0) {
+        return cleaned;
+    }
+    if (raw.startsWith('/')) {
+        return ''; // Handle root path
+    }
+    return '.stan'; // Default for empty/whitespace
+};
+const implicitImportsInclude = (stanPath) => {
+    const sp = normalizeStanPath(stanPath);
+    return `${sp}/imports/**`;
+};
+/**
+ * Append the implicit imports include (if missing) while preserving order.
+ */
+const withImplicitImportsInclude = (stanPath, includes) => {
+    const base = Array.isArray(includes)
+        ? includes.filter((s) => typeof s === 'string' && s.length > 0)
+        : [];
+    const pattern = implicitImportsInclude(stanPath);
+    return base.includes(pattern) ? base : [...base, pattern];
+};
+
 // src/runner/init/service/snapshot.ts
 const snapshotPath = (cwd, stanPath) => path.join(cwd, stanPath, 'diff', '.archive.snapshot.json');
 const writeSnapshot = async (cwd, stanPath, base, dryRun) => {
     const sel = resolveIncludesExcludes(base);
     if (dryRun)
         return;
+    const includes = withImplicitImportsInclude(stanPath, sel.includes);
     await tu({
         cwd,
         stanPath,
-        includes: sel.includes,
+        includes,
         excludes: sel.excludes,
     });
 };
@@ -18784,6 +18828,7 @@ const ensureStanGitignore = async (cwd, stanPath) => {
         `${rel('diff')}/`,
         `${rel('dist')}/`,
         `${rel('patch')}/`,
+        `${rel('imports')}/`,
         // System files: ephemeral state/metadata should never be committed.
         // Keep these gitignored explicitly (and add deterministically if absent).
         rel('system/facet.state.json'),
@@ -29746,6 +29791,7 @@ const archivePhase = async (args, opts) => {
     const shouldContinue = typeof opts?.shouldContinue === 'function'
         ? opts.shouldContinue
         : undefined;
+    const includes = withImplicitImportsInclude(config.stanPath, config.includes ?? []);
     if (!silent && (which === 'both' || which === 'full')) {
         console.log(`stan: start "${alert('archive')}"`);
     }
@@ -29765,7 +29811,7 @@ const archivePhase = async (args, opts) => {
             const startedFull = Date.now();
             archivePath = await ye(cwd, config.stanPath, {
                 includeOutputDir: includeOutputs,
-                includes: config.includes ?? [],
+                includes,
                 excludes: config.excludes ?? [],
                 anchors: config.anchors ?? [],
             });
@@ -29798,7 +29844,7 @@ const archivePhase = async (args, opts) => {
                 cwd,
                 stanPath: config.stanPath,
                 baseName: 'archive',
-                includes: config.includes ?? [],
+                includes,
                 excludes: config.excludes ?? [],
                 anchors: config.anchors ?? [],
                 updateSnapshot: 'createIfMissing',
@@ -33025,6 +33071,7 @@ async function handleSnap(opts) {
                 const cfg = loadConfigFn ? await loadConfigFn(cwd) : null;
                 includes = Array.isArray(cfg?.includes) ? cfg.includes : [];
                 excludes = Array.isArray(cfg?.excludes) ? cfg.excludes : [];
+                includes = withImplicitImportsInclude(stanPath, includes);
                 // Decide overlay enablement from run defaults (snap has no facet flags).
                 const eff = getRunDefaults(cwd);
                 try {