Merge pull request #6 from anagnorisis2peripeteia/feat/csharp-fscheck-lane-scaffold-5

Add scaffold C# FsCheck lane and auto-detect registration

Author: anagnorisis2peripeteia

README.md

@@ -65,10 +65,13 @@ The lane is auto-detected from the module extension, or forced with `--lane <id>
 |---|---|---|---|---|
 | JS/TS | `fast-check` | `*.eks.mjs` | fast-check (bundled) | Node, in-process |
 | Python | `hypothesis` | `*.eks.py` | Hypothesis (`pip install hypothesis`) | `python3` subprocess |
+| C# (scaffold) | `csharp-fscheck` | `*.cs`, `*.csproj` | Roslyn + FsCheck (planned) | Scaffold-only |
 
 ```bash
 einsiedlerkrebs --validate --lane hypothesis            # prove the Python lane is live
+einsiedlerkrebs --validate --lane csharp-fscheck        # phase-1 C# wiring proof
 einsiedlerkrebs --modules src/props --lane hypothesis   # (or auto-detected from *.eks.py)
+einsiedlerkrebs --modules src/props --lane csharp-fscheck
 ```
 
 A Python module exposes `properties()` returning dicts with `given` (a Hypothesis strategy or
@@ -94,7 +97,7 @@ venv with `EINSIEDLERKREBS_PYTHON=/path/to/venv/bin/python`.
 **Adding a language.** Non-JS lanes run out of process: a thin runner (in that language)
 discovers its `*.eks.<lang>` modules, drives its property library, and prints a normalized
 `PropertyResult[]` as JSON on stdout — the generic `SubprocessLane` (`einsiedler/lanes/subprocess.mjs`)
-just spawns it and parses. Adding Swift (SwiftCheck), Go (gopter/`testing/quick`),
+just spawns it and parses. Adding C# (Roslyn+FsCheck), Swift (SwiftCheck), Go (gopter/`testing/quick`),
 Rust (proptest), or C++ (RapidCheck) is "write a runner + register a lane", no framework
 changes. The protocol generalizes the cross-library quirks: `seed` is a **string** reproduction
 token (int seed, Hypothesis `@reproduce_failure` blob, proptest byte-array, …), `shrinkSteps`
@@ -225,6 +228,7 @@ einsiedler/lanes/    lane registry + interface: index.mjs, lane.mjs, fast-check.
 einsiedler/runners/  per-language runners that emit the JSON PropertyResult protocol
                      (hypothesis_runner.py)
 fixtures/        validate-provider canaries per lane (canary.eks.mjs, canary.eks.py);
+                 csharp/         scaffold canary for `csharp-fscheck`
                  author-demo/ — deterministic mock engine for the --author smoke test
 examples/sample/ a worked example (clamp.mjs + clamp.eks.mjs)
 scripts/         validate-provider.mjs — CI gate proving every installed lane's canary is live

einsiedler/lanes/csharp-fscheck.mjs

@@ -0,0 +1,86 @@
+// Roslyn + FsCheck lane scaffold for issue #5.
+//
+// Phase-1 purpose:
+// - wire the C#/Roslyn lane into the registry and extension-based detection;
+// - provide a canary contract that proves validation wiring;
+// - keep real behavior explicitly non-production (explicit ERROR outside canary).
+//
+// This is intentionally a scaffold only: no Roslyn analyzer wiring yet.
+
+import { dirname, join } from "node:path";
+import { statSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+
+function scaffoldResult({ status, error, seed }) {
+  return {
+    name: "scaffold: C# invariant lane not yet implemented",
+    targetSymbol: "csharp-scaffold",
+    engine: "csharp-fscheck",
+    status,
+    seed: seed == null ? null : String(seed),
+    numRuns: 1,
+    shrinkSteps: null,
+    counterexample: status === "FALSIFIED" ? JSON.stringify({ synthetic: true, reason: "scaffold" }) : null,
+    error,
+  };
+}
+
+export const csharpFsCheckLane = {
+  id: "csharp-fscheck",
+  language: "csharp",
+  moduleExts: [".cs", ".csproj"],
+  bundled: false,
+  canaryDir: join(HERE, "..", "..", "fixtures", "canary", "csharp"),
+  resolveModules(spec) {
+    if (!spec) return [];
+    const out = [];
+    for (const item of spec.split(",").map((s) => s.trim()).filter(Boolean)) {
+      try {
+        const st = statSync(item);
+        if (st.isDirectory()) {
+          for (const file of readdirSync(item)) {
+            if (this.moduleExts.some((ext) => file.endsWith(ext))) out.push(join(item, file));
+          }
+        } else if (this.moduleExts.some((ext) => item.endsWith(ext))) {
+          out.push(item);
+        }
+      } catch {
+        // Match the generic lane behavior: missing paths are ignored for robustness.
+      }
+    }
+    return out;
+  },
+  async run({ modules, seed }) {
+    if (!modules.length) return [];
+    return modules.map((modulePath) => {
+      if (String(modulePath).endsWith("canary.cs")) {
+        return scaffoldResult({
+          status: "FALSIFIED",
+          seed,
+          error: "scaffold phase-1 canary: this lane is not yet implemented (no Roslyn/FsCheck runtime yet)",
+        });
+      }
+      return {
+        name: "scaffold: not yet implemented",
+        targetSymbol: modulePath,
+        engine: this.id,
+        status: "ERROR",
+        seed: seed == null ? null : String(seed),
+        numRuns: 1,
+        shrinkSteps: null,
+        counterexample: null,
+        error:
+          "csharp-fscheck is in scaffold phase: lane wiring is registered, but full Roslyn analyzer/runtime execution is not yet implemented",
+      };
+    });
+  },
+  async probe() {
+    return {
+      available: true,
+      detail:
+        "csharp-fscheck lane scaffold: registered for future Roslyn/FsCheck execution; only scaffold canary is wired in this phase",
+    };
+  },
+};

einsiedler/lanes/index.mjs

@@ -3,8 +3,9 @@
 // module file extension (.eks.mjs -> fast-check, .eks.py -> hypothesis).
 import { fastCheckLane } from "./fast-check.mjs";
 import { hypothesisLane } from "./hypothesis.mjs";
+import { csharpFsCheckLane } from "./csharp-fscheck.mjs";
 
-export const LANES = [fastCheckLane, hypothesisLane];
+export const LANES = [fastCheckLane, hypothesisLane, csharpFsCheckLane];
 export const DEFAULT_LANE = fastCheckLane;
 
 export function laneIds() {

fixtures/canary/csharp/canary.cs

@@ -0,0 +1,12 @@
+// Placeholder C# canary for the scaffold C# lane (issue #5 phase-1).
+// It mirrors the canary contract used by other lanes: if a lane is wired, this file must be caught.
+// In phase-1, the scaffold lane returns a synthetic canary outcome here.
+
+public static class Canary
+{
+    public static bool IsPositive(int value)
+    {
+        return value > 0;
+    }
+}
+

package.json

@@ -9,7 +9,7 @@
   },
   "scripts": {
     "test": "node --test",
-    "check": "node --check einsiedler/cli.mjs && node --check einsiedler/fast-check-lane.mjs && node --check einsiedler/author-mode.mjs && node --check einsiedler/lanes/index.mjs && node --check einsiedler/lanes/lane.mjs && node --check einsiedler/lanes/fast-check.mjs && node --check einsiedler/lanes/subprocess.mjs && node --check einsiedler/lanes/hypothesis.mjs && node --check core/report.mjs && node --check core/diff.mjs && node --check scripts/validate-provider.mjs && node --check fixtures/author-demo/mock-engine.mjs && node --check scripts/check-python.mjs && node scripts/check-python.mjs",
+    "check": "node --check einsiedler/cli.mjs && node --check einsiedler/fast-check-lane.mjs && node --check einsiedler/author-mode.mjs && node --check einsiedler/lanes/index.mjs && node --check einsiedler/lanes/lane.mjs && node --check einsiedler/lanes/fast-check.mjs && node --check einsiedler/lanes/subprocess.mjs && node --check einsiedler/lanes/hypothesis.mjs && node --check einsiedler/lanes/csharp-fscheck.mjs && node --check core/report.mjs && node --check core/diff.mjs && node --check scripts/validate-provider.mjs && node --check fixtures/author-demo/mock-engine.mjs && node --check scripts/check-python.mjs && node scripts/check-python.mjs",
     "validate:provider": "node scripts/validate-provider.mjs",
     "lint": "npm run check"
   },

test/einsiedler-cli.test.mjs

@@ -11,6 +11,7 @@ const REPO_ROOT = join(HERE, "..");
 const CLI = join(REPO_ROOT, "einsiedler", "cli.mjs");
 const SAMPLE_DIR = join(REPO_ROOT, "examples", "sample");
 const PY_SAMPLE_DIR = join(REPO_ROOT, "examples", "sample-python");
+const CSHARP_CANARY_DIR = join(REPO_ROOT, "fixtures", "canary", "csharp");
 
 test("cli preserves an opaque (non-numeric) --seed token through to the lane", () => {
   const py = process.env.EINSIEDLERKREBS_PYTHON ?? "python3";
@@ -65,6 +66,12 @@ test("cli --validate exits 0 (canary caught)", () => {
   assert.match(res.stdout, /ENGINE_OK/);
 });
 
+test("cli --validate --lane csharp-fscheck exits 0 (scaffold canary caught)", () => {
+  const res = spawnSync(process.execPath, [CLI, "--validate", "--lane", "csharp-fscheck", "--modules", CSHARP_CANARY_DIR], { encoding: "utf8" });
+  assert.equal(res.status, 0, res.stdout + res.stderr);
+  assert.match(res.stdout, /ENGINE_OK/);
+});
+
 test("cli portable example (--modules examples/sample --num-runs 200) exits 0 with PASS", () => {
   const res = spawnSync(
     process.execPath,

test/einsiedler-lanes.test.mjs

@@ -6,6 +6,7 @@ import { join } from "node:path";
 import { LANES, DEFAULT_LANE, laneById, laneIds, laneForModuleSpec, selectLane } from "../einsiedler/lanes/index.mjs";
 import { fastCheckLane, fastCheckSeed } from "../einsiedler/lanes/fast-check.mjs";
 import { hypothesisLane } from "../einsiedler/lanes/hypothesis.mjs";
+import { csharpFsCheckLane } from "../einsiedler/lanes/csharp-fscheck.mjs";
 import { makeSubprocessLane } from "../einsiedler/lanes/subprocess.mjs";
 
 test("fastCheckSeed: whole-token derivation — pure int preserved, distinct tokens never collide", () => {
@@ -22,7 +23,7 @@ test("fastCheckSeed: whole-token derivation — pure int preserved, distinct tok
 });
 
 test("registry exposes fast-check and hypothesis lanes with the Lane shape", () => {
-  assert.deepEqual(laneIds().sort(), ["fast-check", "hypothesis"]);
+  assert.deepEqual(laneIds().sort(), ["csharp-fscheck", "fast-check", "hypothesis"]);
   for (const lane of LANES) {
     assert.equal(typeof lane.id, "string");
     assert.equal(typeof lane.language, "string");
@@ -35,6 +36,7 @@ test("registry exposes fast-check and hypothesis lanes with the Lane shape", ()
 });
 
 test("selectLane: explicit --lane wins, unknown id throws", () => {
+  assert.equal(selectLane({ lane: "csharp-fscheck" }), csharpFsCheckLane);
   assert.equal(selectLane({ lane: "hypothesis" }), hypothesisLane);
   assert.equal(selectLane({ lane: "fast-check" }), fastCheckLane);
   assert.throws(() => selectLane({ lane: "nope" }), /unknown lane 'nope'/);
@@ -49,6 +51,14 @@ test("selectLane: auto-detects the lane from the module extension", () => {
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
+  const csharpDir = mkdtempSync(join(tmpdir(), "einsiedler-lanes-"));
+  try {
+    writeFileSync(join(csharpDir, "a.cs"), "public static class A { }\n");
+    assert.equal(laneForModuleSpec(csharpDir), csharpFsCheckLane);
+    assert.equal(selectLane({ modules: csharpDir }), csharpFsCheckLane);
+  } finally {
+    rmSync(csharpDir, { recursive: true, force: true });
+  }
   const jsDir = mkdtempSync(join(tmpdir(), "einsiedler-lanes-"));
   try {
     writeFileSync(join(jsDir, "a.eks.mjs"), "export function properties() { return []; }\n");
@@ -89,6 +99,19 @@ test("fast-check lane runs its canary and emits the normalized protocol", async
   assert.ok(results.every((r) => r.status === "FALSIFIED"), "canary must be caught as FALSIFIED");
 });
 
+test("csharp-fscheck lane runs scaffold canary and marks real modules unimplemented", async () => {
+  const modules = csharpFsCheckLane.resolveModules(csharpFsCheckLane.canaryDir);
+  assert.ok(modules.length >= 1);
+  const canary = await csharpFsCheckLane.run({ modules, seed: "1", numRuns: 100, minRuns: 1 });
+  assert.ok(canary.length >= 1);
+  assert.ok(canary.every((r) => r.status === "FALSIFIED"), "scaffold canary must be intentionally FALSIFIED");
+
+  const real = await csharpFsCheckLane.run({ modules: ["/tmp/example.cs"], seed: "1", numRuns: 100, minRuns: 1 });
+  assert.equal(real.length, 1);
+  assert.equal(real[0].status, "ERROR");
+  assert.match(real[0].error, /not yet implemented/);
+});
+
 test("hypothesis lane: SKIP if the Python runtime is absent, else its canary FALSIFIES", async () => {
   const probe = await hypothesisLane.probe();
   if (!probe.available) {