@getarbiter/cli 0.5.0

package/dist/compatibility/cross-language-matrix.json

@@ -0,0 +1,540 @@
+{
+  "_comment": "Machine-readable maturity index for the cross-language enforcement matrix. Values: proven | beta | unsafe | unavailable. Consumed by src/utils/maturity-check.ts.",
+  "_lastUpdated": "2026-05-18",
+  "static_analysis": {
+    "java": {
+      "tool": "checkstyle+pmd+spotbugs+spotless",
+      "maturity": "proven",
+      "reason": "All four tools wired into L1/L2 gate; production-grade rulesets"
+    },
+    "typescript": {
+      "tool": "eslint+prettier",
+      "maturity": "proven",
+      "reason": "Comprehensive static rules + format check wired into L1 gate"
+    },
+    "rust": {
+      "tool": "clippy",
+      "maturity": "proven",
+      "reason": "cargo clippy -D warnings wired into L1; pedantic deny rules in clippy.toml for hexagonal archetype"
+    },
+    "go": {
+      "tool": "golangci-lint",
+      "maturity": "proven",
+      "reason": "Full linter suite (gocyclo/gosec/errcheck/staticcheck) wired into L1 gate"
+    },
+    "python": {
+      "tool": "ruff",
+      "maturity": "proven",
+      "reason": "Comprehensive rules (complexity/unused/security) wired into L1 gate"
+    },
+    "kotlin": {
+      "tool": "detekt",
+      "maturity": "beta",
+      "reason": "detekt is the de facto Kotlin static-analysis tool; Gradle/Maven plugins stable, severity mapping still maturing vs Java Checkstyle/PMD"
+    }
+  },
+  "mutation": {
+    "java": {
+      "tool": "pitest",
+      "maturity": "proven",
+      "reason": "pitest is the de-facto Java mutation testing standard; stable API, broad adoption"
+    },
+    "typescript": {
+      "tool": "stryker",
+      "maturity": "proven",
+      "reason": "Stryker 8.x is well-maintained with first-class Vitest integration"
+    },
+    "rust": {
+      "tool": "cargo-mutants",
+      "maturity": "beta",
+      "reason": "cargo-mutants threshold gating is unstable; passes on some versions, fails silently on others"
+    },
+    "go": {
+      "tool": "go-mutesting",
+      "maturity": "unsafe",
+      "reason": "go-mutesting is abandoned upstream and hangs on Go 1.23 module graphs"
+    },
+    "python": {
+      "tool": "mutmut",
+      "maturity": "beta",
+      "reason": "mutmut runtime can exceed 6h on mid-sized codebases; no reliable timeout-per-mutant control"
+    },
+    "kotlin": {
+      "tool": "pitest",
+      "maturity": "beta",
+      "reason": "pitest operates on JVM bytecode; Kotlin compilation transparent but not yet fixture-verified"
+    }
+  },
+  "contract": {
+    "java": {
+      "tool": "pact-jvm",
+      "maturity": "proven",
+      "reason": "pact-jvm has stable consumer + provider verification; widely adopted in Spring Boot"
+    },
+    "typescript": {
+      "tool": "@pact-foundation/pact",
+      "maturity": "proven",
+      "reason": "Pact JS library is well-maintained with Node 18+ support"
+    },
+    "rust": {
+      "tool": "pact_consumer",
+      "maturity": "beta",
+      "reason": "pact_consumer for Rust is a community crate; provider verification is experimental"
+    },
+    "go": {
+      "tool": "pact_consumer (Go)",
+      "maturity": "beta",
+      "reason": "Pact Go SDK wraps the Rust core via FFI; occasional FFI panics on newer Go runtimes"
+    },
+    "python": {
+      "tool": "pact-python",
+      "maturity": "beta",
+      "reason": "pact-python lacks provider-verification parity with pact-jvm; V4 migration in progress"
+    },
+    "kotlin": {
+      "tool": "pact-jvm",
+      "maturity": "beta",
+      "reason": "pact-jvm works on compiled Kotlin; consumer/provider flow not yet fixture-verified"
+    }
+  },
+  "coverage": {
+    "java": {
+      "tool": "jacoco",
+      "maturity": "proven",
+      "reason": "JaCoCo is the standard Java coverage tool with Gradle and Maven integration"
+    },
+    "typescript": {
+      "tool": "@vitest/coverage-v8",
+      "maturity": "proven",
+      "reason": "vitest --coverage with @vitest/coverage-v8 (the v8 provider) is stable and fast"
+    },
+    "rust": {
+      "tool": "cargo-tarpaulin",
+      "maturity": "proven",
+      "reason": "cargo-tarpaulin produces reliable line/branch coverage on stable Rust"
+    },
+    "go": {
+      "tool": "go test -cover",
+      "maturity": "proven",
+      "reason": "Built-in Go coverage is stable; no external tooling required"
+    },
+    "python": {
+      "tool": "pytest-cov",
+      "maturity": "proven",
+      "reason": "pytest-cov with coverage.py is the standard Python coverage stack"
+    },
+    "kotlin": {
+      "tool": "kover",
+      "maturity": "beta",
+      "reason": "Kotlin-native coverage (JetBrains Kover); Gradle-native, report shape differs from JaCoCo so thresholds need validation"
+    }
+  },
+  "architecture": {
+    "java": {
+      "tool": "ArchUnit",
+      "maturity": "proven",
+      "reason": "ArchUnit has stable API and is widely used in Spring Boot monoliths"
+    },
+    "typescript": {
+      "tool": "eslint-plugin-boundaries",
+      "maturity": "proven",
+      "reason": "eslint-plugin-boundaries provides reliable import boundary checking"
+    },
+    "rust": {
+      "tool": "cargo-deny + clippy",
+      "maturity": "proven",
+      "reason": "cargo-deny and clippy provide reliable static checks for Rust"
+    },
+    "go": {
+      "tool": "golangci-lint (depguard)",
+      "maturity": "proven",
+      "reason": "depguard (golangci-lint) provides reliable static checks for Go, consistent with M22b pattern"
+    },
+    "python": {
+      "tool": "import-linter + ruff",
+      "maturity": "proven",
+      "reason": "import-linter enforces import contracts; ruff handles style"
+    },
+    "kotlin": {
+      "tool": "ArchUnit",
+      "maturity": "beta",
+      "reason": "ArchUnit inspects compiled JVM bytecode so it works on Kotlin; not yet exercised across Kotlin fixtures"
+    }
+  },
+  "e2e": {
+    "java": {
+      "tool": "RestAssured IT",
+      "maturity": "proven",
+      "reason": "RestAssured integration tests are widely used for Spring Boot E2E"
+    },
+    "typescript": {
+      "tool": "Playwright",
+      "maturity": "proven",
+      "reason": "Playwright is the industry standard for browser E2E testing"
+    },
+    "rust": {
+      "tool": "N/A",
+      "maturity": "unavailable",
+      "reason": "No E2E testing equivalent for Rust CLI projects; use integration level instead"
+    },
+    "go": {
+      "tool": "N/A",
+      "maturity": "unavailable",
+      "reason": "No E2E testing equivalent for Go CLI projects; use integration level instead"
+    },
+    "python": {
+      "tool": "Playwright / pytest-playwright",
+      "maturity": "proven",
+      "reason": "pytest-playwright is stable with Python 3.10+"
+    }
+  },
+  "security": {
+    "java": {
+      "tool": "trivy fs",
+      "maturity": "proven",
+      "reason": "GitHub Advisory DB/OSV, no NVD API key, fast — replaces OWASP DependencyCheck (slow/flaky NVD download)"
+    },
+    "typescript": {
+      "tool": "npm audit",
+      "maturity": "proven",
+      "reason": "npm audit is built into npm and reliable"
+    },
+    "rust": {
+      "tool": "cargo audit",
+      "maturity": "proven",
+      "reason": "cargo audit is the standard Rust advisory check"
+    },
+    "go": {
+      "tool": "govulncheck",
+      "maturity": "proven",
+      "reason": "govulncheck is the official Go vulnerability scanner from the Go team"
+    },
+    "python": {
+      "tool": "pip-audit",
+      "maturity": "proven",
+      "reason": "pip-audit is stable and maintained by PyPA"
+    },
+    "kotlin": {
+      "tool": "trivy fs",
+      "maturity": "beta",
+      "reason": "GitHub Advisory DB/OSV, no NVD API key, fast — JVM dependency scanning is language-agnostic; pending Kotlin fixture verification"
+    }
+  },
+  "bdd": {
+    "java": {
+      "tool": "cucumber-jvm",
+      "maturity": "proven",
+      "reason": "stable JUnit5 integration in Spring Boot stacks"
+    },
+    "typescript": {
+      "tool": "@cucumber/cucumber",
+      "maturity": "proven",
+      "reason": "official cucumber-js with native TS support is stable on Node 18+"
+    },
+    "python": {
+      "tool": "pytest-bdd",
+      "maturity": "proven",
+      "reason": "pytest-bdd scenarios() reuses pytest fixtures cleanly"
+    },
+    "go": {
+      "tool": "godog",
+      "maturity": "beta",
+      "reason": "godog v0.14 stable but generic step bindings rough"
+    },
+    "rust": {
+      "tool": "cucumber-rs",
+      "maturity": "beta",
+      "reason": "cucumber-rs 0.20 stable for sync; async World still evolving"
+    }
+  },
+  "style_tokens": {
+    "typescript": {
+      "tool": "stylelint",
+      "maturity": "proven",
+      "reason": "stylelint 16+ enforces color-no-hex and design-token discipline; widely adopted in ts-frontend-spa stacks (a pattern from a prior internal project, #352)"
+    }
+  },
+  "fuzz": {
+    "java": {
+      "tool": "jqwik",
+      "maturity": "beta",
+      "reason": "jqwik property-based fuzzing runs in JUnit5; 30-min nightly budget per spec T4"
+    },
+    "typescript": {
+      "tool": "fast-check",
+      "maturity": "beta",
+      "reason": "fast-check property testing integrates with Vitest; nightly budget"
+    },
+    "rust": {
+      "tool": "cargo-fuzz",
+      "maturity": "beta",
+      "reason": "cargo-fuzz (libFuzzer) is the standard Rust fuzz harness; requires nightly toolchain"
+    },
+    "go": {
+      "tool": "native go fuzzing",
+      "maturity": "beta",
+      "reason": "Go 1.18+ native fuzzing (go test -fuzz); dvyukov/go-fuzz is deprecated upstream. 30-min nightly budget"
+    },
+    "python": {
+      "tool": "atheris",
+      "maturity": "beta",
+      "reason": "atheris (Google libFuzzer Python bindings) is the recommended Python fuzzer; nightly"
+    },
+    "kotlin": {
+      "tool": "jqwik",
+      "maturity": "beta",
+      "reason": "jqwik runs on JVM bytecode so it works with Kotlin, same as Java; the shared fuzz partial (_partials/scheduled-heavy-jobs.ejs) now includes kotlin in the java branch, fixture-render-verified (#1803)"
+    }
+  },
+  "dast": {
+    "java": {
+      "tool": "owasp-zap",
+      "maturity": "beta",
+      "reason": "OWASP ZAP baseline (T2) and full scan (T4 nightly) against ephemeral container"
+    },
+    "typescript": {
+      "tool": "owasp-zap",
+      "maturity": "beta",
+      "reason": "OWASP ZAP baseline (T2) and full scan (T4 nightly)"
+    },
+    "rust": {
+      "tool": "owasp-zap",
+      "maturity": "beta",
+      "reason": "OWASP ZAP baseline against service-archetype Rust binaries only; cli/lib: unavailable"
+    },
+    "go": {
+      "tool": "owasp-zap",
+      "maturity": "beta",
+      "reason": "OWASP ZAP baseline against service-archetype Go binaries only; cli/lib: unavailable"
+    },
+    "python": {
+      "tool": "owasp-zap",
+      "maturity": "beta",
+      "reason": "OWASP ZAP baseline (T2) and full scan (T4 nightly) for service/batch archetypes"
+    },
+    "kotlin": {
+      "tool": "owasp-zap",
+      "maturity": "beta",
+      "reason": "OWASP ZAP scans a running HTTP service; language-agnostic, already wired identically to Java"
+    }
+  },
+  "license_scan": {
+    "java": {
+      "tool": "license-maven-plugin",
+      "maturity": "beta",
+      "reason": "license-maven-plugin checks third-party licenses against an allow-list at T2"
+    },
+    "typescript": {
+      "tool": "license-checker",
+      "maturity": "beta",
+      "reason": "license-checker (npm) enumerates package licenses; T2 gate with deny-list"
+    },
+    "rust": {
+      "tool": "cargo-deny licenses",
+      "maturity": "beta",
+      "reason": "cargo-deny [licenses] table enforces SPDX allow/deny list; T2 gate"
+    },
+    "go": {
+      "tool": "go-licenses",
+      "maturity": "beta",
+      "reason": "go-licenses (Google) enumerates module licenses; T2 gate"
+    },
+    "python": {
+      "tool": "pip-licenses",
+      "maturity": "beta",
+      "reason": "pip-licenses enumerates installed package licenses; T2 gate"
+    },
+    "kotlin": {
+      "tool": "gradle-license-plugin / license-maven-plugin",
+      "maturity": "beta",
+      "reason": "Same JVM build-tool license reporting as Java (Gradle/Maven); 02-pr-extended.yml.ejs's license-scan job now includes kotlin in the java branch, fixture-render-verified (#1803)"
+    }
+  },
+  "sbom": {
+    "java": {
+      "tool": "cyclonedx-maven-plugin",
+      "maturity": "beta",
+      "reason": "cyclonedx-maven-plugin generates CycloneDX SBOM at T3 release; wired in existing nightly"
+    },
+    "typescript": {
+      "tool": "npm sbom / cyclonedx-npm",
+      "maturity": "beta",
+      "reason": "npm sbom (npm 8+) or cyclonedx-npm for CycloneDX output at T3"
+    },
+    "rust": {
+      "tool": "cargo-cyclonedx",
+      "maturity": "beta",
+      "reason": "cargo-cyclonedx generates CycloneDX SBOM for Rust workspace artifacts"
+    },
+    "go": {
+      "tool": "syft",
+      "maturity": "beta",
+      "reason": "syft (Anchore) closes the Go SBOM gap \u2014 used by 05-release.yml.ejs T3 and 06-nightly.yml.ejs T4"
+    },
+    "python": {
+      "tool": "cyclonedx-py",
+      "maturity": "beta",
+      "reason": "cyclonedx-bom (Python) generates CycloneDX SBOM from pip environment at T3"
+    },
+    "kotlin": {
+      "tool": "cyclonedx-gradle-plugin / cyclonedx-maven-plugin",
+      "maturity": "beta",
+      "reason": "Same JVM build-tool SBOM generation as Java (Gradle/Maven); 05-release.yml.ejs's build-superset and sbom jobs now include kotlin in the java branch, fixture-render-verified (#1803)"
+    }
+  },
+  "binary_signing": {
+    "java": {
+      "tool": "cosign sign-blob",
+      "maturity": "beta",
+      "reason": "cosign keyless sign-blob over JARs and native-image binaries at T3; Sigstore OIDC"
+    },
+    "typescript": {
+      "tool": "cosign sign-blob",
+      "maturity": "beta",
+      "reason": "cosign sign-blob over npm tarballs and cli binaries; Sigstore OIDC"
+    },
+    "rust": {
+      "tool": "cosign sign-blob",
+      "maturity": "beta",
+      "reason": "cosign sign-blob over cargo-dist binary artifacts; Sigstore OIDC"
+    },
+    "go": {
+      "tool": "cosign sign / cosign sign-blob",
+      "maturity": "beta",
+      "reason": "cosign sign for container images (service); sign-blob for goreleaser binaries (cli)"
+    },
+    "python": {
+      "tool": "cosign sign-blob",
+      "maturity": "beta",
+      "reason": "cosign sign-blob over wheels (twine) and pyinstaller binaries; Sigstore OIDC"
+    },
+    "kotlin": {
+      "tool": "cosign sign-blob",
+      "maturity": "beta",
+      "reason": "cosign keyless sign-blob over JARs at T3; Sigstore OIDC — language-agnostic, already wired identically to Java"
+    }
+  },
+  "provenance": {
+    "java": {
+      "tool": "actions/attest-build-provenance + slsa-github-generator",
+      "maturity": "beta",
+      "reason": "GitHub native provenance (L1/L2) + slsa-github-generator hermetic builder (L3) at T3"
+    },
+    "typescript": {
+      "tool": "actions/attest-build-provenance + slsa-github-generator",
+      "maturity": "beta",
+      "reason": "GitHub native provenance (L1/L2) + slsa-github-generator (L3) at T3"
+    },
+    "rust": {
+      "tool": "actions/attest-build-provenance + slsa-github-generator",
+      "maturity": "beta",
+      "reason": "GitHub native provenance (L1/L2) + slsa-github-generator (L3) at T3"
+    },
+    "go": {
+      "tool": "actions/attest-build-provenance + slsa-github-generator",
+      "maturity": "beta",
+      "reason": "GitHub native provenance (L1/L2) + slsa-github-generator (L3) at T3"
+    },
+    "python": {
+      "tool": "actions/attest-build-provenance + slsa-github-generator",
+      "maturity": "beta",
+      "reason": "GitHub native provenance (L1/L2) + slsa-github-generator (L3) at T3"
+    },
+    "kotlin": {
+      "tool": "actions/attest-build-provenance + slsa-github-generator",
+      "maturity": "beta",
+      "reason": "GitHub native provenance (L1/L2) + slsa-github-generator (L3) at T3 — language-agnostic, already wired identically to Java"
+    }
+  },
+  "container_scan": {
+    "java": {
+      "tool": "trivy",
+      "maturity": "beta",
+      "reason": "Trivy HIGH+CRITICAL (L2) / MEDIUM+ (L3) blocking at T2 when Dockerfile changed; T3 rescan"
+    },
+    "typescript": {
+      "tool": "trivy",
+      "maturity": "beta",
+      "reason": "Trivy container scan at T2/T3 for service-archetype TS projects"
+    },
+    "rust": {
+      "tool": "trivy",
+      "maturity": "beta",
+      "reason": "Trivy container scan at T2/T3 for service-archetype Rust projects"
+    },
+    "go": {
+      "tool": "trivy",
+      "maturity": "beta",
+      "reason": "Trivy container scan at T2/T3 for service-archetype Go projects"
+    },
+    "python": {
+      "tool": "trivy",
+      "maturity": "beta",
+      "reason": "Trivy container scan at T2/T3 for service-archetype Python projects"
+    },
+    "kotlin": {
+      "tool": "trivy",
+      "maturity": "beta",
+      "reason": "Trivy HIGH+CRITICAL container scan against the built Docker image; language-agnostic Dockerfile-based scan, already wired identically to Java"
+    }
+  },
+  "secret_scan": {
+    "java": {
+      "tool": "gitleaks",
+      "maturity": "beta",
+      "reason": "Gitleaks diff-scan at T1; full history scan at T3 and T4 nightly"
+    },
+    "typescript": {
+      "tool": "gitleaks",
+      "maturity": "beta",
+      "reason": "Gitleaks diff-scan at T1; full history scan at T3 and T4 nightly"
+    },
+    "rust": {
+      "tool": "gitleaks",
+      "maturity": "beta",
+      "reason": "Gitleaks diff-scan at T1; full history scan at T3 and T4 nightly"
+    },
+    "go": {
+      "tool": "gitleaks",
+      "maturity": "beta",
+      "reason": "Gitleaks diff-scan at T1; full history scan at T3 and T4 nightly"
+    },
+    "python": {
+      "tool": "gitleaks",
+      "maturity": "beta",
+      "reason": "Gitleaks diff-scan at T1; full history scan at T3 and T4 nightly"
+    },
+    "kotlin": {
+      "tool": "gitleaks",
+      "maturity": "beta",
+      "reason": "Gitleaks diff-scan at T1; full history scan at T3 and T4 nightly — language-agnostic, already wired identically to Java"
+    }
+  },
+  "a11y": {
+    "typescript": {
+      "tool": "axe-core/playwright",
+      "maturity": "proven",
+      "reason": "@axe-core/playwright 4.11+ ships a stable AxeBuilder; wcag2a+wcag2aa tag set is the industry baseline (INV-61, #349)"
+    },
+    "python": {
+      "tool": "axe-playwright-python",
+      "maturity": "beta",
+      "reason": "axe-playwright-python wraps the same axe-core rules but the API surface is small and tag selection less ergonomic than the TS binding; now generated (#1149) via run_axe.py wrapper for frontend-spa/backend-web-db archetypes"
+    },
+    "rust": {
+      "tool": "N/A",
+      "maturity": "unavailable",
+      "reason": "No browser surface for Rust CLI/embedded archetypes \u2014 a11y is a UI-layer concern"
+    },
+    "go": {
+      "tool": "N/A",
+      "maturity": "unavailable",
+      "reason": "No browser surface for Go CLI/server archetypes \u2014 a11y is a UI-layer concern"
+    },
+    "java": {
+      "tool": "N/A",
+      "maturity": "unavailable",
+      "reason": "Server-side Java archetypes have no rendered UI; pair with a TS frontend lane for a11y coverage"
+    }
+  }
+}

package/dist/compatibility/index.d.ts

@@ -0,0 +1,4 @@
+export { runProbes, validateMatrix } from './probe.js';
+export type { MatrixEntry, LanguageMatrix, ProbeResult, ProbeStatus, VerifyReport, } from './schema.js';
+export { loadSkillsMatrix, validateSkillsMatrix, getSkillsMatrixEntries, } from './skills-validator.js';
+export type { SkillsMatrix } from './skills-validator.js';

package/dist/compatibility/index.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: Apache-2.0
+export{runProbes,validateMatrix}from"./probe.js";export{loadSkillsMatrix,validateSkillsMatrix,getSkillsMatrixEntries}from"./skills-validator.js";

package/dist/compatibility/matcher.js

@@ -0,0 +1 @@
+export class UnparseableConstraintError extends Error{constraint;range;constructor(constraint,range){super(`unparseable matrix constraint "${constraint}" (range="${range}") \u2014 valid forms: ">=18", ">=18 <22", ">=1.21", ">=3 <=3.9" (major or major.minor)`),this.constraint=constraint,this.range=range,this.name="UnparseableConstraintError"}}export function matches(ver,range){const trimmed=range.trim();if(trimmed==="")throw new UnparseableConstraintError("",range);const constraints=trimmed.split(/\s+/);for(const constraint of constraints)if(!satisfies(ver,constraint,range))return!1;return!0}function satisfies(ver,constraint,fullRange){const m=constraint.match(/^(>=|<=|>|<)(\d+)(?:\.(\d+))?$/);if(!m)throw new UnparseableConstraintError(constraint,fullRange);const[,op,rawMaj,rawMin]=m;if(op===void 0||rawMaj===void 0)throw new UnparseableConstraintError(constraint,fullRange);const cmpMajor=+rawMaj,cmpMinor=rawMin!==void 0?+rawMin:void 0,verNumeric=cmpMinor!==void 0?ver.major*1e4+ver.minor:ver.major*1e4,cmpNumeric=cmpMinor!==void 0?cmpMajor*1e4+cmpMinor:cmpMajor*1e4;switch(op){case">=":return verNumeric>=cmpNumeric;case"<=":return verNumeric<=cmpNumeric;case">":return verNumeric>cmpNumeric;case"<":return verNumeric<cmpNumeric;default:throw new UnparseableConstraintError(constraint,fullRange)}}export function validateRanges(entries){const SENTINEL={major:99,minor:99,patch:0},failures=[];for(const{tool,range}of entries)try{matches(SENTINEL,range)}catch(err){const reason=err instanceof Error?err.message:String(err);failures.push({tool,range,reason})}return failures}

package/dist/compatibility/matrix.json

@@ -0,0 +1,27 @@
+{
+  "typescript": [
+    { "tool": "node", "range": ">=18" },
+    { "tool": "npm", "range": ">=9" }
+  ],
+  "java": [
+    { "tool": "java", "range": ">=17" },
+    { "tool": "gradle", "range": ">=7" },
+    { "tool": "mvn", "range": ">=3.8" }
+  ],
+  "kotlin": [
+    { "tool": "java", "range": ">=17" },
+    { "tool": "kotlinc", "range": ">=1.9" },
+    { "tool": "gradle", "range": ">=7" }
+  ],
+  "rust": [
+    { "tool": "rustc", "range": ">=1.70" },
+    { "tool": "cargo", "range": ">=1.70" }
+  ],
+  "go": [{ "tool": "go", "range": ">=1.21" }],
+  "python": [
+    { "tool": "python3", "range": ">=3.10" },
+    { "tool": "pip", "range": ">=22" },
+    { "tool": "ruff", "range": ">=0.4" },
+    { "tool": "lint-imports", "range": ">=2.11" }
+  ]
+}

package/dist/compatibility/parsers.d.ts

@@ -0,0 +1,38 @@
+export interface SemVer {
+    major: number;
+    minor: number;
+    patch: number;
+}
+/** `v20.11.1` → SemVer */
+export declare const parseNodeVersion: (raw: string) => SemVer | null;
+/** `10.2.4` → SemVer */
+export declare const parseNpmVersion: (raw: string) => SemVer | null;
+/**
+ * Handles:
+ *   openjdk version "17.0.9" ...
+ *   java version "1.8.0_402"   (legacy — major becomes 8)
+ *
+ * Bespoke: the legacy `1.x` remap and `_NNN` sub-patch have no representation
+ * in the shared spec table, so this parser stays standalone.
+ */
+export declare function parseJavaVersion(raw: string): SemVer | null;
+/** `Gradle 8.5` or `Gradle 7.6.4` */
+export declare const parseGradleVersion: (raw: string) => SemVer | null;
+/** `Apache Maven 3.9.6 (...)` */
+export declare const parseMavenVersion: (raw: string) => SemVer | null;
+/** `rustc 1.78.0 (hash date)` */
+export declare const parseRustVersion: (raw: string) => SemVer | null;
+/** `cargo 1.78.0 (hash date)` */
+export declare const parseCargoVersion: (raw: string) => SemVer | null;
+/** `go version go1.22.3 linux/amd64` */
+export declare const parseGoVersion: (raw: string) => SemVer | null;
+/** `Python 3.12.3` */
+export declare const parsePythonVersion: (raw: string) => SemVer | null;
+/** `pip 24.0 from ...` */
+export declare const parsePipVersion: (raw: string) => SemVer | null;
+/** `lint-imports, version 2.1.0` */
+export declare const parseLintImportsVersion: (raw: string) => SemVer | null;
+/** `ruff 0.4.5` */
+export declare const parseRuffVersion: (raw: string) => SemVer | null;
+/** `kotlinc-jvm 1.9.23 (JRE 17.0.9+9)` or `info: kotlinc-jvm 1.9.23 (JRE 17.0.9+9)` */
+export declare const parseKotlinVersion: (raw: string) => SemVer | null;

package/dist/compatibility/parsers.js

@@ -0,0 +1 @@
+function parseWith(spec,raw){const m=(spec.trim?raw.trim():raw).match(spec.re);if(!m)return null;const[,maj,min,pat]=m;return maj===void 0||min===void 0||!spec.optionalPatch&&pat===void 0?null:{major:+maj,minor:+min,patch:pat!==void 0?+pat:0}}const SPECS={node:{re:/^v(\d+)\.(\d+)\.(\d+)$/,trim:!0},npm:{re:/^(\d+)\.(\d+)\.(\d+)$/,trim:!0},gradle:{re:/Gradle\s+(\d+)\.(\d+)(?:\.(\d+))?/,optionalPatch:!0},maven:{re:/Apache Maven\s+(\d+)\.(\d+)\.(\d+)/},rust:{re:/rustc\s+(\d+)\.(\d+)\.(\d+)/},cargo:{re:/cargo\s+(\d+)\.(\d+)\.(\d+)/},go:{re:/go(\d+)\.(\d+)(?:\.(\d+))?/,optionalPatch:!0},python:{re:/Python\s+(\d+)\.(\d+)\.(\d+)/},pip:{re:/pip\s+(\d+)\.(\d+)(?:\.(\d+))?/,optionalPatch:!0},lintImports:{re:/lint-imports,\s+version\s+(\d+)\.(\d+)\.(\d+)/,trim:!0},ruff:{re:/^ruff\s+(\d+)\.(\d+)\.(\d+)/,trim:!0},kotlin:{re:/kotlinc-jvm\s+(\d+)\.(\d+)\.(\d+)/,trim:!0}};export const parseNodeVersion=raw=>parseWith(SPECS.node,raw),parseNpmVersion=raw=>parseWith(SPECS.npm,raw);export function parseJavaVersion(raw){const m=raw.match(/"(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:_(\d+))?"/);if(!m)return null;const[,maj,min,pat,sub]=m;return maj===void 0?null:maj==="1"?min===void 0||pat===void 0?null:{major:+min,minor:+pat,patch:sub!==void 0?+sub:0}:{major:+maj,minor:min!==void 0?+min:0,patch:pat!==void 0?+pat:0}}export const parseGradleVersion=raw=>parseWith(SPECS.gradle,raw),parseMavenVersion=raw=>parseWith(SPECS.maven,raw),parseRustVersion=raw=>parseWith(SPECS.rust,raw),parseCargoVersion=raw=>parseWith(SPECS.cargo,raw),parseGoVersion=raw=>parseWith(SPECS.go,raw),parsePythonVersion=raw=>parseWith(SPECS.python,raw),parsePipVersion=raw=>parseWith(SPECS.pip,raw),parseLintImportsVersion=raw=>parseWith(SPECS.lintImports,raw),parseRuffVersion=raw=>parseWith(SPECS.ruff,raw),parseKotlinVersion=raw=>parseWith(SPECS.kotlin,raw);

package/dist/compatibility/probe.d.ts

@@ -0,0 +1,41 @@
+import type { LanguageMatrix, ProbeResult, VerifyReport } from './schema.js';
+type OutputChannel = 'stdout' | 'stderr';
+/** Specification for a build-invocation probe (runs in target project directory) */
+export interface BuildProbeSpec {
+    /** Probe identifier used in output, e.g. "gradlew:help" */
+    name: string;
+    /** Executable to run */
+    command: string;
+    /** Arguments to pass */
+    args: readonly string[];
+    /**
+     * Relative path (within target dir) that must exist before running.
+     * Empty string means always run (no file guard).
+     */
+    requires: string;
+}
+/**
+ * Probe a single tool: run its version command and check against the range.
+ * Exported for unit testing.
+ */
+export declare function probeTool(tool: string, args: readonly string[], range: string, channel: OutputChannel): ProbeResult;
+/** exported for tests */
+export declare function validateMatrix(raw: unknown): LanguageMatrix;
+/**
+ * Run a build-invocation probe in the target directory.
+ * Returns skipped if the required file guard is missing.
+ * Exported for unit testing.
+ */
+export declare function runBuildProbe(dir: string, spec: BuildProbeSpec): ProbeResult;
+/**
+ * Run all tool probes for the detected stack in the given directory.
+ * Runs version probes first, then a per-stack build probe.
+ */
+export declare function runProbes(dir: string): VerifyReport;
+/**
+ * Probe whether `.githooks/pre-commit` exists but `core.hooksPath` is not set to `.githooks`.
+ * Returns null (silent skip) if no `.githooks/` directory is present at all.
+ * Exported for unit testing.
+ */
+export declare function probeHooksPath(dir: string): ProbeResult | null;
+export {};