@sdd-method/verify-cli 0.1.0

package/dist/lib/catalogue/staleness-verdicts.js

@@ -0,0 +1,345 @@
+// Staleness VERDICTS — the second half of M-ADR 0205 §4.5's staleness scope
+// (ledger §3o): "staleness meaning corpus_ref older than the target's last
+// content change". The scores-coverage predicate computes each row's BASIS;
+// this module computes the VERDICT the basis supports. A stale score is worse
+// than a missing one, because it reads as coverage — the predicate otherwise
+// counts a score written against a corpus that has since moved as fully
+// covering its target.
+//
+// Verdict rules, per basis:
+//   corpus_ref + target_path — PRECISE, and a CONTENT test: the target is stale
+//       iff its blob at HEAD differs from its blob at the anchor. An anchor the
+//       repo does not know is UNKNOWN-ANCHOR (never guessed); an anchor with
+//       no target_path cannot support a per-target verdict and is counted as
+//       such rather than compared against repo HEAD (which would mark a row
+//       stale whenever ANYTHING in the repo moved — alarm, not measurement).
+//
+//       WHY CONTENT AND NOT `git log`: the previous test asked whether any
+//       commit touched the path since the anchor, which fires on a PURE RENAME
+//       — so a portability rename restarts the staleness treadmill for every
+//       anchored score in the corpus, and the estate is told to re-review
+//       hundreds of artefacts whose text never changed. Measured instance: one
+//       score reported stale-by-hours was byte-IDENTICAL to its assessed state,
+//       caught only by comparing blobs by hand. A test that cannot tell "moved"
+//       from "changed" produces re-review debt out of nothing.
+//
+//       Renames are exempt BY CONSTRUCTION, not by a special case: where the
+//       path does not exist at the anchor, git's own rename detection over
+//       <anchor>..HEAD supplies the pre-rename name and the blob is compared
+//       across it. Where that also fails the row is PATH-ABSENT-AT-ANCHOR —
+//       reported as its own outcome rather than guessed either way.
+//
+//   TARGET-MISSING (any basis): the target_path does not exist at HEAD. A
+//       deleted artefact cannot be re-reviewed, so folding it into `stale`
+//       prescribes a remedy that cannot be performed (M-ADR 0199 §4.4). It is
+//       counted and reported on its own, and its remedy is to withdraw or
+//       re-point the score.
+//   scored_at + target_path — COARSE: last content change of the path
+//       (committer date) after scored_at ⇒ stale. A path git does not track
+//       is UNKNOWN-ANCHOR.
+//   none — already reported by scores-coverage as unknown currency; not
+//       re-reported here.
+//
+// MEMBER TIER ONLY, stated not silent: the aggregate tier reads sibling
+// catalogues whose target files and git histories are not local, so a verdict
+// there would be a guess. Reporting-only (`coverage` class) like the rest of
+// the scores family — promotion to gate-acting is a later, deliberate act.
+import { execFile as execFileCb } from "node:child_process";
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execFile = promisify(execFileCb);
+const NO_RUN = {
+    assessed: 0,
+    stale: [],
+    current: 0,
+    unknownAnchor: 0,
+    anchorWithoutPath: 0,
+    targetMissing: [],
+    pathAbsentAtAnchor: 0,
+    directoryTargets: 0,
+};
+async function git(sddRoot, args) {
+    try {
+        const { stdout } = await execFile("git", [...args], {
+            cwd: sddRoot,
+            encoding: "utf8",
+            maxBuffer: 4 * 1024 * 1024,
+        });
+        return { ok: true, stdout: stdout.trim() };
+    }
+    catch {
+        return { ok: false, stdout: "" };
+    }
+}
+/**
+ * Is the target genuinely GONE, or merely not committed?
+ *
+ * `git rev-parse HEAD:<path>` fails for both a deleted file and an untracked
+ * one that is sitting on disk. Treating the second as deleted would tell an
+ * author to withdraw a score for an artefact they can see in front of them —
+ * so absence from the HEAD tree is confirmed against the working tree before
+ * it is called missing. (Caught by this module's own untracked-path control,
+ * which is what it was there for.)
+ */
+async function existsOnDisk(sddRoot, path) {
+    try {
+        await access(join(sddRoot, path));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * DIRECTORY TARGETS are a real and different case, raised by the reverse estate
+ * from its own pre-cut data: 18 of its 84 stale rows name a whole-domain
+ * directory rather than a file.
+ *
+ * `git rev-parse <rev>:<path>` returns a TREE oid for a directory and a BLOB oid
+ * for a file, so the comparison below works for both — but it does not mean the
+ * same thing. A file is stale when its own bytes changed; a directory is stale
+ * when ANYTHING beneath it changed, which for a whole-domain tree is close to
+ * unconditional. That is a wider test, and it is defensible (a score over a tree
+ * really is invalidated by movement inside it) — but it must be SAID, because a
+ * number that is near-unconditional by construction reads exactly like a number
+ * that is measuring something.
+ *
+ * Git's rename detection also does not apply: a tree has no rename pair. A moved
+ * directory therefore lands in `pathAbsentAtAnchor` rather than being exempted.
+ */
+async function objectTypeAt(sddRoot, rev, path) {
+    const oid = await git(sddRoot, ["rev-parse", `${rev}:${path}`]);
+    if (!oid.ok || oid.stdout === "")
+        return null;
+    const t = await git(sddRoot, ["cat-file", "-t", oid.stdout]);
+    if (!t.ok)
+        return null;
+    return t.stdout === "tree" ? "tree" : "blob";
+}
+/** Blob (or tree — see `objectTypeAt`) id of `<rev>:<path>`, else null. */
+async function blobAt(sddRoot, rev, path) {
+    const r = await git(sddRoot, ["rev-parse", `${rev}:${path}`]);
+    return r.ok && r.stdout !== "" ? r.stdout : null;
+}
+/**
+ * new-path -> pre-rename path, from git's OWN rename detection over
+ * `<anchor>..HEAD`. One call per distinct anchor, not per row: anchors are few
+ * and this walk is the expensive part.
+ *
+ * Using git's detector rather than a heuristic matters — a basename match would
+ * pair unrelated files that happen to share a name, which is precisely the
+ * shared-token failure this corpus keeps producing.
+ */
+async function renameMap(sddRoot, anchor) {
+    const map = new Map();
+    const r = await git(sddRoot, ["diff", "--name-status", "-M", anchor, "HEAD"]);
+    if (!r.ok)
+        return map;
+    for (const line of r.stdout.split("\n")) {
+        if (!line.startsWith("R"))
+            continue;
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        map.set(parts[2], parts[1]);
+    }
+    return map;
+}
+export async function runStalenessVerdicts(session, options) {
+    if (!options.available.has("quality_scores"))
+        return { ...NO_RUN };
+    if (options.tier !== "member") {
+        return {
+            ...NO_RUN,
+            skipped: "aggregate tier cannot reach member repos' files or git histories — staleness verdicts are member-tier",
+        };
+    }
+    const inRepo = await git(options.sddRoot, ["rev-parse", "--git-dir"]);
+    if (!inRepo.ok) {
+        return {
+            ...NO_RUN,
+            skipped: `${options.sddRoot} is not a git repository — no anchor can be compared, verdicts UNATTEMPTED (not fresh)`,
+        };
+    }
+    const asStr = (v) => v === null || v === undefined ? "" : String(v).trim();
+    const reader = await session.conn.runAndReadAll(`SELECT rubric_id, target_ref, target_path, corpus_ref, scored_at, staleness_basis
+     FROM "quality_scores"
+     WHERE staleness_basis IN ('corpus_ref', 'scored_at');`);
+    const rows = reader.getRows();
+    const stale = [];
+    let current = 0;
+    let unknownAnchor = 0;
+    let anchorWithoutPath = 0;
+    let pathAbsentAtAnchor = 0;
+    let directoryTargets = 0;
+    const targetMissing = [];
+    const anchorKnown = new Map();
+    const renamesByAnchor = new Map();
+    for (const [rubricIdRaw, targetRefRaw, targetPathRaw, corpusRefRaw, scoredAtRaw, basisRaw] of rows) {
+        const rubricId = asStr(rubricIdRaw);
+        const targetRef = asStr(targetRefRaw);
+        const basis = asStr(basisRaw);
+        // Counted for BOTH bases, before the branch. The first cut of this counter
+        // sat inside the corpus_ref branch only, so it was blind to every
+        // scored_at row — and the estate that ASKED for this count has all 18 of
+        // its directory targets on the scored_at basis, so the metric it requested
+        // read zero for it. The controls passed because they were written with
+        // corpus_ref fixtures: a control that exercises one branch says nothing
+        // about the other.
+        {
+            const p = asStr(targetPathRaw);
+            if (p !== "" && (await objectTypeAt(options.sddRoot, "HEAD", p)) === "tree") {
+                directoryTargets += 1;
+            }
+        }
+        if (basis === "corpus_ref") {
+            const anchor = asStr(corpusRefRaw);
+            const path = asStr(targetPathRaw);
+            if (path === "") {
+                anchorWithoutPath += 1;
+                continue;
+            }
+            let known = anchorKnown.get(anchor);
+            if (known === undefined) {
+                known = (await git(options.sddRoot, ["cat-file", "-e", `${anchor}^{commit}`])).ok;
+                anchorKnown.set(anchor, known);
+            }
+            if (!known) {
+                unknownAnchor += 1;
+                continue;
+            }
+            const headBlob = await blobAt(options.sddRoot, "HEAD", path);
+            if (headBlob === null) {
+                if (await existsOnDisk(options.sddRoot, path)) {
+                    // Present but uncommitted: no blob to compare against, and nothing
+                    // deleted. Unknown, which is not fresh.
+                    unknownAnchor += 1;
+                }
+                else {
+                    targetMissing.push({ rubricId, targetRef, targetPath: path });
+                }
+                continue;
+            }
+            let anchorBlob = await blobAt(options.sddRoot, anchor, path);
+            if (anchorBlob === null) {
+                // The path did not exist at the anchor under this name. Ask git whether
+                // it was renamed there rather than concluding anything.
+                let renames = renamesByAnchor.get(anchor);
+                if (renames === undefined) {
+                    renames = await renameMap(options.sddRoot, anchor);
+                    renamesByAnchor.set(anchor, renames);
+                }
+                const oldPath = renames.get(path);
+                if (oldPath !== undefined) {
+                    anchorBlob = await blobAt(options.sddRoot, anchor, oldPath);
+                }
+            }
+            if (anchorBlob === null) {
+                pathAbsentAtAnchor += 1;
+                continue;
+            }
+            if (anchorBlob === headBlob) {
+                // Byte-identical to its assessed state — including across a rename,
+                // which is the whole point of testing content instead of touches.
+                current += 1;
+            }
+            else {
+                stale.push({
+                    rubricId,
+                    targetRef,
+                    basis: "corpus_ref",
+                    detail: "target CONTENT differs from its state at the anchor",
+                });
+            }
+        }
+        else {
+            const path = asStr(targetPathRaw);
+            const at = asStr(scoredAtRaw);
+            if (path === "" || at === "") {
+                // basis says scored_at, but the row cannot actually support it —
+                // count as unknown rather than trusting the label over the data.
+                unknownAnchor += 1;
+                continue;
+            }
+            if ((await blobAt(options.sddRoot, "HEAD", path)) === null &&
+                !(await existsOnDisk(options.sddRoot, path))) {
+                targetMissing.push({ rubricId, targetRef, targetPath: path });
+                continue;
+            }
+            const last = await git(options.sddRoot, ["log", "-1", "--format=%cI", "--", path]);
+            if (!last.ok || last.stdout === "") {
+                unknownAnchor += 1;
+                continue;
+            }
+            const reviewedMs = Date.parse(at);
+            if (Number.isNaN(reviewedMs)) {
+                unknownAnchor += 1;
+                continue;
+            }
+            if (Date.parse(last.stdout) > reviewedMs) {
+                stale.push({
+                    rubricId,
+                    targetRef,
+                    basis: "scored_at",
+                    detail: `target last changed ${last.stdout.slice(0, 10)}, after the review of ${at.slice(0, 10)}`,
+                });
+            }
+            else {
+                current += 1;
+            }
+        }
+    }
+    return {
+        assessed: rows.length,
+        stale,
+        current,
+        unknownAnchor,
+        anchorWithoutPath,
+        targetMissing,
+        pathAbsentAtAnchor,
+        directoryTargets,
+    };
+}
+export function renderStalenessVerdicts(res, tier) {
+    const out = [];
+    if (res.skipped !== undefined) {
+        out.push(`[metric] scores_staleness (${tier}): n/a — ${res.skipped}`);
+        return out;
+    }
+    if (res.assessed === 0)
+        return out;
+    for (const s of res.stale) {
+        out.push(`[finding] coverage: ${s.rubricId} score for '${s.targetRef}' is STALE — ` +
+            `${s.detail}; the assessment predates the artefact it reads as covering — ` +
+            `re-review it or record why the change does not invalidate the score`);
+    }
+    if (res.pathAbsentAtAnchor > 0) {
+        // Counted AND said. A bucket that only ever appears as a number in a metric
+        // line is a state nobody acts on, and this one means an assessment cannot
+        // be verified at all.
+        out.push(`[finding] coverage: ${res.pathAbsentAtAnchor} score(s) have a target that DID NOT EXIST ` +
+            `AT THE ANCHOR under any name git can pair — the assessment cannot be verified ` +
+            `against its own corpus_ref; re-anchor the score, or re-review and re-anchor together`);
+    }
+    for (const t of res.targetMissing) {
+        // Remedy deliberately differs from STALE's. M-ADR 0199 §4.4 binds a remedy
+        // to be performable at the tier that emitted it, and "re-review it" cannot
+        // be performed on an artefact that no longer exists.
+        out.push(`[finding] coverage: ${t.rubricId} score for '${t.targetRef}' has a TARGET THAT NO LONGER ` +
+            `EXISTS — '${t.targetPath}' is absent at HEAD; the assessment cannot be re-reviewed, ` +
+            `so withdraw the score or re-point it at the successor artefact`);
+    }
+    out.push(`[metric] scores_staleness (${tier}): ${res.assessed} verdict-capable score(s) — ` +
+        `${res.stale.length} stale / ${res.current} current / ` +
+        `${res.targetMissing.length} target-missing / ` +
+        `${res.unknownAnchor} unknown-anchor / ${res.anchorWithoutPath} anchor-without-path / ` +
+        `${res.pathAbsentAtAnchor} path-absent-at-anchor` +
+        (res.directoryTargets > 0
+            ? ` (of which ${res.directoryTargets} target a DIRECTORY — stale there means anything beneath it changed, a wider test than a file's and near-unconditional over a large tree)`
+            : "") +
+        ` (staleness is a CONTENT test — a rename is not a change; unknown is not fresh;` +
+        ` reporting-only per M-ADR 0205 §4.5)`);
+    return out;
+}
+//# sourceMappingURL=staleness-verdicts.js.map

package/dist/lib/catalogue/validate.js

@@ -0,0 +1,176 @@
+// `sdd-cli catalogue validate` — re-validate an existing catalogues/
+// directory without rebuilding. Two checks per the canonical CLI spec:
+//
+//   1. Column-shape check: every CSV's header row must match the
+//      canonical schema's declared columns (exact set + order).
+//   2. FK validation: full pass over the loaded rows, internal mode
+//      (external FKs treated per their declared flag — same semantics
+//      as `catalogue build`). Adopters who want post-merge validation
+//      run `catalogue aggregate` instead.
+//
+// Outputs the same shape of findings as `build` so consumers can pipe
+// either through the same parser. Exit 0 on PASS; non-zero on shape
+// drift OR internal-FK FAIL.
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { CLI_VERSION } from "./cli-version.js";
+import { readCatalogueCsv } from "./csv-reader.js";
+import { writeCatalogue } from "./csv-writer.js";
+import { validateWithEngineToLog } from "./engine-validator.js";
+import { FindingsLog } from "./findings.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+export async function runCatalogueValidate(inputs, write) {
+    const sddPath = resolve(inputs.sddPath ?? process.cwd());
+    const cataloguesDir = join(sddPath, "catalogues");
+    const schema = await loadCanonicalSchema();
+    write(`sdd-cli catalogue validate (canonical schema ${schema.schemaVersion}, cli ${CLI_VERSION})\n`);
+    // Existence check on catalogues/ — fail fast with a clear message.
+    try {
+        const s = await stat(cataloguesDir);
+        if (!s.isDirectory()) {
+            throw new Error(`catalogues/ at ${cataloguesDir} exists but is not a directory`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            throw new Error(`catalogues/ not found at ${cataloguesDir}\n` +
+                `  Run \`sdd-cli catalogue build\` before \`validate\`.`);
+        }
+        throw err;
+    }
+    const findings = new FindingsLog();
+    const rowsByCatalogue = new Map();
+    let columnShapeOk = true;
+    for (const cat of schema.catalogues) {
+        const filePath = join(cataloguesDir, `${cat.name}.csv`);
+        let parsed;
+        try {
+            parsed = await readCatalogueCsv(filePath);
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                // Missing file is a shape failure — every catalogue declared in
+                // the schema MUST have a CSV (headers-only acceptable).
+                findings.add("convention", `catalogues/${cat.name}.csv missing — every schema catalogue must have a file (headers-only acceptable)`);
+                columnShapeOk = false;
+                rowsByCatalogue.set(cat.name, []);
+                continue;
+            }
+            throw err;
+        }
+        const expected = cat.columns.map((c) => c.name);
+        const drift = compareColumns(expected, parsed.columns);
+        if (drift !== null) {
+            findings.add("convention", `catalogues/${cat.name}.csv: column shape drift — ${drift}`);
+            columnShapeOk = false;
+        }
+        rowsByCatalogue.set(cat.name, parsed.rows);
+    }
+    // Derive the SDD profile from products.csv so profile-external FKs (schema
+    // 2.23.0) resolve consistently with `catalogue build`. A per-SDD catalogue
+    // has one distinct profile → pass it (an app catalogue's capabilities.domain_id
+    // is then treated external, matching the build). An aggregated catalogue mixes
+    // profiles → leave undefined, so those FKs validate as internal and MUST
+    // resolve (the merged platform domains are present to satisfy them).
+    const profile = singleProfile(rowsByCatalogue.get("products") ?? []);
+    // FK + bound-enum validation on the embedded engine (M-ADR 0205 §4.4
+    // cutover; same semantics, findings text unchanged — the A2/A3 dual-run
+    // record is the evidence). Enum hard-fail behaviour per M-ADR 0203 §4.1
+    // is unchanged: an out-of-set value is an error-severity finding.
+    const { fk, enums } = await validateWithEngineToLog(schema, rowsByCatalogue, findings, { ...(profile !== undefined ? { profile } : {}) });
+    // Report.
+    const findingsText = findings.render();
+    if (findingsText)
+        write(`\n${findingsText}\n`);
+    if (columnShapeOk) {
+        write(`\nColumn-shape check: PASS\n`);
+    }
+    else {
+        write(`\nColumn-shape check: FAIL\n`);
+    }
+    if (fk.internalPass) {
+        write(`FK validation (internal): PASS\n`);
+    }
+    else {
+        write(`FK validation (internal): FAIL (${fk.internalFailures.length} dangling)\n`);
+        for (const f of fk.internalFailures) {
+            write(`  ${f.catalogue}.${f.column}: row pk=${f.referencingRow} → ${f.target}=${f.value || "<empty>"}\n`);
+        }
+    }
+    if (enums.pass) {
+        write(`Enum validation (column_enums): PASS\n`);
+    }
+    else {
+        write(`Enum validation (column_enums): FAIL (${enums.violations.length} out-of-set)\n`);
+        for (const v of enums.violations) {
+            write(`  ${v.catalogue}.${v.column}: row pk=${v.rowPk} value "${v.value}" (allowed: ${v.allowed})\n`);
+        }
+    }
+    if (fk.externalFindings > 0) {
+        write(`External findings: ${fk.externalFindings} (validated by aggregator)\n`);
+    }
+    // Force-touch writeCatalogue to keep imports honest if a future
+    // refactor wants to re-emit a cleaned-up file from validate. Today
+    // validate is read-only.
+    void writeCatalogue;
+    const strictFail = inputs.strict === true && findings.count() > 0;
+    // Error-severity findings (the bound-enum FAIL path) fail validate by
+    // default, matching `catalogue build`'s exit-code contract.
+    const exitCode = !columnShapeOk || !fk.internalPass || !enums.pass || findings.errorCount() > 0 || strictFail
+        ? 1
+        : 0;
+    return {
+        exitCode,
+        schemaVersion: schema.schemaVersion,
+        internalFkPass: fk.internalPass,
+        columnShapeOk,
+        enumPass: enums.pass,
+        findingsCount: findings.count(),
+    };
+}
+/**
+ * Compare a CSV's actual column header against the schema's declared
+ * column order. Returns null if exactly equal (order included), or a
+ * one-line description of the drift otherwise.
+ */
+/**
+ * The single distinct non-empty `profile` across products rows, or undefined
+ * when there are zero or multiple (an aggregated catalogue). Drives
+ * profile-external FK handling (schema 2.23.0) — see the call site.
+ */
+function singleProfile(products) {
+    const profiles = new Set();
+    for (const p of products) {
+        const v = String(p["profile"] ?? "");
+        if (v !== "")
+            profiles.add(v);
+    }
+    return profiles.size === 1 ? [...profiles][0] : undefined;
+}
+function compareColumns(expected, actual) {
+    if (expected.length === actual.length) {
+        let equal = true;
+        for (let i = 0; i < expected.length; i++) {
+            if (expected[i] !== actual[i]) {
+                equal = false;
+                break;
+            }
+        }
+        if (equal)
+            return null;
+    }
+    const expectedSet = new Set(expected);
+    const actualSet = new Set(actual);
+    const missing = expected.filter((c) => !actualSet.has(c));
+    const extra = actual.filter((c) => !expectedSet.has(c));
+    if (missing.length === 0 && extra.length === 0) {
+        return `column order differs (expected: ${expected.join(",")} | got: ${actual.join(",")})`;
+    }
+    const parts = [];
+    if (missing.length > 0)
+        parts.push(`missing: ${missing.join(",")}`);
+    if (extra.length > 0)
+        parts.push(`unexpected: ${extra.join(",")}`);
+    return parts.join("; ");
+}
+//# sourceMappingURL=validate.js.map

package/dist/lib/catalogue/version.js

@@ -0,0 +1,18 @@
+// `sdd-cli catalogue version` — prints the canonical schema version
+// and the sdd-cli version pin so adopters can verify their tooling
+// matches the schema they expect.
+import { CLI_VERSION } from "./cli-version.js";
+import { SCHEMA_COMPAT } from "./schema-compat.js";
+import { loadCanonicalSchema } from "./schema-loader.js";
+export async function runCatalogueVersion(write) {
+    const schema = await loadCanonicalSchema();
+    write([
+        `sdd-cli                    ${CLI_VERSION}`,
+        `catalogue schema           ${schema.schemaVersion}`,
+        `accepted catalogue range   ${SCHEMA_COMPAT.catalogue_schema}`,
+        `accepted sdd_manifest      ${SCHEMA_COMPAT.sdd_manifest}`,
+        `accepted aggregation       ${SCHEMA_COMPAT.aggregation_manifest}`,
+        "",
+    ].join("\n"));
+}
+//# sourceMappingURL=version.js.map

package/dist/lib/list/discover.js

@@ -0,0 +1,100 @@
+import { opendir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { readLockFile } from "../lock-file.js";
+import { readRepoKind } from "../repo-kind.js";
+const SKIP_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    ".cache",
+    "coverage",
+    "tmp",
+    "export",
+    ".venv",
+    "__pycache__",
+]);
+export async function discoverSddRepos(roots) {
+    const seen = new Set();
+    const repos = [];
+    for (const root of roots) {
+        const abs = resolve(root);
+        await walk(abs, seen, repos);
+    }
+    repos.sort((a, b) => a.path.localeCompare(b.path));
+    return repos;
+}
+async function walk(dir, seen, repos) {
+    if (seen.has(dir))
+        return;
+    seen.add(dir);
+    const kind = await tryReadRepoKind(dir);
+    if (kind) {
+        const bundles = await tryReadBundles(dir);
+        const forwardBase = bundles.find((b) => b.isForwardBase) ?? bundles[0];
+        const bundleVersion = forwardBase?.version ?? null;
+        repos.push({ path: dir, kind, bundleVersion, bundles });
+        return;
+    }
+    let entries;
+    try {
+        entries = await opendir(dir);
+    }
+    catch {
+        return;
+    }
+    for await (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith(".") &&
+            entry.name !== ".iteraitive" &&
+            entry.name !== ".sdd-method") {
+            if (SKIP_DIRS.has(entry.name))
+                continue;
+        }
+        if (SKIP_DIRS.has(entry.name))
+            continue;
+        await walk(join(dir, entry.name), seen, repos);
+    }
+}
+async function tryReadRepoKind(dir) {
+    try {
+        return await readRepoKind(dir);
+    }
+    catch {
+        return null;
+    }
+}
+async function tryReadBundles(dir) {
+    try {
+        const lock = await readLockFile(dir);
+        if (!lock)
+            return [];
+        return lock.bundles.map(toDiscoveredBundle);
+    }
+    catch {
+        return [];
+    }
+}
+function toDiscoveredBundle(entry) {
+    const bundle = {
+        name: entry.name,
+        version: entry.bundleVersion,
+        isForwardBase: entry.isForwardBase,
+        managedPathCount: entry.managedPaths.length,
+    };
+    if (entry.producedByAdopter)
+        bundle.producedByAdopter = entry.producedByAdopter;
+    if (entry.scope)
+        bundle.scope = entry.scope;
+    if (entry.requiresForwardBase) {
+        bundle.requiresForwardBase = entry.requiresForwardBase.bundle;
+    }
+    if (entry.requiresPack) {
+        bundle.requiresPack = entry.requiresPack.name;
+    }
+    return bundle;
+}
+//# sourceMappingURL=discover.js.map