@codyswann/lisa 2.279.2 → 2.281.0

package/dist/cli/doctor-readiness-audit-allowlist.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Collect the undocumented audit exceptions across every allowlist file.
+ * @param root - Repository root
+ * @returns Evidence lines, one per undocumented exception
+ */
+export declare function auditExceptionViolations(root: string): Promise<readonly string[]>;
+//# sourceMappingURL=doctor-readiness-audit-allowlist.d.ts.map

package/dist/cli/doctor-readiness-audit-allowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-audit-allowlist.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-audit-allowlist.ts"],"names":[],"mappings":"AAgMA;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAiB5B"}

package/dist/cli/doctor-readiness-audit-allowlist.js

@@ -0,0 +1,177 @@
+/**
+ * Audit-allowlist reading for the dependencies/supply-chain readiness producer
+ * (B5, PRD #1739, #1896).
+ *
+ * An audit allowlist is a list of vulnerabilities somebody decided not to fix.
+ * B5 asks the only question that keeps such a list honest: is the decision
+ * written down next to the exception? Two failure directions matter equally and
+ * this module is shaped by both.
+ *
+ * Reporting too much fabricates findings — audit-ci's own `.nsprc` carries
+ * `$schema` and other configuration at the same level as advisory ids, so a
+ * naive walk reports the schema pointer as an undocumented exclusion. Reporting
+ * too little is worse: an entry with no `id` field, or a bare string in the
+ * list, is still a live exception with no written decision, and dropping it
+ * turns the one finding this dimension exists for into silence. Identity
+ * therefore degrades (advisory id → package name → position) rather than
+ * disappearing.
+ * @module cli/doctor-readiness-audit-allowlist
+ */
+import { isRecord, readFileOrNull } from "./doctor-readiness-shared.js";
+/** Audit allowlists whose entries must each carry a decision record. */
+const ALLOWLIST_FILES = [
+    "audit.ignore.config.json",
+    "audit.ignore.local.json",
+    ".nsprc",
+];
+/** Keys that count as the written decision behind an audit exception. */
+const DECISION_KEYS = [
+    "reason",
+    "notes",
+    "justification",
+    "decision",
+    "rationale",
+    "comment",
+];
+/**
+ * Keys whose value holds audit exceptions. Everything outside these containers
+ * is configuration, not an exception — walking a whole document as if every
+ * top-level key were an advisory id turns audit-ci's own `.nsprc` (`$schema`,
+ * `exceptions`, …) into fabricated findings.
+ */
+const EXCEPTION_CONTAINERS = [
+    "exclusions",
+    "exceptions",
+    "advisories",
+    "allowlist",
+];
+/**
+ * Whether a top-level `.nsprc`-style key names an advisory rather than config.
+ * @param key - The key to classify
+ * @returns True when the key may name an advisory
+ */
+function isAdvisoryKey(key) {
+    return !key.startsWith("$") && !key.startsWith("//");
+}
+/**
+ * Name one array-shaped exception for an operator.
+ *
+ * An entry with no `id` must never be dropped — a live exception with no written
+ * decision is precisely what B5 exists to surface, and a missing field is not a
+ * reason to suppress it. So the identity degrades: advisory id, then package
+ * name, then the entry's position in the list.
+ * @param entry - The entry's fields
+ * @param index - Zero-based position in the container
+ * @returns The operator-facing identity
+ */
+function describeException(entry, index) {
+    if (typeof entry.id === "string" && entry.id.trim() !== "") {
+        return entry.id;
+    }
+    return typeof entry.package === "string" && entry.package.trim() !== ""
+        ? entry.package
+        : `entry #${index + 1}`;
+}
+/**
+ * Normalize one array-shaped exception container.
+ *
+ * A bare string entry IS the advisory id, and it carries no fields at all — so
+ * there is nowhere for a decision to live, which makes it undocumented by
+ * construction rather than something to skip over.
+ * @param container - The array of entries
+ * @returns The normalized exceptions
+ */
+function arrayEntries(container) {
+    return container.flatMap((entry, index) => {
+        if (typeof entry === "string" && entry.trim() !== "") {
+            return [{ id: entry.trim(), fields: null }];
+        }
+        return isRecord(entry)
+            ? [{ id: describeException(entry, index), fields: entry }]
+            : [];
+    });
+}
+/**
+ * Take the object-valued, non-config entries out of an exception map.
+ * @param container - A candidate exception map
+ * @returns The entries that are genuinely exceptions
+ */
+function mapEntries(container) {
+    return Object.entries(container).flatMap(([key, entry]) => isAdvisoryKey(key) && isRecord(entry) ? [{ id: key, fields: entry }] : []);
+}
+/**
+ * Normalize one allowlist document into exception entries.
+ *
+ * Two shapes exist in the wild: a named container holding an array or a map of
+ * entries, and audit-ci's `.nsprc`, whose top level maps advisory id to entry.
+ * In the map shape only OBJECT-valued entries are exceptions — a string, a
+ * boolean, or a `$schema` pointer at the top level is configuration.
+ * @param parsed - The parsed allowlist document
+ * @returns The exception entries
+ */
+function exceptionEntries(parsed) {
+    if (!isRecord(parsed)) {
+        return [];
+    }
+    const containers = EXCEPTION_CONTAINERS.flatMap(key => parsed[key] === undefined ? [] : [parsed[key]]);
+    if (containers.length > 0) {
+        return containers.flatMap(container => Array.isArray(container)
+            ? arrayEntries(container)
+            : isRecord(container)
+                ? mapEntries(container)
+                : []);
+    }
+    // No recognized container: fall back to the `.nsprc` id → entry map. If
+    // nothing there is an object-valued advisory key, this document establishes
+    // nothing and reports nothing.
+    return mapEntries(parsed);
+}
+/**
+ * Read one audit allowlist and report the exceptions carrying no decision.
+ *
+ * An entry with `active: false` is skipped: audit-ci never applies it, so there
+ * is no live exception for anybody to justify.
+ * @param file - Repo-relative allowlist path
+ * @param parsed - The parsed allowlist document
+ * @returns Evidence lines, one per undocumented exception
+ */
+function undocumentedExceptions(file, parsed) {
+    return exceptionEntries(parsed).flatMap(({ id, fields }) => {
+        if (fields?.active === false) {
+            return [];
+        }
+        const documented = fields !== null &&
+            DECISION_KEYS.some(decisionKey => typeof fields[decisionKey] === "string" &&
+                fields[decisionKey].trim() !== "");
+        return documented
+            ? []
+            : [
+                `\`${file}\` excludes advisory \`${id}\` from the dependency audit ` +
+                    "with no written decision (no reason/notes/justification field), so " +
+                    "nobody can tell whether the exception is still true",
+            ];
+    });
+}
+/**
+ * Collect the undocumented audit exceptions across every allowlist file.
+ * @param root - Repository root
+ * @returns Evidence lines, one per undocumented exception
+ */
+export async function auditExceptionViolations(root) {
+    const perFile = await Promise.all(ALLOWLIST_FILES.map(async (file) => {
+        const source = await readFileOrNull(root, file);
+        if (source === null) {
+            return [];
+        }
+        try {
+            return undocumentedExceptions(file, JSON.parse(source));
+        }
+        catch {
+            // An unparseable allowlist establishes nothing about its entries, so it
+            // is passed over rather than reported as an undocumented exception.
+            return [];
+        }
+    }));
+    return perFile.flat();
+}
+//# sourceMappingURL=doctor-readiness-audit-allowlist.js.map

package/dist/cli/doctor-readiness-audit-allowlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-audit-allowlist.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-audit-allowlist.ts"],"names":[],"mappings":"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"}

package/dist/cli/doctor-readiness-capabilities.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The capabilities/tools readiness producer (PRD #1739, #1896).
+ *
+ * Dimension 2 of the `readiness-rubric` asks whether every tool the work needs
+ * is provably *reachable*, not merely installed. The `tool-access-gate` names
+ * the anti-pattern explicitly: a binary on `PATH`, a dependency in a manifest,
+ * or a configured MCP server proves that something was declared, never that a
+ * request through it succeeds. Reachability is established by a live read-only
+ * probe against the real system, and nothing an offline file read can see is a
+ * substitute for one.
+ *
+ * So this dimension has no offline evidence to gather and no blocker to stand.
+ * What it has is an obligation to say so: a blank dimension reads as "nothing to
+ * report" when it actually means "never looked" (#1898), and a presence-based
+ * PASS would be worse still — it would report the anti-pattern as proof. The
+ * producer therefore renders one reasoned SKIP, every time, naming the live
+ * probe it did not run.
+ * @module cli/doctor-readiness-capabilities
+ */
+import type { ReadinessDimensionRecord } from "./doctor-readiness-types.js";
+/** The capabilities/tools readiness dimension id (readiness-rubric, RRR-1). */
+export declare const CAPABILITIES_TOOLS_DIMENSION_ID = "capabilities-tools";
+/**
+ * Assess the capabilities/tools dimension. Always a reasoned SKIP: the question
+ * is not offline-answerable, so the honest answer is a stated non-answer. The
+ * record names no `blocker`, so it can never stand one up, and the `root`
+ * argument is accepted only to satisfy the shared producer signature — reading
+ * it would be the presence anti-pattern the rule forbids.
+ * @param _root - Project root (deliberately unread)
+ * @returns The capabilities/tools dimension record
+ */
+export declare function assessCapabilitiesToolsDimension(_root: string): Promise<ReadinessDimensionRecord>;
+//# sourceMappingURL=doctor-readiness-capabilities.d.ts.map

package/dist/cli/doctor-readiness-capabilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-capabilities.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-capabilities.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAE5E,+EAA+E;AAC/E,eAAO,MAAM,+BAA+B,uBAAuB,CAAC;AAWpE;;;;;;;;GAQG;AACH,wBAAsB,gCAAgC,CACpD,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,wBAAwB,CAAC,CAMnC"}

package/dist/cli/doctor-readiness-capabilities.js

@@ -0,0 +1,26 @@
+/** The capabilities/tools readiness dimension id (readiness-rubric, RRR-1). */
+export const CAPABILITIES_TOOLS_DIMENSION_ID = "capabilities-tools";
+/** The stated reason this dimension is never assessed by an offline read. */
+const CAPABILITIES_SKIP_REASON = "Tool reachability requires a live read-only probe against the real system " +
+    "and cannot be established from an offline read. The `tool-access-gate` rule " +
+    "names presence — a binary on `PATH`, a dependency in a manifest, a " +
+    "configured MCP server — as the anti-pattern: it proves a tool was declared, " +
+    "never that a request through it succeeds. This dimension was therefore " +
+    "deliberately not assessed rather than answered from presence.";
+/**
+ * Assess the capabilities/tools dimension. Always a reasoned SKIP: the question
+ * is not offline-answerable, so the honest answer is a stated non-answer. The
+ * record names no `blocker`, so it can never stand one up, and the `root`
+ * argument is accepted only to satisfy the shared producer signature — reading
+ * it would be the presence anti-pattern the rule forbids.
+ * @param _root - Project root (deliberately unread)
+ * @returns The capabilities/tools dimension record
+ */
+export async function assessCapabilitiesToolsDimension(_root) {
+    return await Promise.resolve({
+        id: CAPABILITIES_TOOLS_DIMENSION_ID,
+        status: "SKIP",
+        findings: [{ reason: CAPABILITIES_SKIP_REASON, skip: true }],
+    });
+}
+//# sourceMappingURL=doctor-readiness-capabilities.js.map

package/dist/cli/doctor-readiness-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-capabilities.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-capabilities.ts"],"names":[],"mappings":"AAqBA,+EAA+E;AAC/E,MAAM,CAAC,MAAM,+BAA+B,GAAG,oBAAoB,CAAC;AAEpE,6EAA6E;AAC7E,MAAM,wBAAwB,GAC5B,4EAA4E;IAC5E,8EAA8E;IAC9E,qEAAqE;IACrE,8EAA8E;IAC9E,yEAAyE;IACzE,+DAA+D,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gCAAgC,CACpD,KAAa;IAEb,OAAO,MAAM,OAAO,CAAC,OAAO,CAAC;QAC3B,EAAE,EAAE,+BAA+B;QACnC,MAAM,EAAE,MAAM;QACd,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,wBAAwB,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;KAC7D,CAAC,CAAC;AACL,CAAC"}

package/dist/cli/doctor-readiness-context-claims.d.ts

@@ -0,0 +1,14 @@
+/** One enforcement claim read out of an instruction surface. */
+export interface EnforcementClaim {
+    readonly file: string;
+    readonly line: number;
+    readonly text: string;
+    readonly mechanisms: readonly string[];
+}
+/**
+ * Read every instruction surface a repository declares.
+ * @param root - Repository root
+ * @returns Every enforcement claim, in stable file order
+ */
+export declare function collectClaims(root: string): Promise<readonly EnforcementClaim[]>;
+//# sourceMappingURL=doctor-readiness-context-claims.d.ts.map

package/dist/cli/doctor-readiness-context-claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-context-claims.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-context-claims.ts"],"names":[],"mappings":"AA+CA,gEAAgE;AAChE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CACxC;AAkED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,SAAS,gBAAgB,EAAE,CAAC,CAWtC"}

package/dist/cli/doctor-readiness-context-claims.js

@@ -0,0 +1,117 @@
+/**
+ * Enforcement-claim extraction for the context-routing readiness producer
+ * (B6, PRD #1739, #1896).
+ *
+ * B6 compares what the repository's instruction surfaces promise against the
+ * machinery that would have to deliver it. This module does the reading half —
+ * finding the sentences that assert a guarantee and the repository paths they
+ * name — while its sibling turns those claims into the rubric-shaped dimension
+ * record. Splitting them keeps each file inside the repository's file-size
+ * budget and keeps the (deliberately conservative) claim grammar in one place.
+ *
+ * Every filter here is a false-positive guard. A false B6 tells an operator
+ * their documentation lies when it does not, so a sentence is treated as a
+ * claim only when it asserts a guarantee, is not hedged, and is not inside a
+ * fenced code block — and a token is treated as a mechanism only when it is a
+ * checkable repository path.
+ * @module cli/doctor-readiness-context-claims
+ */
+import { readdir } from "node:fs/promises";
+import * as path from "node:path";
+import { isMechanismPath } from "./doctor-readiness-context-mechanisms.js";
+import { readFileOrNull } from "./doctor-readiness-shared.js";
+/** The instruction surfaces whose enforcement claims are cross-checked. */
+const CLAIM_SOURCE_FILES = ["README.md", "AGENTS.md"];
+/** The rules directory whose every `.md` file is an instruction surface. */
+const RULES_DIR = path.join(".claude", "rules");
+/**
+ * Phrases that assert a guarantee something else must enforce. Deliberately
+ * narrow: a loose verb list ("uses", "checks") would sweep in ordinary prose and
+ * turn B6 into noise the operator learns to ignore.
+ */
+const ENFORCEMENT_CLAIM = /\b(is enforced|are enforced|enforced by|enforces|is blocked by|are blocked by|blocked by|always runs|runs on every|required check|is required|hard-fails|automatically runs|automatically loaded)\b/i;
+/**
+ * Words that turn a sentence into an illustration, a possibility, or a plan.
+ * A hedged sentence claims nothing, so it can overstate nothing.
+ */
+const HEDGED_CLAIM = /\b(example|e\.g\.|i\.e\.|for instance|if you|would|could|may|might|should|todo|planned|future|suppose|imagine|placeholder|instead of|rather than|used to)\b/i;
+/** Inline-code spans, the only place a mechanism is read from. */
+const INLINE_CODE = /`([^`\n]+)`/g;
+/**
+ * Extract the mechanism paths a claim line names.
+ * @param line - The raw documentation line
+ * @returns Repo-relative mechanism paths, deduplicated
+ */
+function namedMechanisms(line) {
+    const tokens = [...line.matchAll(INLINE_CODE)]
+        .map(match => (match[1] ?? "").trim())
+        .filter(isMechanismPath)
+        .map(token => token.replace(/\/$/, ""));
+    return [...new Set(tokens)];
+}
+/**
+ * Read the enforcement claims out of one instruction surface. Fenced code blocks
+ * are skipped wholesale: a sample inside a fence documents a shape, not this
+ * repository's guarantees.
+ * @param file - Repo-relative file path
+ * @param source - File contents
+ * @returns The enforcement claims the file makes
+ */
+function extractClaims(file, source) {
+    return proseLines(source)
+        .filter(entry => ENFORCEMENT_CLAIM.test(entry.text) && !HEDGED_CLAIM.test(entry.text))
+        .map(entry => ({
+        file,
+        line: entry.line,
+        text: entry.text.trim(),
+        mechanisms: namedMechanisms(entry.text),
+    }));
+}
+/**
+ * Split a document into its prose lines, dropping fenced code blocks entirely.
+ * A line is inside a fence when an odd number of fence markers precede it, which
+ * is what makes the fence state derivable per line rather than accumulated.
+ * @param source - File contents
+ * @returns The prose lines, each carrying its 1-based line number
+ */
+function proseLines(source) {
+    const lines = source.split("\n");
+    const fences = lines.flatMap((text, index) => text.trim().startsWith("```") ? [index] : []);
+    return lines.flatMap((text, index) => {
+        const openFences = fences.filter(fence => fence < index).length;
+        return fences.includes(index) || openFences % 2 === 1
+            ? []
+            : [{ line: index + 1, text }];
+    });
+}
+/**
+ * Read every instruction surface a repository declares.
+ * @param root - Repository root
+ * @returns Every enforcement claim, in stable file order
+ */
+export async function collectClaims(root) {
+    const ruleFiles = await listRuleFiles(root);
+    const sources = await Promise.all([...CLAIM_SOURCE_FILES, ...ruleFiles].map(async (file) => ({
+        file,
+        source: await readFileOrNull(root, file),
+    })));
+    return sources.flatMap(({ file, source }) => source === null ? [] : extractClaims(file, source));
+}
+/**
+ * List the `.claude/rules/*.md` instruction files.
+ * @param root - Repository root
+ * @returns Repo-relative rule file paths, sorted
+ */
+async function listRuleFiles(root) {
+    try {
+        const entries = await readdir(path.join(root, RULES_DIR));
+        return entries
+            .filter(entry => entry.endsWith(".md"))
+            .sort((a, b) => a.localeCompare(b))
+            .map(entry => `${RULES_DIR.split(path.sep).join("/")}/${entry}`);
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=doctor-readiness-context-claims.js.map

package/dist/cli/doctor-readiness-context-claims.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-context-claims.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-context-claims.ts"],"names":[],"mappings":"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"}

package/dist/cli/doctor-readiness-context-mechanisms.d.ts

@@ -0,0 +1,46 @@
+/** What a named mechanism turned out to be. */
+export type MechanismVerdict = 
+/** The named path exists — the documented guarantee is backed. */
+"present"
+/** The named path provably does not exist — this is what B6 stands on. */
+ | "missing"
+/** Not a checkable in-repository path, so it establishes nothing. */
+ | "unmappable";
+/** Decides whether a repository path is ignored/generated. */
+export type IgnoreMatcher = (relativePath: string) => boolean;
+/**
+ * Whether an inline-code span is even shaped like an in-repository path.
+ *
+ * Every exclusion is a false-positive guard: a URL is not a repo path, a glob
+ * names a set rather than a file, an `@` marks a scoped package or a versioned
+ * action reference rather than a path, and a placeholder names nothing.
+ * @param token - The inline-code text
+ * @returns True when the token is shaped like a repository path
+ */
+export declare function isMechanismPath(token: string): boolean;
+/**
+ * Build the ignore matcher for a repository from its `.gitignore` plus the
+ * always-generated defaults. The matcher is deliberately coarse — it compares
+ * path segments and directory prefixes rather than implementing gitignore's full
+ * grammar — because its only job is to move a doubtful path OUT of the violation
+ * set, where being over-inclusive is the safe direction.
+ * @param root - Repository root
+ * @returns A matcher that answers "is this path generated or ignored?"
+ */
+export declare function loadIgnoreMatcher(root: string): Promise<IgnoreMatcher>;
+/**
+ * Classify one named mechanism.
+ *
+ * A token only becomes checkable when the repository itself vouches for the
+ * shape: it carries a known file extension, it lives under a dot-directory the
+ * repository conventionally keeps machinery in, or its first segment is a real
+ * directory in this repository. `acme/release-gate` in a repository with no
+ * `acme/` directory is an `org/repo` slug as far as anything here can tell, so
+ * it is unmappable — not missing.
+ * @param root - Repository root
+ * @param token - The named mechanism path
+ * @param isIgnored - The repository's ignore matcher
+ * @returns What the mechanism turned out to be
+ */
+export declare function classifyMechanism(root: string, token: string, isIgnored: IgnoreMatcher): Promise<MechanismVerdict>;
+//# sourceMappingURL=doctor-readiness-context-mechanisms.d.ts.map

package/dist/cli/doctor-readiness-context-mechanisms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-context-mechanisms.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-context-mechanisms.ts"],"names":[],"mappings":"AA+CA,+CAA+C;AAC/C,MAAM,MAAM,gBAAgB;AAC1B,kEAAkE;AAChE,SAAS;AACX,0EAA0E;GACxE,SAAS;AACX,qEAAqE;GACnE,YAAY,CAAC;AAEjB,8DAA8D;AAC9D,MAAM,MAAM,aAAa,GAAG,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;AAE9D;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAmBtD;AAED;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAmB5E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,aAAa,GACvB,OAAO,CAAC,gBAAgB,CAAC,CAa3B"}

package/dist/cli/doctor-readiness-context-mechanisms.js

@@ -0,0 +1,116 @@
+/**
+ * Mechanism classification for the context-routing readiness producer (B6,
+ * PRD #1739, #1896).
+ *
+ * B6 may only be stood up on a documented guarantee whose named mechanism
+ * provably does not exist. Deciding whether a backticked token even IS a
+ * checkable repository path is therefore the whole precision budget of the
+ * blocker, and a standing blocker flips the entire repository to `NOT_READY` —
+ * so every ambiguity here resolves to `unmappable`, never to `missing`.
+ *
+ * The three false-positive classes this module exists to kill, all of which look
+ * exactly like repository paths:
+ *
+ * - **Package names.** `@codyswann/lisa` is a dependency, not a file.
+ * - **Slugs and refs.** `CodySwannGT/lisa` and `origin/main` name a repository
+ *   and a git ref; neither is a path in the working tree.
+ * - **Generated artifacts.** `dist/cli.js` is absent from a clean checkout by
+ *   design, so faulting it would fault every repository that builds anything.
+ * @module cli/doctor-readiness-context-mechanisms
+ */
+import { directoryExists, pathExists, readFileOrNull, trimSlashes, } from "./doctor-readiness-shared.js";
+/** File extensions a named mechanism plausibly ends in. */
+const MECHANISM_EXTENSION = /\.(ya?ml|sh|bash|zsh|ts|tsx|js|mjs|cjs|json|jsonc|md|toml|cfg|ini)$/;
+/**
+ * Generated paths treated as ignored even when a repository ships no
+ * `.gitignore`. Their absence is a property of a clean checkout, never of
+ * documentation that lies.
+ */
+const ALWAYS_GENERATED = [
+    "node_modules",
+    "dist",
+    "build",
+    "coverage",
+    "out",
+    ".next",
+    ".turbo",
+    ".cache",
+];
+/**
+ * Whether an inline-code span is even shaped like an in-repository path.
+ *
+ * Every exclusion is a false-positive guard: a URL is not a repo path, a glob
+ * names a set rather than a file, an `@` marks a scoped package or a versioned
+ * action reference rather than a path, and a placeholder names nothing.
+ * @param token - The inline-code text
+ * @returns True when the token is shaped like a repository path
+ */
+export function isMechanismPath(token) {
+    const trimmed = token.trim();
+    if (trimmed === "" || /\s/.test(trimmed)) {
+        return false;
+    }
+    if (trimmed.includes("://") ||
+        trimmed.includes("*") ||
+        trimmed.includes("<") ||
+        trimmed.includes("$") ||
+        // A scoped package (`@acme/pkg`) or a pinned action (`actions/checkout@v4`)
+        // is a dependency coordinate, not a file this repository owns.
+        trimmed.includes("@") ||
+        trimmed.startsWith("/") ||
+        trimmed.startsWith("-")) {
+        return false;
+    }
+    return trimmed.includes("/") || MECHANISM_EXTENSION.test(trimmed);
+}
+/**
+ * Build the ignore matcher for a repository from its `.gitignore` plus the
+ * always-generated defaults. The matcher is deliberately coarse — it compares
+ * path segments and directory prefixes rather than implementing gitignore's full
+ * grammar — because its only job is to move a doubtful path OUT of the violation
+ * set, where being over-inclusive is the safe direction.
+ * @param root - Repository root
+ * @returns A matcher that answers "is this path generated or ignored?"
+ */
+export async function loadIgnoreMatcher(root) {
+    const source = (await readFileOrNull(root, ".gitignore")) ?? "";
+    const declared = source
+        .split("\n")
+        .map(line => line.trim())
+        .filter(line => line !== "" && !line.startsWith("#") && !line.startsWith("!"))
+        .map(trimSlashes)
+        .filter(line => line !== "" && !line.includes("*"));
+    const patterns = new Set([...ALWAYS_GENERATED, ...declared]);
+    return relativePath => relativePath
+        .split("/")
+        .some((segment, index, segments) => patterns.has(segments.slice(0, index + 1).join("/")) ||
+        patterns.has(segment));
+}
+/**
+ * Classify one named mechanism.
+ *
+ * A token only becomes checkable when the repository itself vouches for the
+ * shape: it carries a known file extension, it lives under a dot-directory the
+ * repository conventionally keeps machinery in, or its first segment is a real
+ * directory in this repository. `acme/release-gate` in a repository with no
+ * `acme/` directory is an `org/repo` slug as far as anything here can tell, so
+ * it is unmappable — not missing.
+ * @param root - Repository root
+ * @param token - The named mechanism path
+ * @param isIgnored - The repository's ignore matcher
+ * @returns What the mechanism turned out to be
+ */
+export async function classifyMechanism(root, token, isIgnored) {
+    if (isIgnored(token)) {
+        return "unmappable";
+    }
+    if (await pathExists(root, token)) {
+        return "present";
+    }
+    const [firstSegment = ""] = token.split("/");
+    const checkable = MECHANISM_EXTENSION.test(token) ||
+        firstSegment.startsWith(".") ||
+        (token.includes("/") && (await directoryExists(root, firstSegment)));
+    return checkable ? "missing" : "unmappable";
+}
+//# sourceMappingURL=doctor-readiness-context-mechanisms.js.map

package/dist/cli/doctor-readiness-context-mechanisms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-context-mechanisms.js","sourceRoot":"","sources":["../../src/cli/doctor-readiness-context-mechanisms.ts"],"names":[],"mappings":"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"}

package/dist/cli/doctor-readiness-context.d.ts

@@ -0,0 +1,16 @@
+import type { ReadinessDimensionRecord } from "./doctor-readiness-types.js";
+/** The context-routing readiness dimension id (readiness-rubric, RRR-1). */
+export declare const CONTEXT_ROUTING_DIMENSION_ID = "context-routing";
+/**
+ * Assess the context-routing dimension: B6, "documentation overstates enforced
+ * guarantees". Offline by construction — it reads only the repository's own
+ * instruction surfaces and the paths they name — and high-precision by design:
+ * it stands B6 only on a named mechanism that survives {@link classifyMechanism}
+ * and still demonstrably does not exist. The record's status is `WARN` rather
+ * than `FAIL`, but that is a confidence signal to a human reader only: a
+ * standing B6 blocker flips the repository to `NOT_READY` either way.
+ * @param root - Project root to assess
+ * @returns The context-routing dimension record
+ */
+export declare function assessContextRoutingDimension(root: string): Promise<ReadinessDimensionRecord>;
+//# sourceMappingURL=doctor-readiness-context.d.ts.map

package/dist/cli/doctor-readiness-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor-readiness-context.d.ts","sourceRoot":"","sources":["../../src/cli/doctor-readiness-context.ts"],"names":[],"mappings":"AA2CA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAC;AAE5E,4EAA4E;AAC5E,eAAO,MAAM,4BAA4B,oBAAoB,CAAC;AAqN9D;;;;;;;;;;GAUG;AACH,wBAAsB,6BAA6B,CACjD,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,wBAAwB,CAAC,CAoCnC"}