import { describe, expect, it } from "@effect/vitest";import { spawnSync } from "node:child_process";import { mkdir, rm, writeFile } from "node:fs/promises";import { dirname, join, resolve } from "node:path"; const repoRoot = resolve(import.meta.dirname, "../../../.."); const runOxlint = (files: readonly string[]) =>  spawnSync(    join(repoRoot, "node_modules", ".bin", "oxlint"),    ["-c", join(repoRoot, ".oxlintrc.jsonc"), ...files, "--deny-warnings"],    {      cwd: repoRoot,      encoding: "utf8",    },  ); const runOxlintOn = async (name: string, source: string) => {  const dir = join(repoRoot, ".local", "oxlint-plugin-executor-tests");  await mkdir(dir, { recursive: true });  const file = join(dir, name);  await mkdir(dirname(file), { recursive: true });  await writeFile(file, source);   const result = runOxlint([file]);   await rm(file, { force: true });  return result;}; const runOxlintFile = (repoRelativeFile: string) => runOxlint([join(repoRoot, repoRelativeFile)]); describe("executor oxlint plugin", () => {  it("rejects expect calls in conditional test branches", async () => {    const result = await runOxlintOn(      "conditional-expect.test.ts",      `        import { describe, expect, it } from "@effect/vitest";         const helper = (value: string | undefined) => {          if (value) {            expect(value).toBe("ok");          }        };         describe("example", () => {          it("uses a helper", () => {            helper("ok");          });        });      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(no-conditional-tests)");  });   it("allows unconditional expects over conditional values", async () => {    const result = await runOxlintOn(      "unconditional-expect.test.ts",      `        import { describe, expect, it } from "@effect/vitest";         const pick = (flag: boolean) => flag ? "ok" : "no";         describe("example", () => {          it("compares the selected value", () => {            const value = pick(true);            expect(value).toBe("ok");          });        });      `,    );     expect(result.status).toBe(0);    expect(result.stdout).toContain("Found 0 warnings and 0 errors.");    expect(result.stderr).toBe("");  });   it("rejects Schema.Class declarations anywhere", async () => {    const result = await runOxlintOn(      "schema-class.ts",      `        import { Schema } from "effect";         export class Thing extends Schema.Class<Thing>("Thing")({          name: Schema.String,        }) {}      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(no-schema-class)");  });   it("rejects Schema.TaggedClass declarations anywhere", async () => {    const result = await runOxlintOn(      "schema-tagged-class.ts",      `        import { Schema } from "effect";         export class Thing extends Schema.TaggedClass<Thing>()("Thing", {          name: Schema.String,        }) {}      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(no-schema-class)");  });   it("allows Schema.TaggedErrorClass (typed errors are exempt)", async () => {    const result = await runOxlintOn(      "tagged-error.ts",      `        import { Schema } from "effect";         export class MyError extends Schema.TaggedErrorClass<MyError>()("MyError", {          message: Schema.String,        }) {}      `,    );     expect(result.status).toBe(0);  });   it("allows structural HTTP payload schemas", async () => {    const result = await runOxlintOn(      "struct-payload.ts",      `        import { HttpApiEndpoint } from "effect/unstable/httpapi";        import { Schema } from "effect";         const CreateThing = Schema.Struct({          name: Schema.String,        });         HttpApiEndpoint.post("createThing", "/things", {          payload: CreateThing,        });      `,    );     expect(result.status).toBe(0);    expect(result.stdout).toContain("Found 0 warnings and 0 errors.");    expect(result.stderr).toBe("");  });   it("allows typed error messages in Effect.catchTag handlers", async () => {    const result = await runOxlintOn(      "catch-tag-message.ts",      `        import { Effect } from "effect";         declare const program: Effect.Effect<string, { _tag: "DomainError"; message: string }>;         export const handled = program.pipe(          Effect.catchTag("DomainError", (err) => Effect.succeed(err.message)),        );      `,    );     expect(result.status).toBe(0);    expect(result.stdout).toContain("Found 0 warnings and 0 errors.");  });   it("rejects unknown error messages outside Effect.catchTag handlers", async () => {    const result = await runOxlintOn(      "unknown-message.ts",      `        export const format = (err: unknown) => String((err as { message: string }).message);      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(no-unknown-error-message)");  });   it("rejects hand-rolled null predicates in Effect files", async () => {    const result = await runOxlintOn(      "manual-null-predicate.ts",      `        import { Effect } from "effect";         const isNonNull = <A>(value: A | null): value is A => value !== null;         export const values = [Effect.void, null].filter(isNonNull);      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(prefer-effect-predicate)");  });   it("rejects inline nullish filter predicates in Effect files", async () => {    const result = await runOxlintOn(      "inline-nullish-filter.ts",      `        import { Predicate } from "effect";         export const values = ["ok", null].filter((value): value is string => value !== null);      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(prefer-effect-predicate)");  });   it("allows null filters in files that do not import Effect", async () => {    const result = await runOxlintOn(      "plain-null-filter.ts",      `        export const values = ["ok", null].filter((value): value is string => value !== null);      `,    );     expect(result.status).toBe(0);    expect(result.stdout).toContain("Found 0 warnings and 0 errors.");  });   it("rejects raw Durable Object id resolution", async () => {    const result = await runOxlintOn(      "raw-durable-object-id.ts",      `        declare const namespace: {          readonly idFromName: (name: string) => unknown;          readonly idFromString: (id: string) => unknown;        };         namespace.idFromName("session");        namespace.idFromString("session");      `,    );     expect(result.status).toBe(1);    expect(result.stdout).toContain("executor(no-raw-durable-object-id)");    expect(result.stdout).toContain("Use the canonical helper");  });   it("allows canonical Durable Object helper files to resolve ids", () => {    const result = runOxlintFile("packages/hosts/cloudflare/src/mcp/session-stub.ts");     expect(result.status).toBe(0);    expect(result.stdout).toContain("Found 0 warnings and 0 errors.");  });});