@opengsd/gsd-core 1.20.0 → 1.21.0

package/gsd-core/bin/lib/project-root.cjs

@@ -23,8 +23,7 @@ exports.findProjectRoot = findProjectRoot;
 exports.consentProjectRoot = consentProjectRoot;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const node_os_1 = __importDefault(require("node:os"));
-const FIND_PROJECT_ROOT_MAX_DEPTH = 10;
+const project_context_cjs_1 = require("./project-context.cjs");
 // #4894: an operator-supplied `--project-dir` IS the project root — the
 // dispatcher validates it and skips the ancestor walk-up for `cwd`, but code
 // that derives a root from a PHASE DIRECTORY (verification) never sees `cwd`.
@@ -39,235 +38,15 @@ function setExplicitProjectRoot(root) {
 function resolveProjectRoot(startDir) {
     return explicitProjectRoot ?? findProjectRoot(startDir);
 }
+/**
+ * #6043 (ADR-4908): the ancestor walk moved verbatim to `project-context.cts`
+ * (`walkUpForPlanning`), which the resolver also owns. This stays a one-line
+ * delegate for its remaining callers (init, state, consentProjectRoot, the
+ * gsd-tools skew check, hooks/lib/isolation-sentinel.js); Phase 2 migrates them.
+ * It never spawns git.
+ */
 function findProjectRoot(startDir) {
-    let resolvedStart;
-    try {
-        resolvedStart = node_path_1.default.resolve(startDir);
-    }
-    catch {
-        return startDir;
-    }
-    const fsRoot = node_path_1.default.parse(resolvedStart).root;
-    const home = node_os_1.default.homedir();
-    // If startDir already contains .planning/, it IS the project root.
-    try {
-        const ownPlanningDir = resolvedStart + node_path_1.default.sep + '.planning';
-        if (node_fs_1.default.existsSync(ownPlanningDir) && node_fs_1.default.statSync(ownPlanningDir).isDirectory()) {
-            return startDir;
-        }
-    }
-    catch {
-        // fall through
-    }
-    // A `.planning` that is itself a symlink is a deliberate hop into a separate
-    // tree (the documented "keep planning content out of the tracked repo"
-    // convention: `.planning -> ~/.gsd-external-planning/<project>/`, its own git
-    // repo). `fs.existsSync(d + '/.git')` DEREFERENCES `d`, so at `d ===
-    // <the .planning symlink path>` it finds the EXTERNAL store's `.git`, and
-    // both isInsideGitRepo/nearestGitRoot misread it as a crossed nested-child-
-    // repo boundary (#2843's guard). `fs.lstatSync` does not dereference its
-    // final path component, so it answers "is `d` ITSELF a symlink" (#4815).
-    //
-    // Deliberately scoped to a symlink named `.planning`, NOT any symlinked
-    // directory: a nested child repo reached through some other symlinked
-    // ancestor is still a real repo boundary, and skipping it would reopen
-    // #2843 through a different trigger.
-    function isSymlinkedPlanningDir(d) {
-        if (node_path_1.default.basename(d) !== '.planning')
-            return false;
-        try {
-            return node_fs_1.default.lstatSync(d).isSymbolicLink();
-        }
-        catch {
-            return false;
-        }
-    }
-    // Walk upward, mirroring isInsideGitRepo from the CJS reference.
-    function isInsideGitRepo(candidateParent) {
-        let d = resolvedStart;
-        while (d !== fsRoot) {
-            try {
-                if (!isSymlinkedPlanningDir(d) && node_fs_1.default.existsSync(d + node_path_1.default.sep + '.git'))
-                    return true;
-            }
-            catch {
-                // ignore
-            }
-            if (d === candidateParent)
-                break;
-            const next = node_path_1.default.dirname(d);
-            if (next === d)
-                break;
-            d = next;
-        }
-        return false;
-    }
-    // #2843: nearest ancestor (including `from` itself) that contains a `.git`,
-    // bounded by `upTo` (exclusive). Returns the git-repo root, or null if none
-    // exists before `upTo` / the filesystem root. Used to detect a NESTED child
-    // repo whose root is strictly below a candidate ancestor `.planning/` — in
-    // that case the caller's repo boundary sits between start and the ancestor,
-    // so trusting the ancestor's `.planning/` would silently cross into a
-    // different project. (No `git` subprocess — fs walk only, matching
-    // isInsideGitRepo's deliberate no-spawn contract.)
-    function nearestGitRoot(from, upTo) {
-        let d = from;
-        while (d !== fsRoot) {
-            if (d === upTo)
-                break;
-            try {
-                if (!isSymlinkedPlanningDir(d) && node_fs_1.default.existsSync(d + node_path_1.default.sep + '.git'))
-                    return d;
-            }
-            catch {
-                // ignore
-            }
-            const next = node_path_1.default.dirname(d);
-            if (next === d)
-                break;
-            d = next;
-        }
-        return null;
-    }
-    let dir = resolvedStart;
-    let depth = 0;
-    while (dir !== fsRoot && depth < FIND_PROJECT_ROOT_MAX_DEPTH) {
-        const parent = node_path_1.default.dirname(dir);
-        if (parent === dir)
-            break;
-        if (parent === home)
-            break;
-        const parentPlanning = parent + node_path_1.default.sep + '.planning';
-        let parentPlanningIsDir = false;
-        try {
-            parentPlanningIsDir = node_fs_1.default.existsSync(parentPlanning) && node_fs_1.default.statSync(parentPlanning).isDirectory();
-        }
-        catch {
-            parentPlanningIsDir = false;
-        }
-        if (parentPlanningIsDir) {
-            const configPath = parentPlanning + node_path_1.default.sep + 'config.json';
-            let matched = false;
-            try {
-                const raw = node_fs_1.default.readFileSync(configPath, 'utf-8');
-                const config = JSON.parse(raw);
-                if (config && typeof config === 'object') {
-                    const cfg = config;
-                    const subReposValue = cfg['sub_repos'] ??
-                        (cfg['planning'] && typeof cfg['planning'] === 'object'
-                            ? cfg['planning']['sub_repos']
-                            : undefined);
-                    const subRepos = Array.isArray(subReposValue) ? subReposValue : [];
-                    if (subRepos.length > 0) {
-                        const relPath = node_path_1.default.relative(parent, resolvedStart);
-                        const topSegment = relPath.split(node_path_1.default.sep)[0];
-                        if (subRepos.includes(topSegment)) {
-                            return parent;
-                        }
-                    }
-                    if (cfg['multiRepo'] === true && isInsideGitRepo(parent)) {
-                        matched = true;
-                    }
-                }
-            }
-            catch {
-                // config.json missing or unparseable — fall through to .git heuristic.
-            }
-            if (matched)
-                return parent;
-            // Heuristic (3): parent has .planning/ and we're inside a git repo.
-            // Before returning, check if any further ancestor has sub_repos that explicitly
-            // claims our startDir — explicit sub_repos config takes precedence over the
-            // implicit .git signal. (#1422)
-            if (isInsideGitRepo(parent)) {
-                // #2843: do NOT cross a git-repo boundary. If the caller is inside its
-                // OWN nested repo whose root is strictly below `parent`, trusting
-                // `parent`'s .planning/ would silently resolve to a DIFFERENT project.
-                // isInsideGitRepo only proved SOME .git exists between start and parent;
-                // verify that .git is parent's own (or absent between), not a nested
-                // child repo. If nearestGitRoot finds a .git strictly below parent,
-                // the boundary is crossed — fall through (do not return parent).
-                if (nearestGitRoot(resolvedStart, parent) !== null) {
-                    dir = parent;
-                    depth += 1;
-                    continue;
-                }
-                // Lookahead: walk ancestors above `parent` to find a sub_repos claim.
-                let ancestor = node_path_1.default.dirname(parent);
-                let ancestorDepth = 0;
-                while (ancestor !== fsRoot && ancestor !== home && ancestorDepth < FIND_PROJECT_ROOT_MAX_DEPTH) {
-                    const ancestorPlanning = ancestor + node_path_1.default.sep + '.planning';
-                    try {
-                        if (node_fs_1.default.existsSync(ancestorPlanning) && node_fs_1.default.statSync(ancestorPlanning).isDirectory()) {
-                            const ancestorConfig = ancestor + node_path_1.default.sep + '.planning' + node_path_1.default.sep + 'config.json';
-                            const rawA = node_fs_1.default.readFileSync(ancestorConfig, 'utf-8');
-                            const cfgA = JSON.parse(rawA);
-                            const subReposValueA = cfgA['sub_repos'] ??
-                                (cfgA['planning'] && typeof cfgA['planning'] === 'object'
-                                    ? cfgA['planning']['sub_repos']
-                                    : undefined);
-                            const subReposA = Array.isArray(subReposValueA) ? subReposValueA : [];
-                            if (subReposA.length > 0) {
-                                const relPathA = node_path_1.default.relative(ancestor, resolvedStart);
-                                const topSegmentA = relPathA.split(node_path_1.default.sep)[0];
-                                if (subReposA.includes(topSegmentA)) {
-                                    return ancestor;
-                                }
-                            }
-                        }
-                    }
-                    catch {
-                        // ignore — config missing or unparseable, keep walking
-                    }
-                    const nextAncestor = node_path_1.default.dirname(ancestor);
-                    if (nextAncestor === ancestor)
-                        break;
-                    ancestor = nextAncestor;
-                    ancestorDepth += 1;
-                }
-                return parent;
-            }
-        }
-        dir = parent;
-        depth += 1;
-    }
-    // Heuristic (4): nearest ancestor .planning/ — last resort before fallback.
-    // Runs only after heuristics (1)–(3) have been exhausted without a match,
-    // ensuring sub_repos / multiRepo / .git-based resolution always wins when
-    // applicable. Walks upward again within the same FIND_PROJECT_ROOT_MAX_DEPTH
-    // bound; returns the nearest ancestor directory that contains a .planning/
-    // subdirectory so config resolves correctly when invoked from a plain
-    // descendant of a single-repo project. (#1414)
-    let dir2 = resolvedStart;
-    let depth2 = 0;
-    while (dir2 !== fsRoot && depth2 < FIND_PROJECT_ROOT_MAX_DEPTH) {
-        const parent2 = node_path_1.default.dirname(dir2);
-        if (parent2 === dir2)
-            break;
-        try {
-            const candidatePlanning = parent2 + node_path_1.default.sep + '.planning';
-            if (node_fs_1.default.existsSync(candidatePlanning) && node_fs_1.default.statSync(candidatePlanning).isDirectory()) {
-                // #2843: do not cross a git-repo boundary. If the caller is inside its
-                // own nested repo (a .git strictly below parent2), parent2's .planning/
-                // belongs to a DIFFERENT project — keep walking is wrong; stop and fall
-                // through to the startDir fallback instead of silently resolving to the
-                // ancestor project. (Reached only when no .git exists anywhere in the
-                // chain per the triage, but guard defensively.)
-                if (nearestGitRoot(resolvedStart, parent2) !== null) {
-                    break;
-                }
-                return parent2;
-            }
-        }
-        catch {
-            // ignore fs errors and continue walking
-        }
-        if (parent2 === home)
-            break;
-        dir2 = parent2;
-        depth2 += 1;
-    }
-    return startDir;
+    return (0, project_context_cjs_1.walkUpForPlanning)(startDir).root;
 }
 /**
  * #1459 (IC-01 / CB-4): THE single canonical derivation of the PROJECT ROOT used to bind/lookup a

package/gsd-core/bin/lib/quick-batch-dispatch.cjs

@@ -188,7 +188,7 @@ function routeMergeOutcome(outcome) {
 }
 /**
  * Crash-window duplicate-dispatch guard
- * (`.gsd/phase/feat-3677-quick-batch-hardening-acceptance/40-design.md` §1).
+ * (the #3677 design, PR #4240, §1).
  * `quick-batch resume`'s `eligible` is purely status/dependency-derived —
  * it has no awareness that an item already finished executing (a real
  * commit, `SUMMARY.md` written) before a coordinator crash left

package/gsd-core/bin/lib/report-parser.cjs

@@ -9,6 +9,14 @@ exports.ReportFormat = {
     Tap: 'tap', Junit: 'junit', SwiftTesting: 'swift-testing', Unittest: 'unittest', GoTest: 'go-test', Unknown: 'unknown',
 };
 exports.TestStatus = { Passed: 'passed', Failed: 'failed', Skipped: 'skipped', Todo: 'todo' };
+/**
+ * A name that is a JS/TS test source file, as opposed to a Java class or method. Limited to the
+ * extensions vitest, jest and node:test load: a wider list (`go`, `rs`, `py`, ...) would flag a
+ * Surefire class-level entry whose FQN ends in that segment (`com.acme.go`, #4724).
+ */
+const TEST_FILE_NAME = /\.[cm]?[jt]sx?$/;
+/** jest-junit's classNameTemplate for a suite that produced no results (utils/buildJsonResults.js). */
+const JEST_SUITE_FAILED_TO_RUN = 'Test suite failed to run';
 function parseTap(output) {
     const report = { format: exports.ReportFormat.Tap, valid: true, tests: [], issues: [] };
     const parser = new tap_parser_cjs_1.Parser({ strict: true });
@@ -62,12 +70,18 @@ function parseTap(output) {
             skipped ||= Boolean(parent.closingTestPoint?.skip);
             todo ||= Boolean(parent.closingTestPoint?.todo);
         }
+        // node:test reports a file that exits non-zero without a failing subtest as `not ok N - <file>`
+        // with `error: 'test failed'` / `code: 'ERR_TEST_FAILURE'` (#5721): it asserted nothing.
+        const diag = result.diag;
+        const fileFailure = !result.ok && diag?.['error'] === 'test failed' && diag['code'] === 'ERR_TEST_FAILURE'
+            && TEST_FILE_NAME.test(result.name);
         report.tests.push({
             name: result.name,
             identities: [...new Set([result.name, result.fullname])],
             group: null,
             groupIdentities: [],
             status: skipped ? exports.TestStatus.Skipped : todo ? exports.TestStatus.Todo : result.ok ? exports.TestStatus.Passed : exports.TestStatus.Failed,
+            ...(fileFailure ? { loadFailure: true } : {}),
         });
     }
     if (!completed)
@@ -111,6 +125,8 @@ function parseJunit(output) {
                 group: className || null,
                 groupIdentities: className ? [className, className.split('.').at(-1)] : [],
                 status: exports.TestStatus.Passed,
+                ...(className === JEST_SUITE_FAILED_TO_RUN || (name === className && TEST_FILE_NAME.test(name))
+                    ? { loadFailure: true } : {}),
             };
         }
         else if (current && parent === 'testcase') {