@jjchill/probity-rules 0.1.0

package/dist/presets/kmp.js

@@ -0,0 +1,253 @@
+/**
+ * Probity rule-entry factory — Kotlin Multiplatform preset.
+ *
+ * Same enforcement as the Kotlin preset, recalibrated for a KMP
+ * codebase with ports-and-adapters codified per feature module:
+ * source sets (`commonMain`/`androidMain`/`desktopMain`/`iosMain`,
+ * tests in `commonTest`/`androidHostTest`/…), core vs adapter split
+ * by package (`domain`/`port`/`usecase`/`presentation` vs
+ * `adapter`/`di`/`ui`), kotlin.test + hand-written fakes with NO
+ * mocking library, Koin at the composition root only, and
+ * acceptance tests driven through a Robot DSL at the ViewModel
+ * boundary with Markdown Given/When/Then specs in docs/specs/.
+ * Adjust globs and package names to your layout.
+ *
+ * Probity still runs on Node: `npm install -D @nizos/probity`
+ * (plus optionally @ast-grep/napi @ast-grep/lang-kotlin for the TDD
+ * fast-path) next to gradlew.
+ */
+import { join } from 'node:path';
+import { enforceTdd, forbidContentPattern } from '@nizos/probity';
+import { enforceAcceptanceLanguage, withAcceptanceLanguageFastPath, } from '../rules/acceptance-language.js';
+import { enforceSpecTestParity, requireSpecBackedAcceptanceTest, surfaceScenarioLinkBreakage, } from '../rules/spec-test-parity.js';
+import { surfaceGlossaryTermBreakage } from '../rules/ubiquitous-language.js';
+import { enforceProbeReversion, forbidNewAmbientEffects, GRADLE_TEST_COMMAND, KOTLIN_BOUNDARY_ADDENDUM, KOTLIN_INFRASTRUCTURE_IMPORTS, MOCKING_LIBRARY_IMPORTS, requireGreenTestRun, withKotlinFastPath, withMutationProbe, withTelemetryFastPath, } from '../rules/kotlin.js';
+import { enforceAdapterObservability, enforcePortsBoundary, } from '../rules/ports-and-adapters.js';
+/**
+ * The rule entries, as a factory over the project root. Probity only
+ * reads the default export below; the factory exists so tooling can
+ * instantiate the exact same blocks against a different root — the
+ * workflow eval runs them in a temp directory, and
+ * `scripts/scope-report.ts` resolves their `files` scopes against the
+ * real tree. Keeping the entries in one place is what lets the eval's
+ * scoping stay derived from this config instead of hand-mirrored.
+ *
+ * Relative globs (`docs/...`) are NOT anchored here: Probity's
+ * `loadConfig` anchors them against this file's directory at load
+ * time, and the tooling replicates that via `rules/scoping.ts`.
+ *
+ * `parity` optionally switches on the per-scenario driver mapping
+ * (`driverScopes`/`defaultScopes` on the commit-time parity gate) —
+ * projects normally enable it by uncommenting the block in the
+ * `enforceSpecTestParity` call below; the parameter exists so the
+ * workflow eval can exercise the scope checks without changing the
+ * template's default-off posture.
+ */
+export function kmpRuleEntries(root, parity) {
+    // Ubiquitous-language glossary (copy GLOSSARY.template.md here).
+    // The glossary-aware rules degrade gracefully while the file
+    // doesn't exist yet — wiring it up front costs nothing.
+    const glossary = join(root, 'docs/GLOSSARY.md');
+    // Core purity scope — the inside of the hexagon: domain, ports,
+    // use cases, and MVI presentation in commonMain. Adapter, DI, and
+    // Compose ui packages import vendors by design — excluded.
+    const CORE_GLOBS = [
+        '**/src/commonMain/**/domain/**',
+        '**/src/commonMain/**/port/**',
+        '**/src/commonMain/**/usecase/**',
+        '**/src/commonMain/**/presentation/**',
+    ];
+    // Rule ordering principle: Probity stops at the first violation, so
+    // every deterministic screen (pattern match, free, instant) is
+    // listed before any AI-validated rule (a model call per matching
+    // write). A write with a vendor import in core code must be
+    // rejected by the free import screen, not after a TDD model call.
+    return [
+        // ── Deterministic wall ───────────────────────────────────────────
+        // Core import/effect screens. The import screen also catches Koin
+        // here: DI stays at the composition root, never in domain code.
+        {
+            files: CORE_GLOBS,
+            rules: [
+                forbidContentPattern({
+                    match: KOTLIN_INFRASTRUCTURE_IMPORTS,
+                    reason: 'Core code imports an infrastructure/vendor package (this ' +
+                        'screen includes Koin — DI belongs at the composition ' +
+                        'root). The Dependency Rule: core imports nothing from ' +
+                        'frameworks, vendors, or OS I/O — define a port and reach ' +
+                        'the dependency through an adapter (see the ' +
+                        'ports-and-adapters skill).',
+                }),
+                forbidNewAmbientEffects({
+                    seamHint: 'This codebase injects function-typed providers (e.g. ' +
+                        'nowEpochMillis: () -> Long) with real defaults supplied ' +
+                        'only in platform adapters or DI modules',
+                }),
+            ],
+        },
+        // No mocking library at all: this convention is hand-written
+        // fakes substituted at ports (shared via testfixtures modules).
+        {
+            files: ['**/src/*Test/kotlin/**', '**/src/test/kotlin/**'],
+            rules: [
+                forbidContentPattern({
+                    match: MOCKING_LIBRARY_IMPORTS,
+                    reason: 'This codebase uses no mocking library: substitute a ' +
+                        'hand-written fake at the port (see the shared test ' +
+                        'fixtures), never mock an SDK or framework type. Ports ' +
+                        'are the only test seam.',
+                }),
+            ],
+        },
+        // Spec↔test traceability. Editing a spec must not silently break
+        // the tests that claim its scenarios: removing or renaming a
+        // `## Scenario:` heading still covered by a test blocks with the
+        // list of affected tests, so the rename updates its Covers: tags
+        // in the same change.
+        {
+            files: ['docs/specs/**/*.feature.md'],
+            rules: [surfaceScenarioLinkBreakage({ testRoots: [root] })],
+        },
+        // Spec-first, at write time: adding a new acceptance test case
+        // requires a new Covers: tag resolving to a scenario that already
+        // exists in docs/specs — the feature file is written before the
+        // test that claims it. Scoped to the test-case layer only
+        // (*Spec.kt); drivers/DSL/scenario bodies add no @Test functions.
+        {
+            files: ['**/acceptance/**/*Spec.kt', '**/acceptance/**/*Test.kt'],
+            rules: [
+                requireSpecBackedAcceptanceTest({ specsDir: join(root, 'docs/specs') }),
+            ],
+        },
+        // Ubiquitous-language drift: renaming or removing a glossary term
+        // that specs, tests, or code still use blocks the glossary edit
+        // with the list of users.
+        {
+            files: ['docs/GLOSSARY.md'],
+            rules: [surfaceGlossaryTermBreakage({ searchRoots: [root] })],
+        },
+        // ── AI-validated judgment layer ──────────────────────────────────
+        // Inner loop: test-driven-development. `src/*Main` / `src/*Test`
+        // cover every KMP source set (commonMain, androidMain, commonTest,
+        // androidHostTest, …); main/test cover classic Android app modules
+        // alongside them. The Kotlin fast-path keeps the most common write
+        // (a single new @Test) deterministic. The mutation-probe wrapper
+        // lets a write marked `// probity: mutation-probe` (a deliberate
+        // break proving a retrofitted test bites) through without a
+        // red-before-green demand — enforceProbeReversion below blocks
+        // commits until the probe is reverted.
+        {
+            files: [
+                '**/src/*Main/kotlin/**',
+                '**/src/*Test/kotlin/**',
+                '**/src/main/kotlin/**',
+                '**/src/test/kotlin/**',
+            ],
+            // Telemetry-only additions (a complete logger.event/breadcrumb
+            // line) pass deterministically — instrumentation demanded by the
+            // adapter-observability rule must not be judged as unasserted
+            // behavior by the TDD gate.
+            rules: [
+                withMutationProbe(withTelemetryFastPath(withKotlinFastPath(enforceTdd()))),
+            ],
+        },
+        // Boundaries: ports-and-adapters. The Dependency Rule judgments
+        // the import screen can't make — thin adapters, vendor types in
+        // port signatures, glossary-conflicting names.
+        {
+            files: CORE_GLOBS,
+            rules: [
+                enforcePortsBoundary({
+                    instructions: (defaults) => defaults + KOTLIN_BOUNDARY_ADDENDUM,
+                    glossaryPath: glossary,
+                }),
+            ],
+        },
+        // Adapters must be thin, but not blind: a new adapter path doing
+        // external I/O carries boundary observability (structured event,
+        // port tap, or span). Delta-based — legacy uninstrumented paths
+        // migrate incrementally.
+        {
+            files: ['**/src/*Main/kotlin/**/adapter/**'],
+            rules: [
+                withTelemetryFastPath(enforceAdapterObservability({
+                    conventionHint: 'This codebase uses structured Logger.event(tag, event, ' +
+                        'level, fields) from :foundation (one greppable line: ' +
+                        'event=<name> k=v), and/or a recording port-tap decorator ' +
+                        'wired at the Koin composition root.',
+                })),
+            ],
+        },
+        // Outer loop: acceptance-testing. The Language Test on the spec
+        // layer: Markdown Given/When/Then specs and the acceptance test
+        // cases. Robot/DSL/driver classes are layers 2-3 (they know about
+        // UiState and MVI intents) — excluded, whichever of the two
+        // layouts a feature uses (merged *Robot.kt, or split *Dsl.kt +
+        // *Driver.kt per the four-layer model). Shared scenario-body
+        // files (*Scenarios.kt — the bodies both drivers run) are layer 1
+        // and stay INCLUDED by design: they must read as pure domain
+        // language.
+        {
+            files: [
+                'docs/specs/**/*.feature.md',
+                '**/acceptance/**',
+                '!**/*Robot.kt',
+                '!**/*Dsl.kt',
+                '!**/*Driver.kt',
+            ],
+            // requireGlossaryEntry: true is the strict "glossary
+            // conversation happens first" mode — turn it on once the
+            // glossary has real coverage, not on day one. The fast-path
+            // wrapper keeps a single-@Test write that only reuses existing
+            // DSL vocabulary free of AI calls (Markdown specs always go to
+            // the validator).
+            rules: [
+                withAcceptanceLanguageFastPath(enforceAcceptanceLanguage({ glossaryPath: glossary })),
+            ],
+        },
+        // ── Ship gates ───────────────────────────────────────────────────
+        // Definition of done, made mechanical: every non-wip scenario in
+        // docs/specs is claimed by an acceptance test (Covers: tag), and
+        // every tag resolves to a real scenario. Mark in-progress specs
+        // `## Scenario (wip):`. CI mirror for human commits:
+        // scripts/spec-parity.mjs.
+        //
+        // Brownfield adoption: a spec suite that predates the gate would
+        // block every commit. Generate a baseline once —
+        //   node scripts/spec-parity.mjs --specs docs/specs \
+        //     --baseline docs/specs/.parity-baseline --write-baseline
+        // — and commit it: baselined scenarios are exempt while new ones
+        // are enforced from day one; burn the file down by deleting lines
+        // as coverage lands. No baseline file → full enforcement.
+        //
+        // Per-scenario driver mapping (optional): declare named driver
+        // scopes and tag scenarios that need more than the default suite —
+        // `## Scenario [system]: …` then requires a covering test whose
+        // path matches that scope. Tags are floors, not ceilings; with
+        // shared scenario bodies (*Scenarios.kt) the extra covering test
+        // is a thin spec class calling the existing body. CALIBRATE THE
+        // PATTERNS TO YOUR LAYOUT before uncommenting — a pattern matching
+        // zero files makes every tagged scenario fail, loudly.
+        enforceSpecTestParity({
+            specsDir: join(root, 'docs/specs'),
+            testRoots: [root],
+            baselinePath: join(root, 'docs/specs/.parity-baseline'),
+            // driverScopes: [
+            //   { name: 'view-model', filePattern: /[/\\]acceptance[/\\]viewmodel[/\\]/ },
+            //   { name: 'system', filePattern: /[/\\]acceptance[/\\]ui[/\\]/ },
+            // ],
+            // defaultScopes: ['view-model'],
+            ...parity,
+        }),
+        // The commit half of the mutation-probe round-trip: no commit
+        // while a `probity: mutation-probe` marker is still on disk —
+        // reverting the mutation removes the marker with it.
+        enforceProbeReversion({ roots: [root] }),
+        // Matches testAndroidHostTest, :feature:x:testAndroidHostTest,
+        // :desktop:jvmTest, allTests, :app:testDevDebugUnitTest. Stricter
+        // than Probity's requireCommand: the recorded run's output must
+        // actually be green, not merely exist.
+        requireGreenTestRun({ command: GRADLE_TEST_COMMAND }),
+    ];
+}
+//# sourceMappingURL=kmp.js.map

package/dist/presets/kmp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kmp.js","sourceRoot":"","sources":["../../presets/kmp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAkB,MAAM,gBAAgB,CAAA;AAIjF,OAAO,EACL,yBAAyB,EACzB,8BAA8B,GAC/B,MAAM,iCAAiC,CAAA;AACxC,OAAO,EACL,qBAAqB,EACrB,+BAA+B,EAC/B,2BAA2B,GAE5B,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAA;AAC7E,OAAO,EACL,qBAAqB,EACrB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,6BAA6B,EAC7B,uBAAuB,EACvB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,2BAA2B,EAC3B,oBAAoB,GACrB,MAAM,gCAAgC,CAAA;AAEvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,cAAc,CAC5B,IAAY,EACZ,MAAmE;IAEnE,iEAAiE;IACjE,6DAA6D;IAC7D,wDAAwD;IACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAA;IAE/C,gEAAgE;IAChE,kEAAkE;IAClE,2DAA2D;IAC3D,MAAM,UAAU,GAAU;QACxB,gCAAgC;QAChC,8BAA8B;QAC9B,iCAAiC;QACjC,sCAAsC;KACvC,CAAA;IAED,oEAAoE;IACpE,+DAA+D;IAC/D,iEAAiE;IACjE,4DAA4D;IAC5D,kEAAkE;IAElE,OAAO;QACL,oEAAoE;QAEpE,kEAAkE;QAClE,gEAAgE;QAChE;YACE,KAAK,EAAE,UAAU;YACjB,KAAK,EAAE;gBACL,oBAAoB,CAAC;oBACnB,KAAK,EAAE,6BAA6B;oBACpC,MAAM,EACJ,2DAA2D;wBAC3D,uDAAuD;wBACvD,wDAAwD;wBACxD,2DAA2D;wBAC3D,6CAA6C;wBAC7C,4BAA4B;iBAC/B,CAAC;gBACF,uBAAuB,CAAC;oBACtB,QAAQ,EACN,uDAAuD;wBACvD,0DAA0D;wBAC1D,yCAAyC;iBAC5C,CAAC;aACH;SACF;QAED,6DAA6D;QAC7D,gEAAgE;QAChE;YACE,KAAK,EAAE,CAAC,wBAAwB,EAAE,uBAAuB,CAAC;YAC1D,KAAK,EAAE;gBACL,oBAAoB,CAAC;oBACnB,KAAK,EAAE,uBAAuB;oBAC9B,MAAM,EACJ,sDAAsD;wBACtD,qDAAqD;wBACrD,wDAAwD;wBACxD,yBAAyB;iBAC5B,CAAC;aACH;SACF;QAED,iEAAiE;QACjE,6DAA6D;QAC7D,iEAAiE;QACjE,iEAAiE;QACjE,sBAAsB;QACtB;YACE,KAAK,EAAE,CAAC,4BAA4B,CAAC;YACrC,KAAK,EAAE,CAAC,2BAA2B,CAAC,EAAE,SAAS,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SAC5D;QAED,+DAA+D;QAC/D,kEAAkE;QAClE,gEAAgE;QAChE,0DAA0D;QAC1D,kEAAkE;QAClE;YACE,KAAK,EAAE,CAAC,2BAA2B,EAAE,2BAA2B,CAAC;YACjE,KAAK,EAAE;gBACL,+BAA+B,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC,EAAE,CAAC;aACxE;SACF;QAED,kEAAkE;QAClE,gEAAgE;QAChE,0BAA0B;QAC1B;YACE,KAAK,EAAE,CAAC,kBAAkB,CAAC;YAC3B,KAAK,EAAE,CAAC,2BAA2B,CAAC,EAAE,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SAC9D;QAED,oEAAoE;QAEpE,iEAAiE;QACjE,mEAAmE;QACnE,mEAAmE;QACnE,mEAAmE;QACnE,iEAAiE;QACjE,iEAAiE;QACjE,4DAA4D;QAC5D,+DAA+D;QAC/D,uCAAuC;QACvC;YACE,KAAK,EAAE;gBACL,wBAAwB;gBACxB,wBAAwB;gBACxB,uBAAuB;gBACvB,uBAAuB;aACxB;YACD,+DAA+D;YAC/D,iEAAiE;YACjE,8DAA8D;YAC9D,4BAA4B;YAC5B,KAAK,EAAE;gBACL,iBAAiB,CACf,qBAAqB,CAAC,kBAAkB,CAAC,UAAU,EAAE,CAAC,CAAC,CACxD;aACF;SACF;QAED,gEAAgE;QAChE,gEAAgE;QAChE,+CAA+C;QAC/C;YACE,KAAK,EAAE,UAAU;YACjB,KAAK,EAAE;gBACL,oBAAoB,CAAC;oBACnB,YAAY,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,GAAG,wBAAwB;oBAC/D,YAAY,EAAE,QAAQ;iBACvB,CAAC;aACH;SACF;QAED,iEAAiE;QACjE,iEAAiE;QACjE,gEAAgE;QAChE,yBAAyB;QACzB;YACE,KAAK,EAAE,CAAC,mCAAmC,CAAC;YAC5C,KAAK,EAAE;gBACL,qBAAqB,CACnB,2BAA2B,CAAC;oBAC1B,cAAc,EACZ,yDAAyD;wBACzD,uDAAuD;wBACvD,2DAA2D;wBAC3D,qCAAqC;iBACxC,CAAC,CACH;aACF;SACF;QAED,gEAAgE;QAChE,gEAAgE;QAChE,kEAAkE;QAClE,4DAA4D;QAC5D,+DAA+D;QAC/D,6DAA6D;QAC7D,kEAAkE;QAClE,6DAA6D;QAC7D,YAAY;QACZ;YACE,KAAK,EAAE;gBACL,4BAA4B;gBAC5B,kBAAkB;gBAClB,eAAe;gBACf,aAAa;gBACb,gBAAgB;aACjB;YACD,qDAAqD;YACrD,yDAAyD;YACzD,4DAA4D;YAC5D,+DAA+D;YAC/D,+DAA+D;YAC/D,kBAAkB;YAClB,KAAK,EAAE;gBACL,8BAA8B,CAC5B,yBAAyB,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC,CACtD;aACF;SACF;QAED,oEAAoE;QACpE,iEAAiE;QACjE,iEAAiE;QACjE,gEAAgE;QAChE,qDAAqD;QACrD,2BAA2B;QAC3B,EAAE;QACF,iEAAiE;QACjE,iDAAiD;QACjD,sDAAsD;QACtD,8DAA8D;QAC9D,iEAAiE;QACjE,kEAAkE;QAClE,0DAA0D;QAC1D,EAAE;QACF,+DAA+D;QAC/D,mEAAmE;QACnE,gEAAgE;QAChE,+DAA+D;QAC/D,iEAAiE;QACjE,gEAAgE;QAChE,mEAAmE;QACnE,uDAAuD;QACvD,qBAAqB,CAAC;YACpB,QAAQ,EAAE,IAAI,CAAC,IAAI,EAAE,YAAY,CAAC;YAClC,SAAS,EAAE,CAAC,IAAI,CAAC;YACjB,YAAY,EAAE,IAAI,CAAC,IAAI,EAAE,6BAA6B,CAAC;YACvD,kBAAkB;YAClB,+EAA+E;YAC/E,oEAAoE;YACpE,KAAK;YACL,iCAAiC;YACjC,GAAG,MAAM;SACV,CAAC;QAEF,8DAA8D;QAC9D,8DAA8D;QAC9D,qDAAqD;QACrD,qBAAqB,CAAC,EAAE,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;QAExC,+DAA+D;QAC/D,kEAAkE;QAClE,gEAAgE;QAChE,uCAAuC;QACvC,mBAAmB,CAAC,EAAE,OAAO,EAAE,mBAAmB,EAAE,CAAC;KACtD,CAAA;AACH,CAAC"}

package/dist/presets/kotlin.d.ts

@@ -0,0 +1,40 @@
+import { type RuleEntry } from '@nizos/probity';
+import type { Globs } from '../rules/scoping.js';
+export type KotlinPresetOptions = {
+    /** Absolute path to the ubiquitous-language glossary. Defaults to
+     *  `<root>/docs/GLOSSARY.md`; glossary-aware rules degrade
+     *  gracefully while it doesn't exist yet. */
+    glossaryPath?: string;
+    /** Core purity scope — point at your core modules (e.g. the
+     *  `*-core` modules of a core/ui split); DI wiring and adapter
+     *  packages import vendors by design and must be excluded. */
+    coreGlobs?: Globs;
+    /** Deterministic infrastructure/vendor import screen for core code. */
+    infrastructureImports?: RegExp;
+    /** Point at the project's canonical ambient-effect port(s). */
+    seamHint?: string;
+    /** Test source sets where static/object/constructor mocking is
+     *  forbidden — ports are the only test seam. */
+    staticMockGlobs?: Globs;
+    /** Test-case files that must carry a spec-backed Covers: tag. */
+    acceptanceTestGlobs?: Globs;
+    /** Files the Language Test applies to (acceptance test globs plus
+     *  any Gherkin feature files). */
+    acceptanceLanguageGlobs?: Globs;
+    /** Source sets the TDD gate applies to. */
+    tddGlobs?: Globs;
+    /** Adapter/data packages that must carry boundary observability. */
+    adapterGlobs?: Globs;
+    /** The real Gradle test task your commit gate should look for. */
+    commitCommand?: RegExp;
+};
+/**
+ * Rule entries for a Kotlin/JVM/Android project, as a factory over the
+ * project root. Rule ordering principle: Probity stops at the first
+ * violation, so every deterministic screen (pattern match, free,
+ * instant) is listed before any AI-validated rule (a model call per
+ * matching write). A write with a vendor import in core code must be
+ * rejected by the free import screen, not after a TDD model call.
+ */
+export declare function kotlinRuleEntries(root: string, options?: KotlinPresetOptions): RuleEntry[];
+//# sourceMappingURL=kotlin.d.ts.map

package/dist/presets/kotlin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../presets/kotlin.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAoC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAuBjF,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAGhD,MAAM,MAAM,mBAAmB,GAAG;IAChC;;iDAE6C;IAC7C,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;kEAE8D;IAC9D,SAAS,CAAC,EAAE,KAAK,CAAA;IACjB,uEAAuE;IACvE,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;oDACgD;IAChD,eAAe,CAAC,EAAE,KAAK,CAAA;IACvB,iEAAiE;IACjE,mBAAmB,CAAC,EAAE,KAAK,CAAA;IAC3B;sCACkC;IAClC,uBAAuB,CAAC,EAAE,KAAK,CAAA;IAC/B,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,KAAK,CAAA;IAChB,oEAAoE;IACpE,YAAY,CAAC,EAAE,KAAK,CAAA;IACpB,kEAAkE;IAClE,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,mBAAwB,GAAG,SAAS,EAAE,CAgK9F"}

package/dist/presets/kotlin.js

@@ -0,0 +1,172 @@
+/**
+ * Probity rule-entry factory — Kotlin/JVM/Android preset.
+ *
+ * Same enforcement as the JS preset (see hooks/PROBITY.md) with the
+ * deterministic layer swapped to Kotlin-shaped rules from
+ * '../rules/kotlin.js'. Calibrated against a multi-module Android
+ * codebase (Gradle per project, `<module>-core` / `<module>-ui`
+ * split, Mockito-kotlin + JUnit 4, AWS/Amplify/Apollo/OkHttp/
+ * Retrofit/Room vendor stack) — every option below defaults to that
+ * calibration; a consuming project overrides what its layout needs.
+ *
+ * Note Probity itself still runs on Node: the consuming Kotlin
+ * project needs `npm install -D @nizos/probity` (a one-dependency
+ * package.json next to gradlew is fine).
+ */
+import { join } from 'node:path';
+import { enforceTdd, forbidContentPattern } from '@nizos/probity';
+import { enforceAcceptanceLanguage, withAcceptanceLanguageFastPath, } from '../rules/acceptance-language.js';
+import { enforceProbeReversion, forbidNewAmbientEffects, forbidStaticMocks, GRADLE_TEST_COMMAND, KOTLIN_BOUNDARY_ADDENDUM, KOTLIN_INFRASTRUCTURE_IMPORTS, requireGreenTestRun, withKotlinFastPath, withMutationProbe, withTelemetryFastPath, } from '../rules/kotlin.js';
+import { enforceAdapterObservability, enforcePortsBoundary, } from '../rules/ports-and-adapters.js';
+import { requireSpecBackedAcceptanceTest } from '../rules/spec-test-parity.js';
+import { surfaceGlossaryTermBreakage } from '../rules/ubiquitous-language.js';
+/**
+ * Rule entries for a Kotlin/JVM/Android project, as a factory over the
+ * project root. Rule ordering principle: Probity stops at the first
+ * violation, so every deterministic screen (pattern match, free,
+ * instant) is listed before any AI-validated rule (a model call per
+ * matching write). A write with a vendor import in core code must be
+ * rejected by the free import screen, not after a TDD model call.
+ */
+export function kotlinRuleEntries(root, options = {}) {
+    const glossary = options.glossaryPath ?? join(root, 'docs/GLOSSARY.md');
+    const coreGlobs = options.coreGlobs ?? [
+        '**/*-core/src/main/**',
+        '!**/*-core/src/main/**/di/**',
+        '!**/*-core/src/main/**/data/**',
+    ];
+    const staticMockGlobs = options.staticMockGlobs ?? [
+        '**/src/test/**',
+        '**/src/androidTest/**',
+        '**/src/sharedTest/**',
+    ];
+    const acceptanceTestGlobs = options.acceptanceTestGlobs ?? [
+        '**/acceptance/**/*Spec.kt',
+        '**/acceptance/**/*Test.kt',
+    ];
+    const acceptanceLanguageGlobs = options.acceptanceLanguageGlobs ?? [
+        ...acceptanceTestGlobs,
+        '**/*.feature',
+    ];
+    const tddGlobs = options.tddGlobs ?? [
+        '**/src/main/java/**',
+        '**/src/main/kotlin/**',
+        '**/src/test/**',
+        '**/src/sharedTest/**',
+    ];
+    const adapterGlobs = options.adapterGlobs ?? [
+        '**/src/main/**/adapter/**',
+        '**/src/main/**/adapters/**',
+        '**/src/main/**/data/**',
+    ];
+    return [
+        // ── Deterministic wall ───────────────────────────────────────────
+        // Core import/effect screens.
+        {
+            files: coreGlobs,
+            rules: [
+                forbidContentPattern({
+                    match: options.infrastructureImports ?? KOTLIN_INFRASTRUCTURE_IMPORTS,
+                    reason: 'Core code imports an infrastructure package. The ' +
+                        'Dependency Rule: core imports nothing from frameworks, ' +
+                        'vendors, or OS I/O — define a port in the core and reach ' +
+                        'the dependency through an adapter (see the ' +
+                        'ports-and-adapters skill).',
+                }),
+                // Delta-based: only NEW ambient calls block, so the existing
+                // Instant.now()/UUID.randomUUID() sites in a brownfield
+                // codebase don't freeze their files. Point seamHint at your
+                // canonical port(s).
+                forbidNewAmbientEffects({
+                    seamHint: options.seamHint ??
+                        'This codebase has a TimeProvider port (sudocommons-core) — inject it rather than reading the OS clock',
+                }),
+            ],
+        },
+        // Ports are the only test seam: no new static/object/constructor
+        // mocking anywhere in the suite.
+        {
+            files: staticMockGlobs,
+            rules: [forbidStaticMocks()],
+        },
+        // Ubiquitous-language drift: renaming or removing a glossary term
+        // that specs, tests, or code still use blocks the glossary edit
+        // with the list of users.
+        {
+            files: ['docs/GLOSSARY.md'],
+            rules: [surfaceGlossaryTermBreakage({ searchRoots: [root] })],
+        },
+        // Spec-first, at write time: adding a new acceptance test case
+        // requires a new Covers: tag resolving to a `## Scenario:` that
+        // already exists in docs/specs — the feature file is written
+        // before the test that claims it. Deterministic; the pattern also
+        // matches Swift XCTest (`func test…`), so an XCUITest acceptance
+        // glob works here unchanged.
+        {
+            files: acceptanceTestGlobs,
+            rules: [
+                requireSpecBackedAcceptanceTest({ specsDir: join(root, 'docs/specs') }),
+            ],
+        },
+        // ── AI-validated judgment layer ──────────────────────────────────
+        // Inner loop: test-driven-development. Android source sets
+        // commonly keep .kt under src/main/java, so match both. Probity
+        // has no built-in Kotlin fast-path; withKotlinFastPath supplies
+        // one — a write adding exactly one @Test function passes without
+        // an AI call. It needs the optional packages
+        // (`npm install -D @ast-grep/napi @ast-grep/lang-kotlin`) and
+        // falls through to plain enforceTdd when they're absent.
+        {
+            files: tddGlobs,
+            // Telemetry-only additions pass deterministically — see the
+            // KMP preset's note on the TDD/observability tension.
+            rules: [
+                withMutationProbe(withTelemetryFastPath(withKotlinFastPath(enforceTdd()))),
+            ],
+        },
+        // Boundaries: ports-and-adapters. The Dependency Rule judgments
+        // the import screen can't make — thin adapters, vendor types in
+        // port signatures, glossary-conflicting names.
+        {
+            files: coreGlobs,
+            rules: [
+                enforcePortsBoundary({
+                    instructions: (defaults) => defaults + KOTLIN_BOUNDARY_ADDENDUM,
+                    glossaryPath: glossary,
+                }),
+            ],
+        },
+        // Adapters must be thin, but not blind: a new adapter path doing
+        // external I/O carries boundary observability (structured event,
+        // port tap, or span). Point the globs at your adapter/data
+        // packages. Delta-based — legacy paths migrate incrementally.
+        {
+            files: adapterGlobs,
+            rules: [withTelemetryFastPath(enforceAdapterObservability())],
+        },
+        // Outer loop: acceptance-testing. The Language Test on the spec
+        // layer only. Point at wherever your executable specifications
+        // live (e.g. an acceptance package under androidTest, or Gherkin
+        // features); protocol drivers and test infrastructure must NOT
+        // match.
+        {
+            files: acceptanceLanguageGlobs,
+            rules: [
+                withAcceptanceLanguageFastPath(enforceAcceptanceLanguage({ glossaryPath: glossary })),
+            ],
+        },
+        // ── Ship gates ───────────────────────────────────────────────────
+        // The commit half of the mutation-probe round-trip: no commit
+        // while a `probity: mutation-probe` marker is still on disk —
+        // reverting the mutation removes the marker with it.
+        enforceProbeReversion({ roots: [root] }),
+        // No commit on an unverified tree. GRADLE_TEST_COMMAND matches
+        // plain and flavored test tasks (`./gradlew test`,
+        // `./gradlew :app:testDevDebugUnitTest`); tighten it to your
+        // module's real task if you want the gate strict about which
+        // suite counts. Stricter than Probity's requireCommand: the
+        // recorded run's output must actually be green, not merely exist.
+        requireGreenTestRun({ command: options.commitCommand ?? GRADLE_TEST_COMMAND }),
+    ];
+}
+//# sourceMappingURL=kotlin.js.map

package/dist/presets/kotlin.js.map

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

package/dist/presets/swift.d.ts

@@ -0,0 +1,10 @@
+import { type RuleEntry } from '@nizos/probity';
+/**
+ * Rule entries as a factory over the project root, mirroring the KMP
+ * preset: Probity reads the default export; tooling (scope reports,
+ * workflow evals) can instantiate the same blocks against another
+ * root. Relative globs are anchored by Probity's loadConfig against
+ * this file's directory.
+ */
+export declare function swiftRuleEntries(root: string): RuleEntry[];
+//# sourceMappingURL=swift.d.ts.map

package/dist/presets/swift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../presets/swift.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAoC,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AA6CjF;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,CAmR1D"}