canary-test-cli 6.6.0 → 6.7.0

package/dist/engine/core/fs-glob.js

@@ -0,0 +1,185 @@
+/**
+ * Filesystem and glob helpers shared by the migrator, the framework probes,
+ * and workspace detection.
+ *
+ * A leaf module by design: it imports nothing from `core/`, which is what lets
+ * `framework-probes` use `globFiles` without cycling back through `migrator`
+ * (#504 part 1). The glob subset mirrors `Path.glob` -- `**` matches zero or
+ * more directories, `*` matches within one segment.
+ */
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+export function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+export function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** Compile a single glob segment (with `*` -> `[^/]*`) to an anchored regex. */
+export function segGlobRegex(seg) {
+    const body = seg
+        .replace(/[.+^${}()|[\]\\?]/g, '\\$&')
+        .replace(/\*/g, '[^/]*');
+    return new RegExp(`^${body}$`);
+}
+/**
+ * Match files under *root* against a pathlib-style glob (`**` matches zero or
+ * more directories; `*` matches within a single segment). Mirrors the subset of
+ * `Path.glob` the migrator needs.
+ */
+export function globFiles(root, pattern) {
+    const segments = pattern.split('/');
+    const out = [];
+    const visit = (dir, si) => {
+        const seg = segments[si];
+        const last = si === segments.length - 1;
+        if (seg === '**') {
+            // `**` consumes zero directories -> continue at the same dir.
+            visit(dir, si + 1);
+            // `**` consumes one-or-more -> descend into each subdir, staying on `**`.
+            for (const d of subDirs(dir))
+                visit(d, si);
+            return;
+        }
+        const re = segGlobRegex(seg);
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            if (!re.test(e.name))
+                continue;
+            const full = join(dir, e.name);
+            if (last) {
+                if (e.isFile() || isFile(full))
+                    out.push(full);
+            }
+            else if (e.isDirectory()) {
+                visit(full, si + 1);
+            }
+        }
+    };
+    visit(root, 0);
+    return out;
+}
+export function subDirs(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isDirectory())
+            .map((e) => join(dir, e.name));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Directories a workspace glob must never descend into or return.
+ *
+ * `node_modules` matters twice over: a dependency ships its own
+ * `playwright.config.ts`, which would be mistaken for this repo's suite and
+ * silently suppress a scaffold the user needs -- and a `**` glob over a real
+ * monorepo would otherwise walk every installed package on disk.
+ */
+export const _WORKSPACE_SKIP_DIRS = new Set([
+    'node_modules',
+    '.git',
+    '.venv',
+    'venv',
+    'dist',
+    'build',
+    '.next',
+    '.turbo',
+    'coverage',
+    '__pycache__',
+]);
+/**
+ * Match *directories* under *root* against a workspace glob (`apps/*`).
+ *
+ * Deliberately a separate walk from `globFiles` rather than a shared one
+ * parameterised by file-vs-directory: folding the two together forced a `kind`
+ * branch through every step and pushed both the walker and its filter to
+ * cyclomatic complexity 14 (threshold 10) to save 7 lines. Two short, honest
+ * walks beat one clever one.
+ */
+export function globDirs(root, pattern) {
+    const segments = pattern.split('/').filter((s) => s !== '');
+    const out = [];
+    const walkable = (dir) => subDirs(dir).filter((d) => !_WORKSPACE_SKIP_DIRS.has(basename(d)));
+    const visit = (dir, si) => {
+        if (si === segments.length) {
+            if (dir !== root)
+                out.push(dir);
+            return;
+        }
+        const seg = segments[si];
+        if (seg === '**') {
+            visit(dir, si + 1);
+            for (const d of walkable(dir))
+                visit(d, si);
+            return;
+        }
+        const re = segGlobRegex(seg);
+        for (const d of walkable(dir)) {
+            if (re.test(basename(d)))
+                visit(d, si + 1);
+        }
+    };
+    visit(root, 0);
+    return out;
+}
+export function readTextOrNull(path) {
+    try {
+        return readFileSync(path, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Order two POSIX-style relative paths the way Python orders `Path` objects:
+ * component-wise (`PurePath.__lt__` compares the parts list), NOT as joined
+ * strings. They differ when a directory name prefixes a sibling file name and
+ * the next char sorts below '/' (0x2F) -- most commonly the '.' extension
+ * separator, e.g. `scripts/run.sh` vs `scripts.md`. A joined-string sort places
+ * `scripts.md` first ('.' 0x2E < '/' 0x2F); Python's component sort places
+ * `scripts/run.sh` first ('scripts' < 'scripts.md'). This ordering feeds the
+ * skill-dir hash, a byte-exact contract compared against Python-written
+ * .deploy-manifest.json files on the upgrade path.
+ */
+export function comparePathParts(a, b) {
+    const pa = a.split('/');
+    const pb = b.split('/');
+    const n = Math.min(pa.length, pb.length);
+    for (let i = 0; i < n; i++) {
+        if (pa[i] < pb[i])
+            return -1;
+        if (pa[i] > pb[i])
+            return 1;
+    }
+    return pa.length - pb.length;
+}
+/** Parse *text* as JSON, or null if it is absent or malformed. */
+export function parseJsonOrNull(text) {
+    if (text === null)
+        return null;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=fs-glob.js.map

package/dist/engine/core/gate-result.js

@@ -36,10 +36,33 @@ const CONTROL_CHARS = /[\u0000-\u001F\u007F]/g;
 export function skippedSuffix(skipped) {
     if (!skipped || skipped.length === 0)
         return '';
-    const names = skipped
-        .map((s) => s.name.replace(CONTROL_CHARS, ''))
-        .join(', ');
-    return ` (${skipped.length} skipped: ${names})`;
+    // #579: `reason` used to be write-only -- every caller set one and no
+    // surface ever rendered it, so a reader could see THAT a path was dropped
+    // but never WHY. Name and cause now travel together, keeping the D7
+    // contract that the path stays visible rather than collapsing into a bare
+    // count.
+    //
+    // Grouped by reason, because producers write reasons at very different
+    // grain: the guardian uses short tokens (`skipGlobs`), doctor uses whole
+    // remedy sentences. Repeating the reason per name turned one doctor line
+    // into 183 characters that said the same thing twice. Groups keep
+    // first-appearance order, so output stays deterministic.
+    //
+    // Reasons are control-char stripped for the same line-forging reason names
+    // are -- rendering the field is what made it an injection surface.
+    const groups = new Map();
+    for (const entry of skipped) {
+        const reason = entry.reason.replace(CONTROL_CHARS, '');
+        const names = groups.get(reason);
+        if (names)
+            names.push(entry.name.replace(CONTROL_CHARS, ''));
+        else
+            groups.set(reason, [entry.name.replace(CONTROL_CHARS, '')]);
+    }
+    const rendered = [...groups]
+        .map(([reason, names]) => reason ? `${names.join(', ')} [${reason}]` : names.join(', '))
+        .join('; ');
+    return ` (${skipped.length} skipped: ${rendered})`;
 }
 /**
  * The single summary-line/exit-code path for swept commands.