@nielspeter/eess-ts 0.2.0 → 0.4.0

package/dist/core/diagnose.js

@@ -0,0 +1,382 @@
+import { TerminalBuilder } from './terminal-builder.js';
+import { diagnoseGlob, syntacticFault, FAULT_ADVICE, ON_DISK_ADVICE } from './glob-diagnosis.js';
+import { globSitesOf, isDeadSite } from './glob-evaluator.js';
+import { pathUniverse } from './path-universe.js';
+import { diskSet } from './disk-set.js';
+import { isDeadGlobTree } from './glob-evaluator.js';
+import { emptyProjectAdvice, loadedNothing } from './empty-project-advice.js';
+import { isFaultPosition } from '@nielspeter/eess';
+/**
+ * Report what each rule cannot enforce, without evaluating their conditions.
+ *
+ * It DOES materialize each rule's selection, as of plan 0096 — "this rule
+ * examined nothing" is a fact about the selection. The docstring said "without
+ * running any of them" and that stopped being true; it is the IDE-hover contract
+ * for an exported function, so it is corrected here and not only in `docs/`.
+ *
+ * As of plan 0102, one family's `inertAdvice?()` goes further than selection:
+ * `inconsistentSiblings` walks every sibling body's AST to answer it (the same
+ * work `check()` does), so for that one family this IS evaluating the
+ * condition, not just counting what would be handed to it (review: architect).
+ * Still no `Condition.evaluate()` call — the boundary this docstring's
+ * predecessor drew — but "without evaluating" is no longer exactly right for
+ * every family, and is corrected here rather than left for the next reader to
+ * discover by profiling `doctor`.
+ *
+ * The in-process half of `doctor`. It exists because rules written inside
+ * vitest are a co-equal documented path (`docs/running-in-tests.md`), and a
+ * CLI-only diagnostic would leave half the users unable to measure before R3
+ * flips anything — which is the one job R2a has.
+ *
+ * Reports **identities, never totals**: which glob, in which rule, at which
+ * position. A count is a snapshot, and under ADR-009 rule 4 a snapshot is the
+ * thing that rots. Callers who want a number can take `.length`.
+ */
+export function diagnose(rules, project) {
+    const findings = [];
+    /**
+     * Projects already reported empty, by OBJECT not by path.
+     *
+     * The path is not an identity: `workspace([...])` sets `tsConfigPath` to the
+     * alphabetically first of N configs (`project.ts`), so a `workspace()` and a
+     * `project()` naming that same config collided — and the loser was dropped
+     * silently, contributing no finding at all. A false green inside the fix for
+     * a false green. `project()` and `workspace()` are both memoized, so object
+     * identity IS project identity, and it is what `pathUniverse` and `diskSet`
+     * already key on.
+     */
+    const emptyProjects = new WeakSet();
+    for (const rule of rules) {
+        const name = ruleName(rule);
+        // PER RULE, not once for the whole array. Taking the first project any
+        // rule could name and diagnosing everything against it is wrong in both
+        // directions: a rule file with two `project()` calls gets half its globs
+        // checked against the wrong universe — the documented monorepo hazard,
+        // committed by the diagnostic itself — and a file whose rules cannot name
+        // a project at all got silence.
+        // The rule's own project WINS over the parameter. Backwards, the parameter
+        // silently re-checks every rule against one universe — which is the
+        // documented monorepo hazard the paragraph above complains about, and the
+        // `project-unknown` advice used to recommend it. The parameter is a
+        // fallback for rules that cannot name a project, which is the only case it
+        // was ever needed for.
+        const target = rule.getProject?.() ?? project;
+        // Where this rule's findings begin, so the tail can ask whether anything
+        // else already explained an empty examination (plan 0096's precedence
+        // ruling). The gate has the same shape at `terminal-builder.ts` — each fault
+        // REPLACES what follows — and `diagnose()` must mirror it or the preview
+        // disagrees with the thing it previews.
+        //
+        // ABOVE the `no-condition` push, deliberately. It sat below on the first
+        // pass, so the tail could never see a missing assertion and measured
+        // ['no-condition','zero-subjects'] on three shapes — while the comment on
+        // the tail claimed a missing assertion already named a cause. The code
+        // contradicted its own comment.
+        const before = findings.length;
+        // A rule with a selector and no condition asserts nothing about what it
+        // selected. Reported here so that R3b's gate can see proposal 019 at all:
+        // a doctor that reported only glob faults would pass while 019's blast
+        // radius was completely unknown — this plan's own question, asked of its
+        // own gate.
+        if (hasNoCondition(rule)) {
+            findings.push({
+                kind: 'no-condition',
+                rule: name,
+                // The builder's own per-state remedy when it offers one — the same
+                // string the runtime prints — falling back to the generic form for a
+                // DiagnosableRule that predates the hook. The old fixed text here said
+                // "add a .should() clause", which is the wrong remedy for the main
+                // shape (the .should() is present; the condition is not).
+                // The builder's own per-state remedy. No literal fallback string here:
+                // an earlier revision hard-coded the generic text a second time, and a
+                // review measured either copy being rewritten with nothing failing —
+                // two strings in the mechanism whose stated purpose is one string, one
+                // place. A DiagnosableRule that predates the hook gets the base
+                // method's text, from the one place that owns it.
+                advice: rule.assertionAdvice?.() ?? TerminalBuilder.prototype.assertionAdvice.call(rule),
+            });
+        }
+        const trees = rule.globs?.() ?? [];
+        // Silence here would be a false green in the tool built to remove false
+        // greens: a rule that declares globs and cannot say which project to check
+        // them against used to be skipped, so a rule file made entirely of such
+        // rules reported a clean bill of health and exited 0 with every one of its
+        // globs unchecked. Say so instead.
+        //
+        // This comment used to name `crossLayer()` and `resolvers()` as the
+        // builders that could not name their project — and by the time it was read
+        // again, `48e3391` had given both a `getProject()`, so it named as examples
+        // the two shapes the fix had repaired. `tests/core/diagnose.test.ts` pins
+        // the truth in both directions: one test drives this branch, and a second
+        // asserts a `crossLayer` rule does NOT reach it. Hence no roster and no
+        // count here — a builder reaches this branch exactly when it implements no
+        // `getProject()` and no project was passed in, which is checked on the
+        // line below rather than remembered in prose.
+        if (!target) {
+            if (trees.length > 0) {
+                findings.push({
+                    kind: 'project-unknown',
+                    rule: name,
+                    advice: 'this rule declares globs but cannot say which project it was built against, so they were not checked. A builder constructed directly rather than through its entry point has no project to report',
+                });
+                // ...but the syntactic faults do not need a project, so they are still
+                // reported here rather than held back for a run that may never happen.
+                findings.push(...syntacticFindings(name, trees));
+            }
+            // Evidence is a fact about the FAMILY, not about whether we could name its
+            // project — so this branch reports it too. Under the SAME gate as the tail:
+            // pushed unconditionally it produced ['project-unknown','dead-glob',
+            // 'zero-subjects'], the very shape this plan condemns, on the one path the
+            // ruling had not been extended to.
+            if (findings.length === before) {
+                const noProjectEvidence = zeroSubjectsFinding(rule, name);
+                if (noProjectEvidence !== undefined)
+                    findings.push(noProjectEvidence);
+            }
+            continue;
+        }
+        // Bug 0031. When the project loaded nothing, EVERY glob is dead and none
+        // of them is the reason. Diagnosing them one by one produced six findings
+        // whose advice said "a path segment is misspelled" about correctly spelled
+        // globs, measured against a real adopting codebase whose root tsconfig is
+        // `"files": []` plus project references.
+        //
+        // The rule is not new here: `slice-rule-builder.ts` already states it —
+        // "blaming the glob would send the caller to the wrong file entirely" —
+        // and `check` printed the right cause in the same run this printed the
+        // wrong one.
+        //
+        // Once per PROJECT, not per rule and not per glob: the identity of this
+        // fault is the tsconfig, so that is what ADR-009 rule 4 asks be named.
+        // Deduped by path rather than by object because the path is what the
+        // message prints, and printing one sentence twice is the thing being
+        // fixed.
+        if (loadedNothing(target)) {
+            if (!emptyProjects.has(target)) {
+                emptyProjects.add(target);
+                findings.push({
+                    kind: 'project-empty',
+                    rule: name,
+                    // One owner, shared with the builder's failing-check message. The
+                    // clause "Reported once for this project" used to be here and was
+                    // FALSE on the primary surface: `doctor` calls `diagnose()` once per
+                    // rule file, so two files against one empty tsconfig printed the
+                    // sentence claiming it was printed once, twice. Measured by review.
+                    advice: emptyProjectAdvice(target),
+                });
+            }
+            // The syntactic faults survive an empty project: they are properties of
+            // the glob text, not of what loaded, so withholding them buys the reader
+            // a second failing round trip.
+            findings.push(...syntacticFindings(name, trees));
+            // Skip the rest of the glob walk. Not an optimisation — reporting those
+            // globs is the bug, because every one would carry a cause that is false.
+            continue;
+        }
+        const universe = pathUniverse(target);
+        for (const tree of trees) {
+            // Only diagnose sites inside a tree that is actually dead. A live tree
+            // may still contain a dead site — `or(dead, live)` is a working rule —
+            // and reporting the dead one there is the false red the tree exists to
+            // prevent.
+            if (!isDeadGlobTree(tree, universe))
+                continue;
+            for (const site of globSitesOf(tree)) {
+                // An exclusion matching zero is remedy-optional (proposal 006) and
+                // never a fault, and a positive condition glob is indistinguishable
+                // from an armed tripwire that has not fired. Reporting either asserts
+                // a remedy for a non-fault — and `position` used to be copied into the
+                // finding and never read, so both fired.
+                if (!isFaultPosition(site.position))
+                    continue;
+                if (!isDeadSite(site, universe))
+                    continue;
+                findings.push(describe(site, name, universe, target));
+            }
+        }
+        // LAST, and only if nothing else spoke for this rule. A dead glob, a missing
+        // assertion or an empty project each already names a cause with its own
+        // remedy; adding "your narrowing removed everything" beside one of them
+        // prints the derived symptom above the root cause, with advice that is false
+        // on that path. The first attempt emitted this first and unconditionally,
+        // which measured as ['zero-subjects','dead-glob'] for a single typo and
+        // broke the invariant bug 0040 is filed for — that `diagnose()` and the gate
+        // agree about a dead discovery glob.
+        if (findings.length === before) {
+            const evidence = zeroSubjectsFinding(rule, name);
+            if (evidence !== undefined)
+                findings.push(evidence);
+        }
+        // A DISTINCT branch, not folded into the zeroSubjectsFinding guard above:
+        // inertAdvice() only returns non-empty when examinedUnits() > 0 (plan
+        // 0102's own guard requires `matching > 0`), so the two are structurally
+        // mutually exclusive and this never doubles up with the zero-subjects
+        // finding above. Unconditional (not gated on `findings.length === before`)
+        // because the emptiness precedence above governs a different axis
+        // (evidence present vs. absent); this axis is evidence present vs.
+        // adequate, and nothing else in this loop speaks to it.
+        const inert = inertFinding(rule, name);
+        if (inert !== undefined)
+            findings.push(inert);
+        // Also unconditional, and naturally exclusive from the two branches above:
+        // `deferredWarningAdvice()` only fires when `.violations()` returns at
+        // least one `error`-severity result, which cannot happen when examined
+        // units is zero (zero-subjects) or the family's own adequacy predicate says
+        // this rule can never produce a finding (inert) — both of those states mean
+        // no violations at all, so `breaching.length` is `0` and this stays silent.
+        const deferred = deferredWarningFinding(rule, name);
+        if (deferred !== undefined)
+            findings.push(deferred);
+    }
+    return findings;
+}
+/**
+ * A rule that examined nothing, when nothing else explained why — plan 0096.
+ *
+ * Returns `undefined` unless the family answers `examinedUnits()` and answered
+ * zero. Two callers, on purpose: the project-unknown branch (a family with no
+ * project still has evidence — `crossProject` and `schemaFromSDL` have no
+ * `ArchProject` at all, and the first attempt gated this on one and gave those
+ * two families no preview whatsoever) and the tail of the normal path.
+ *
+ * NOT called from the project-empty branch. That fault is the instrument, it
+ * already has its own finding, and reporting both would print one fault twice
+ * — and prefigure 0098's precedence backwards, where an empty project outranks
+ * every declaration because a declaration asserts a fact about a loaded corpus.
+ */
+function zeroSubjectsFinding(rule, name) {
+    if (rule.examinedUnits === undefined)
+        return undefined;
+    if (rule.examinedUnits() !== 0)
+        return undefined;
+    // The author said empty is the point. Reporting anyway would make the advice
+    // below a remedy the reader has already applied — ADR-009 rule 2's loop — and
+    // would over-report against 0098's floor, which honours the same mint. That
+    // the mint exists at all is why 0097 shipped first; this is its first reader.
+    if (rule.declaresEmpty?.() === true)
+        return undefined;
+    // `.notExist()` examines zero BECAUSE that is what it asserts — the gate has
+    // exempted this since 0.34.0 and the preview must agree, or `doctor` reports a
+    // working rule as broken. Plan 0098: the rule-builder family is the first to
+    // report evidence, so this is the first release in which the two could differ.
+    if (rule.assertsCardinality?.() === true)
+        return undefined;
+    return {
+        kind: 'zero-subjects',
+        rule: name,
+        // ONE cause, because precedence has already removed the others: this fires
+        // only when no dead glob, missing assertion or empty project explained the
+        // emptiness first. So the remedy can name that cause without the hedging
+        // ADR-009 rule 2 forbids — and it must not say "your filters", because the
+        // commonest trigger is a default the author never wrote (`minLines` is 5).
+        // VERBATIM from the rule when it can speak, so this preview and the gate
+        // cannot drift. The fallback is for a foreign dialect that predates the seam;
+        // it deliberately no longer promises "a later release makes this fail" — that
+        // release is this one.
+        // NO fallback literal. It was a six-line copy of the producer's sentence —
+        // dead for every real builder (every `TerminalBuilder` has the method), never
+        // referenced by a test, and already diverging: no unit noun, no file count,
+        // no narrowing hint. The seam exists because "two texts for one state is the
+        // plan-0070 drift shape"; a fallback is that second text, one level down, in
+        // the commit that added the seam.
+        //
+        // A duck-typed `DiagnosableRule` that cannot answer simply has no advice to
+        // report, which is honest — better than core inventing a sentence for a
+        // family whose units and remedies it does not know.
+        advice: rule.zeroSubjectsAdvice?.() ??
+            'this rule examined 0 units, so it enforces nothing as written today.',
+    };
+}
+/**
+ * A rule whose evidence is non-empty but which is structurally unable to ever
+ * produce a finding as configured — plan 0102, bug 0077(A).
+ *
+ * Mirrors `zeroSubjectsFinding`'s shape: returns `undefined` unless the family
+ * answers `inertAdvice()` and answers non-empty. No fallback literal, for the
+ * same reason `zeroSubjectsFinding` has none — a family that cannot answer has
+ * no advice to report, which is honest; core does not invent a sentence for an
+ * adequacy predicate it does not own.
+ */
+function inertFinding(rule, name) {
+    const advice = rule.inertAdvice?.();
+    if (advice === undefined || advice === '')
+        return undefined;
+    return { kind: 'inert', rule: name, advice };
+}
+/** A deferred warning whose accepted list no longer covers everything it finds — plan 0090. */
+function deferredWarningFinding(rule, name) {
+    const advice = rule.deferredWarningAdvice?.();
+    if (advice === undefined || advice === '')
+        return undefined;
+    return { kind: 'deferred-warning', rule: name, advice };
+}
+/**
+ * The faults that need no project at all, reported on the branches that have none.
+ *
+ * `syntacticFault` takes `(glob, kind, base)` — no universe, no project — and
+ * is split out for exactly that reason. `'./src/**'` is dead in every possible
+ * project; loading the tsconfig will not fix it. Both early exits below (the
+ * project is unknown, the project is empty) used to swallow these, so the
+ * reader corrected their config, re-ran, and only then learned the glob was
+ * also malformed — a second round trip for a fault already decided.
+ *
+ * Reported by review. Applies to the pre-existing `project-unknown` branch too,
+ * which had the same hole.
+ */
+function syntacticFindings(rule, trees) {
+    const findings = [];
+    for (const tree of trees) {
+        for (const site of globSitesOf(tree)) {
+            // Same position filter as the main path: an exclusion or condition glob
+            // matching nothing is not a fault, and that does not change because the
+            // fault is syntactic.
+            if (!isFaultPosition(site.position))
+                continue;
+            const fault = syntacticFault(site.glob, site.kind, site.base);
+            if (fault === undefined)
+                continue;
+            findings.push({
+                kind: 'dead-glob',
+                rule,
+                origin: site.origin,
+                glob: site.glob,
+                position: site.position,
+                fault,
+                advice: FAULT_ADVICE[fault],
+            });
+        }
+    }
+    return findings;
+}
+function describe(site, rule, universe, project) {
+    // The disk set is reached only from here, so a project with no dead globs
+    // never walks the filesystem.
+    const diagnosis = diagnoseGlob(site, universe, diskSet(project));
+    const onDiskAdvice = diagnosis.onDisk ? ON_DISK_ADVICE[diagnosis.onDisk] : '';
+    return {
+        kind: 'dead-glob',
+        rule,
+        origin: site.origin,
+        glob: site.glob,
+        position: site.position,
+        fault: diagnosis.fault,
+        onDisk: diagnosis.onDisk,
+        advice: onDiskAdvice === '' ? FAULT_ADVICE[diagnosis.fault] : onDiskAdvice,
+    };
+}
+function ruleName(rule) {
+    const described = rule.describeRule?.();
+    // `||` throughout, never `??`: `describeRule()` returns `rule: ''` for a bare
+    // entry point (no predicates, no conditions), and `'' ` is not nullish — so
+    // `?? 'unnamed rule'` made the fallback dead code and `doctor` printed an
+    // empty rule name for precisely the shape this diagnostic is about. Caught by
+    // sabotage, not by reading. The gate derives the same name in
+    // `TerminalBuilder.collectWithAssertionGuard`; both must be non-empty, and
+    // both are asserted so.
+    return described?.id || described?.rule || 'unnamed rule';
+}
+/** Whether the rule reached a terminal with no condition attached. */
+function hasNoCondition(rule) {
+    return rule.assertsSomething?.() === false;
+}
+//# sourceMappingURL=diagnose.js.map

package/dist/core/diagnose.js.map

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

package/dist/core/disk-set.d.ts

@@ -0,0 +1,48 @@
+import type { ArchProject } from './project.js';
+/**
+ * What the filesystem says about a glob that the compiler's file set does not.
+ *
+ * Only populated for `no-match` — the other faults are syntactic and the disk
+ * has nothing to add. `not-determined` is the honest answer above the walk's
+ * entry budget, or where the walk refused to look.
+ *
+ * Declared here rather than in `glob-diagnosis.ts` because this is the module
+ * that produces it: the other way round made the two files import each other.
+ * Both edges were `import type` and therefore erased at runtime — but our own
+ * `arch/no-cycles` rule slices by directory, so it could not see a cycle
+ * INSIDE `core/`, and a per-file slicing in a test found it immediately. A
+ * cycle nothing can see is the shape this whole plan is about.
+ */
+export type OnDisk = 'holds-typescript' | 'no-typescript' | 'absent' | 'not-determined';
+/**
+ * What the filesystem knows that the compiler's file set does not.
+ *
+ * The second derivation ADR-009 rule 5 asks for: filesystem contents versus
+ * compiler membership. It is what distinguishes "your glob is misspelled" from
+ * "your glob is fine and your tsconfig scope excludes it" — the cheapest wrong
+ * action an agent can take, and the majority case in a real monorepo.
+ */
+export interface DiskSet {
+    /** Classify a glob by what exists on disk under the paths it matches. */
+    classify(glob: string): OnDisk;
+}
+/**
+ * The project's disk set, walked at most once and only when asked.
+ *
+ * Lazy on purpose. This is only ever reached from `diagnoseGlob`, which is
+ * only ever reached from an already-firing fault, so a project with no faults
+ * never touches the filesystem. An eager version would charge every `check()`
+ * a recursive walk to answer a question no fault asked.
+ */
+export declare function diskSet(project: ArchProject): DiskSet;
+/**
+ * The walk, with the budget injectable.
+ *
+ * Exported for tests only. The degrade path is the difference between "not
+ * determined" and a *partial, wrong* classification — a false "contains no
+ * TypeScript" in the one message whose whole defence is that it states only
+ * facts — and with the budget a module constant it could only ever have been
+ * reached by accident on a repository nobody has.
+ */
+export declare function buildDiskSet(project: ArchProject, budgetLimit?: number): DiskSet;
+//# sourceMappingURL=disk-set.d.ts.map

package/dist/core/disk-set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disk-set.d.ts","sourceRoot":"","sources":["../../src/core/disk-set.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAkD/C;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,MAAM,GAAG,kBAAkB,GAAG,eAAe,GAAG,QAAQ,GAAG,gBAAgB,CAAA;AAEvF;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,yEAAyE;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;CAC/B;AAID;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAMrD;AAED;;;;;;;;GAQG;AAEH,wBAAgB,YAAY,CAAC,OAAO,EAAE,WAAW,EAAE,WAAW,SAAe,GAAG,OAAO,CAEtF"}