@jjchill/probity-rules 0.1.0

package/dist/presets/swift.js

@@ -0,0 +1,285 @@
+/**
+ * Probity rule-entry factory — Swift/iOS preset.
+ *
+ * Same enforcement stack as the Kotlin presets (see hooks/PROBITY.md),
+ * recalibrated for a native iOS app: an Xcode workspace with the
+ * acceptance suite in AcceptanceTests/ following the four-layer model
+ * (Specs + Component test glue / Scenarios / DSL / Drivers), XCUITest
+ * plus an app-hosted component-test target, MVVM view models over
+ * use-case ports, and Markdown Given/When/Then specs in docs/specs/.
+ * Calibrated against a production CocoaPods + SwiftPM app — adjust
+ * globs and package names to your layout.
+ *
+ * Probity runs on Node: `npm install -D @nizos/probity` (a
+ * one-dependency package.json with `"type": "module"` next to the
+ * xcworkspace is fine).
+ */
+import { join } from 'node:path';
+import { enforceTdd, forbidContentPattern } from '@nizos/probity';
+import { enforceAcceptanceLanguage, enforceControlledPreconditions, } from '../rules/acceptance-language.js';
+import { enforceCharacterizationResolution, enforceProbeReversion, requireGreenTestRun, withCharacterizationTest, withInverseScenarioGuidance, withMutationProbe, withTelemetryFastPath, } from '../rules/kotlin.js';
+import { enforceAdapterObservability, enforcePortsBoundary, } from '../rules/ports-and-adapters.js';
+import { enforceSpecTestParity, requireSpecBackedAcceptanceTest, surfaceScenarioLinkBreakage, } from '../rules/spec-test-parity.js';
+import { SWIFT_FIXED_SLEEPS, SWIFT_PROBE_FILE_PATTERN, XCODEBUILD_TEST_COMMAND, XCODEBUILD_TEST_FAILED, XCODEBUILD_TEST_SUCCEEDED, XCUITEST_MECHANICS, } from '../rules/swift.js';
+import { surfaceGlossaryTermBreakage } from '../rules/ubiquitous-language.js';
+// Acceptance test files live under AcceptanceTests/ (capital A) — the
+// parity scanners' default pattern expects a lowercase `acceptance/`
+// segment, so every spec-traceability rule below overrides it.
+const ACCEPTANCE_TEST_FILES = /AcceptanceTests[/\\]/;
+// Swift telemetry lines the fast-path recognizes as complete
+// single-line instrumentation (SudoLogging-style logger calls).
+const SWIFT_TELEMETRY_LINES = [
+    /^[\w.]*logger\.(?:event|info|debug|error|warning)\(.*\)$/i,
+];
+/**
+ * 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 function swiftRuleEntries(root) {
+    const glossary = join(root, 'docs/GLOSSARY.md');
+    // 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).
+    return [
+        // ── Deterministic wall ───────────────────────────────────────────
+        // No fixed waits anywhere in the acceptance suite: synchronize
+        // with XCTest expectations, predicates, or
+        // waitForExistence(timeout:) — never sleep.
+        {
+            files: ['AcceptanceTests/**'],
+            rules: [
+                forbidContentPattern({
+                    match: SWIFT_FIXED_SLEEPS,
+                    reason: 'Fixed waits are races: XCUITest flakiness starts here. ' +
+                        'Wait for the concluding observable state with XCTest ' +
+                        'expectations, predicate expectations, or ' +
+                        'waitForExistence(timeout:) (see the acceptance-testing ' +
+                        'and ios-development skills).',
+                }),
+            ],
+        },
+        // XCUITest mechanics belong only in the driver that owns the
+        // deployed-app scope. Specs, scenario bodies, the DSL, and the
+        // app-hosted component tests must stay implementation-neutral.
+        {
+            files: [
+                'AcceptanceTests/Specs/**',
+                'AcceptanceTests/Scenarios/**',
+                'AcceptanceTests/DSL/**',
+                'AcceptanceTests/Component/**',
+            ],
+            rules: [
+                forbidContentPattern({
+                    match: XCUITEST_MECHANICS,
+                    reason: 'XCUIApplication/XCUIElement outside AcceptanceTests/Drivers: ' +
+                        'only protocol drivers know how to reach the SUT. Move the ' +
+                        'mechanics into the XCUITest driver and express this layer ' +
+                        'in domain language (four-layer model, acceptance-testing ' +
+                        'skill).',
+                }),
+            ],
+        },
+        // Spec-first, at write time: adding a new acceptance test case
+        // (func test…) requires a Covers: tag resolving to a
+        // `## Scenario:` heading that already exists in docs/specs — the
+        // feature file is written before the test that claims it. A file
+        // whose existing tag already resolves may gain further driver
+        // tests for the same scenario (one scenario, many drivers).
+        // Scoped to the whole suite directory, not *Tests.swift: XCTest
+        // only discovers `func test…` methods, so the declaration pattern
+        // is the real detector and a creative filename can't dodge the
+        // rule. NOTE the directory itself is the boundary — acceptance
+        // tests added outside it (e.g. a new App/Tests/ target) are
+        // invisible to every rule here until the globs learn the path.
+        {
+            files: ['AcceptanceTests/**'],
+            rules: [
+                requireSpecBackedAcceptanceTest({ specsDir: join(root, 'docs/specs') }),
+            ],
+        },
+        // Editing a spec must not silently break the tests that claim its
+        // scenarios: removing or renaming a covered `## Scenario:` heading
+        // blocks with the list of affected tests.
+        {
+            files: ['docs/specs/**/*.feature.md'],
+            rules: [
+                surfaceScenarioLinkBreakage({
+                    testRoots: [root],
+                    testFilePattern: ACCEPTANCE_TEST_FILES,
+                }),
+            ],
+        },
+        // 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 over app sources and the
+        // acceptance suite. On a project whose only suite is the
+        // acceptance scheme, the observed red comes from
+        // `xcodebuild … test` — the outside-in loop, not an exemption.
+        // The mutation-probe wrapper lets a deliberate break marked
+        // `// probity: mutation-probe` through without a red-before-green
+        // demand; enforceProbeReversion below holds the commit hostage
+        // until it is reverted. Telemetry-only additions pass
+        // deterministically so the observability rule and the TDD gate
+        // never contradict each other.
+        // App/*.swift catches root-level sources (AppDelegate.swift lives
+        // beside App/Sources, not inside it) — audit these globs against
+        // your tree with scripts/scope-report.ts; a write no rule matches
+        // is a silent free pass.
+        {
+            files: [
+                'App/*.swift',
+                'App/Sources/**',
+                'AcceptanceTests/**',
+                'VPNNetworkExtension/**',
+            ],
+            rules: [
+                // The inverse-scenario wrapper changes only the DENY TEXT, and
+                // only on the test-control layer (the acceptance composition
+                // root): when a fixture has no red demanding it because the
+                // environment already satisfies the scenario's Given, the
+                // correct move — write the inverse scenario and let its red
+                // drive the fixture — is stated at the decision point instead
+                // of leaving "observe a red first" to read as "delete the
+                // control".
+                // The characterization wrapper sanctions the FIRST test for
+                // behavior that predates it (born green, so no red can be
+                // observed before it exists): a test-layer write carrying
+                // `// probity: characterization` passes, and the marker only
+                // comes off through a proof-checked removal (a recorded run
+                // where that test failed under a mutation probe). The
+                // resolution gate below blocks commits while a marker is on
+                // disk, so the bypass is a round-trip, not an exemption.
+                withInverseScenarioGuidance(withCharacterizationTest(withMutationProbe(withTelemetryFastPath(enforceTdd(), {
+                    patterns: SWIFT_TELEMETRY_LINES,
+                    filePattern: /\.swift$/,
+                })), { filePattern: /AcceptanceTests[/\\]/ }), { filePattern: /App[/\\]Sources[/\\]Acceptance[/\\]/ }),
+            ],
+        },
+        // Preconditions are controlled, not observed: a driver method
+        // named for a Given must establish it (fixture key, launch
+        // environment, programmed fake), and control wiring is never
+        // deleted just because the scenario passes without it — on a
+        // brownfield system the environment produces the sad path for
+        // free, which is exactly when the seam matters most (the success
+        // path is unreachable until the port is controlled).
+        {
+            files: ['AcceptanceTests/Drivers/**', 'App/Sources/Acceptance/**'],
+            rules: [enforceControlledPreconditions()],
+        },
+        // Boundaries: ports-and-adapters judgments the screens can't make
+        // — thin adapters, vendor types in port signatures, names
+        // conflicting with the glossary. Point at wherever your ports and
+        // core behavior live (here: module view-models/use-cases and the
+        // application-owned provider ports).
+        {
+            files: ['App/Sources/Modules/**', 'App/Sources/Utilities/Providers/**'],
+            rules: [enforcePortsBoundary({ 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 paths migrate
+        // incrementally.
+        {
+            files: [
+                'App/Sources/**/Adapters/**',
+                'App/Sources/**/Services/**',
+                'App/Sources/**/Analytics/**',
+            ],
+            rules: [
+                withTelemetryFastPath(enforceAdapterObservability({
+                    conventionHint: 'This codebase uses SudoLogging (a Logger built by the ' +
+                        'MySudoVpn logger factories — one structured, greppable ' +
+                        'line per boundary call/outcome), and/or a recording ' +
+                        'port-tap decorator wired where the app composes its ' +
+                        'dependencies.',
+                }), { patterns: SWIFT_TELEMETRY_LINES, filePattern: /\.swift$/ }),
+            ],
+        },
+        // Outer loop: acceptance-testing. The Language Test on the spec
+        // layer: Markdown specs, test-case glue, scenario bodies, and the
+        // DSL — everything above the drivers must read as pure domain
+        // language. Drivers are layer 3 (they know accessibility
+        // identifiers, hosted views, view-model ports) — excluded.
+        {
+            files: [
+                'docs/specs/**/*.feature.md',
+                'AcceptanceTests/Specs/**',
+                'AcceptanceTests/Component/**',
+                'AcceptanceTests/Scenarios/**',
+                'AcceptanceTests/DSL/**',
+            ],
+            rules: [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. Brownfield adoption:
+        // generate a baseline once with scripts/spec-parity.mjs
+        // --write-baseline and burn it down (see hooks/PROBITY.md).
+        // 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 a
+        // shared scenario layer (AcceptanceTests/Scenarios/) the extra
+        // covering test is a thin spec class calling the existing body.
+        // The example scopes match the calibration app's layout — the
+        // XCUITest target under Specs/, the app-hosted component target
+        // under Component/. CALIBRATE TO YOUR LAYOUT before uncommenting.
+        enforceSpecTestParity({
+            specsDir: join(root, 'docs/specs'),
+            testRoots: [root],
+            testFilePattern: ACCEPTANCE_TEST_FILES,
+            baselinePath: join(root, 'docs/specs/.parity-baseline'),
+            // driverScopes: [
+            //   { name: 'system', filePattern: /AcceptanceTests[/\\]Specs[/\\]/ },
+            //   { name: 'hosted-ui', filePattern: /AcceptanceTests[/\\]Component[/\\]/ },
+            // ],
+            // defaultScopes: ['hosted-ui'],
+        }),
+        // The commit half of the mutation-probe round-trip: no commit
+        // while a `probity: mutation-probe` marker is still on disk.
+        enforceProbeReversion({
+            roots: [root],
+            filePattern: SWIFT_PROBE_FILE_PATTERN,
+        }),
+        // The commit half of the characterization round-trip: no commit
+        // while a `probity: characterization` marker is still on disk —
+        // the marker only comes off once the transcript records the
+        // marked test failing under a mutation probe.
+        enforceCharacterizationResolution({
+            roots: [root],
+            filePattern: SWIFT_PROBE_FILE_PATTERN,
+        }),
+        // No commit on an unverified tree. Matches `xcodebuild … test`
+        // and xcresulttool summary readbacks; the recorded output must
+        // actually be green (** TEST SUCCEEDED ** or "result": "Passed"),
+        // not merely exist. CALIBRATE AGAINST YOUR REAL COMMAND: a
+        // `-quiet` run suppresses the verdict banner entirely (verified
+        // live), so a runbook that mandates -quiet must also mandate the
+        // `xcrun xcresulttool get test-results summary` readback — that
+        // readback is the output this gate accepts. Run your documented
+        // test command once and confirm successPattern matches what it
+        // actually prints before trusting the gate.
+        // Scope the commit-on-green gate to code the acceptance suite
+        // actually validates; infra/docs/tooling-only commits (CI config,
+        // lint config, Markdown, probity.config.ts, rules/**) aren't gated
+        // on a fresh xcodebuild run. Adjust the paths to your layout.
+        requireGreenTestRun({
+            command: XCODEBUILD_TEST_COMMAND,
+            successPattern: XCODEBUILD_TEST_SUCCEEDED,
+            failurePattern: XCODEBUILD_TEST_FAILED,
+            enforceForPaths: /^(?:App|AcceptanceTests|VPNNetworkExtension)\//,
+        }),
+    ];
+}
+//# sourceMappingURL=swift.js.map

package/dist/presets/swift.js.map

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

package/dist/rules/acceptance-language.d.ts

@@ -0,0 +1,95 @@
+import type { Rule } from '@nizos/probity';
+/**
+ * Wraps `enforceAcceptanceLanguage` so the most common spec-layer
+ * write — a Kotlin test file gaining exactly one new `@Test` whose
+ * added lines only call vocabulary that already exists in the
+ * suite's DSL/Robot/driver files — passes deterministically, with no
+ * model call. Rationale: when two rule scopes overlap (the TDD rule's
+ * Kotlin fast-path plus this rule on `acceptance/**`), a single-test
+ * write otherwise still pays one AI call despite being advertised as
+ * free.
+ *
+ * The fast-path is conservative on three axes; failing any one falls
+ * through to the wrapped AI rule (it can only skip work, never
+ * block):
+ *   1. the write must add exactly one `@Test`;
+ *   2. no added line may contain mechanism vocabulary
+ *      (backend/server/database/url/click/... — the deterministic
+ *      screen errs broad);
+ *   3. every identifier the added lines call must already be declared
+ *      in this file or a sibling `.kt` file in the same directory —
+ *      a brand-new DSL step name is exactly what the validator should
+ *      judge.
+ *
+ * Markdown/Gherkin spec writes never fast-path — prose is where the
+ * Language Test earns its keep.
+ */
+export declare function withAcceptanceLanguageFastPath(rule: Rule): Rule;
+/**
+ * AI-validated enforcement of the `acceptance-testing` skill's
+ * Language Test: executable specifications stay in domain language —
+ * no UI mechanics, protocols, or persistence details — assert a
+ * single outcome, and (when a glossary is supplied) use the
+ * ubiquitous language verbatim.
+ *
+ * Applies to: write actions. Scope it with a `{ files, rules }` block
+ * to the spec layer only (e.g. `specs/**`, `**\/*.feature`) — the DSL
+ * and protocol-driver layers are supposed to contain the mechanics
+ * this rule blocks, and every matching write costs an AI call.
+ *
+ * @param options.glossaryPath — absolute path to the project's
+ *   ubiquitous-language glossary (see the `ubiquitous-language`
+ *   skill). Resolve it in the config file, e.g.
+ *   `fileURLToPath(new URL('./docs/GLOSSARY.md', import.meta.url))`.
+ *   When set and readable, the glossary is included in the
+ *   validator's prompt and vocabulary conflicts become violations.
+ * @param options.requireGlossaryEntry — strict vocabulary mode: when
+ *   true (and a glossary is supplied and readable), a domain concept
+ *   in spec content with no glossary entry becomes a violation —
+ *   "the glossary conversation happens first" (ubiquitous-language
+ *   skill). Default false: only conflicts with existing entries
+ *   violate, so an empty or young glossary doesn't block everything.
+ * @param options.instructions — overrides or extends the default
+ *   language rules text. Pass a string to replace it, or a function
+ *   `(defaults) => ...` to extend it.
+ * @param options.maxGlossaryChars — truncate the glossary beyond this
+ *   length when building the prompt (default 8000).
+ *
+ * @example
+ * { files: ['specs/**', 'acceptance/**', '**\/*.feature'], rules: [enforceAcceptanceLanguage()] }
+ */
+export declare function enforceAcceptanceLanguage(options?: {
+    glossaryPath?: string;
+    requireGlossaryEntry?: boolean;
+    instructions?: string | ((defaults: string) => string);
+    maxGlossaryChars?: number;
+}): Rule;
+/**
+ * AI-validated enforcement of the `acceptance-testing` skill's
+ * controlled-precondition principle: a scenario's Given is established
+ * by the test (fixture, programmed stub, substituted port), never
+ * inherited from the ambient environment. Catches the two moves that
+ * silently hand a Given to the environment:
+ *
+ *   1. a driver method whose name states a precondition but whose body
+ *      sets no fixture/stub/launch state (the no-op precondition
+ *      driver), and
+ *   2. removing control fixtures because the scenario passes without
+ *      them — the brownfield trap where the environment produces the
+ *      sad path for free, and the deleted fixture leaves the success
+ *      path unspecifiable.
+ *
+ * Applies to: write actions. Scope it with a `{ files, rules }` block
+ * to the driver and test-control layers (e.g.
+ * `AcceptanceTests/Drivers/**` plus the acceptance composition root) —
+ * the opposite scoping from `enforceAcceptanceLanguage`, which
+ * excludes those layers. Every matching write costs an AI call.
+ *
+ * @param options.instructions — overrides or extends the default
+ *   precondition rules text. Pass a string to replace it, or a
+ *   function `(defaults) => ...` to extend it.
+ */
+export declare function enforceControlledPreconditions(options?: {
+    instructions?: string | ((defaults: string) => string);
+}): Rule;
+//# sourceMappingURL=acceptance-language.d.ts.map

package/dist/rules/acceptance-language.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acceptance-language.d.ts","sourceRoot":"","sources":["../../rules/acceptance-language.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAU,IAAI,EAA2B,MAAM,gBAAgB,CAAA;AA8Q3E;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAmD/D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAC9B,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAA;IACtD,gBAAgB,CAAC,EAAE,MAAM,CAAA;CACrB,GACL,IAAI,CAyCN;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE;IACP,YAAY,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,CAAA;CAClD,GACL,IAAI,CAiCN"}