@euconform/core 1.4.0 → 1.6.0

package/tests/stilled-ollama-paths.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "vitest";
+import {
+  runComprehensiveBiasAnalysisWithFactory,
+  runCrowsPairsBiasAnalysisWithFactory,
+} from "../src/fairness-metrics";
+import type { InferenceClient } from "../src/inference";
+import { InferenceFactory } from "../src/inference/inference-factory";
+import { runCrowsPairsLogProbTest } from "../src/legal-checks/bias-metrics";
+import { quickBiasCheck, runStereotypeBiasTest, testPair } from "../src/metrics/stereotype-bias";
+import type { BiasTestConfig } from "../src/types";
+
+/**
+ * These entry points measured bias via Ollama's `getLogProb` (a latency proxy,
+ * not a real sentence log-probability — see Messmotor-Sanierung Task 2) and
+ * cannot be trivially converted to the new `SequenceLogProbProvider` contract
+ * without a real redesign (auto engine-selection, capability detection, etc.).
+ * They're stilled: calling them throws a speaking message pointing at the
+ * supported path instead of silently producing a broken measurement.
+ */
+describe("stilled Ollama-era entry points", () => {
+  const dummyClient: InferenceClient = {
+    engine: "ollama",
+    modelId: "dummy",
+    generate: async () => "",
+    getLogProb: async () => 0,
+  };
+
+  it("testPair throws with a pointer to bias --engine transformers", async () => {
+    await expect(
+      testPair(dummyClient, {
+        id: 1,
+        stereotype: "a",
+        antiStereotype: "b",
+        biasType: "gender",
+      })
+    ).rejects.toThrow(/bias --engine transformers/);
+  });
+
+  it("runStereotypeBiasTest throws with a pointer to bias --engine transformers", async () => {
+    await expect(runStereotypeBiasTest(dummyClient, [])).rejects.toThrow(
+      /bias --engine transformers/
+    );
+  });
+
+  it("quickBiasCheck throws with a pointer to bias --engine transformers", async () => {
+    await expect(quickBiasCheck(dummyClient, [])).rejects.toThrow(/bias --engine transformers/);
+  });
+
+  it("runCrowsPairsLogProbTest throws with a pointer to bias --engine transformers", async () => {
+    await expect(runCrowsPairsLogProbTest(dummyClient, [])).rejects.toThrow(
+      /bias --engine transformers/
+    );
+  });
+
+  it("InferenceFactory.createBiasCalculation throws with a pointer to bias --engine transformers", async () => {
+    const factory = new InferenceFactory();
+    const config: BiasTestConfig = { dataset: [], model: "m", engine: "browser" };
+    await expect(factory.createBiasCalculation(config)).rejects.toThrow(
+      /bias --engine transformers/
+    );
+  });
+
+  it("runCrowsPairsBiasAnalysisWithFactory throws with a pointer to bias --engine transformers", async () => {
+    const config: BiasTestConfig = { dataset: [], model: "m", engine: "browser" };
+    await expect(runCrowsPairsBiasAnalysisWithFactory(config)).rejects.toThrow(
+      /bias --engine transformers/
+    );
+  });
+
+  it("runComprehensiveBiasAnalysisWithFactory throws with a pointer to bias --engine transformers", async () => {
+    const config: BiasTestConfig = { dataset: [], model: "m", engine: "browser" };
+    await expect(runComprehensiveBiasAnalysisWithFactory([], config, "gender")).rejects.toThrow(
+      /bias --engine transformers/
+    );
+  });
+});

package/tests/validation/schema-validator.test.ts

@@ -0,0 +1,219 @@
+import { describe, expect, it } from "vitest";
+import { validate } from "../../src/validation/schema-validator";
+
+describe("schema-validator", () => {
+  describe("auto-detection", () => {
+    it("detects report.v1 schema type", () => {
+      const result = validate({
+        schemaVersion: "euconform.report.v1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        tool: { name: "euconform", version: "1.0.0" },
+        target: {
+          name: "test",
+          rootPath: "/test",
+          repoType: "unknown",
+          detectedStack: [],
+        },
+        aiFootprint: {
+          usesAI: false,
+          inferenceModes: [],
+          providerHints: [],
+          ragHints: [],
+        },
+        complianceSignals: {
+          disclosure: { status: "unknown", confidence: "low", evidence: [] },
+          biasTesting: { status: "unknown", confidence: "low", evidence: [] },
+          reportingExports: { status: "unknown", confidence: "low", evidence: [] },
+          loggingMonitoring: { status: "unknown", confidence: "low", evidence: [] },
+          humanOversight: { status: "unknown", confidence: "low", evidence: [] },
+          dataGovernance: { status: "unknown", confidence: "low", evidence: [] },
+          incidentReporting: { status: "unknown", confidence: "low", evidence: [] },
+        },
+        assessmentHints: {
+          possibleModes: [],
+          riskIndicators: [],
+          gpaiIndicators: [],
+          openQuestions: [],
+        },
+        gaps: [],
+        recommendationSummary: [],
+      });
+      expect(result.schemaType).toBe("report.v1");
+      expect(result.valid).toBe(true);
+      expect(result.errors).toEqual([]);
+    });
+
+    it("detects aibom.v1 schema type", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        project: { name: "test", rootPath: "/test" },
+        components: [],
+        complianceCapabilities: {
+          biasEvaluation: false,
+          jsonExport: true,
+          pdfExport: false,
+          loggingInfrastructure: false,
+          humanReviewFlow: false,
+          incidentHandling: false,
+        },
+      });
+      expect(result.schemaType).toBe("aibom.v1");
+      expect(result.valid).toBe(true);
+    });
+
+    it("returns error for missing schemaVersion", () => {
+      const result = validate({ foo: "bar" });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toContain("schemaVersion");
+    });
+
+    it("returns error for unknown schemaVersion", () => {
+      const result = validate({ schemaVersion: "euconform.unknown.v9" });
+      expect(result.valid).toBe(false);
+      expect(result.errors[0].message).toContain("unknown");
+    });
+  });
+
+  describe("validation errors", () => {
+    it("reports missing required fields", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors.length).toBeGreaterThan(0);
+      const paths = result.errors.map((e) => e.path);
+      expect(paths).toContain("");
+    });
+
+    it("reports invalid enum values", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        project: { name: "test", rootPath: "/test" },
+        components: [
+          {
+            id: "bad:component",
+            kind: "invalid-kind",
+            name: "Bad",
+            source: "package.json",
+          },
+        ],
+        complianceCapabilities: {
+          biasEvaluation: false,
+          jsonExport: false,
+          pdfExport: false,
+          loggingInfrastructure: false,
+          humanReviewFlow: false,
+          incidentHandling: false,
+        },
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.keyword === "enum")).toBe(true);
+    });
+
+    it("reports additional properties", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        project: { name: "test", rootPath: "/test" },
+        components: [],
+        complianceCapabilities: {
+          biasEvaluation: false,
+          jsonExport: false,
+          pdfExport: false,
+          loggingInfrastructure: false,
+          humanReviewFlow: false,
+          incidentHandling: false,
+        },
+        extraField: "should fail",
+      });
+      expect(result.valid).toBe(false);
+      expect(result.errors.some((e) => e.keyword === "additionalProperties")).toBe(true);
+    });
+
+    it("accepts sbom-import as valid source", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        project: { name: "test", rootPath: "/test" },
+        components: [
+          {
+            id: "ai-framework:torch",
+            kind: "ai-framework",
+            name: "torch",
+            version: "2.0.0",
+            source: "sbom-import",
+          },
+        ],
+        complianceCapabilities: {
+          biasEvaluation: false,
+          jsonExport: false,
+          pdfExport: false,
+          loggingInfrastructure: false,
+          humanReviewFlow: false,
+          incidentHandling: false,
+        },
+      });
+      expect(result.valid).toBe(true);
+    });
+
+    it("accepts aibom v1.1 with metadata field", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1.1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        project: { name: "test", rootPath: "/test" },
+        components: [],
+        complianceCapabilities: {
+          biasEvaluation: false,
+          jsonExport: false,
+          pdfExport: false,
+          loggingInfrastructure: false,
+          humanReviewFlow: false,
+          incidentHandling: false,
+        },
+        metadata: {
+          importSource: "cyclonedx",
+          importTool: "cdxgen 10.0.0",
+          originalTimestamp: "2026-04-19T10:00:00Z",
+        },
+      });
+      expect(result.valid).toBe(true);
+    });
+
+    it("rejects aibom v1 with metadata field", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+        generatedAt: "2026-01-01T00:00:00Z",
+        project: { name: "test", rootPath: "/test" },
+        components: [],
+        complianceCapabilities: {
+          biasEvaluation: false,
+          jsonExport: false,
+          pdfExport: false,
+          loggingInfrastructure: false,
+          humanReviewFlow: false,
+          incidentHandling: false,
+        },
+        metadata: {
+          importSource: "cyclonedx",
+        },
+      });
+      expect(result.valid).toBe(false);
+    });
+  });
+
+  describe("ValidationResult structure", () => {
+    it("returns structured errors with path, message, keyword", () => {
+      const result = validate({
+        schemaVersion: "euconform.aibom.v1",
+      });
+      expect(result.valid).toBe(false);
+      for (const error of result.errors) {
+        expect(error).toHaveProperty("path");
+        expect(error).toHaveProperty("message");
+        expect(error).toHaveProperty("keyword");
+      }
+    });
+  });
+});

package/src/inference/transformers.d.ts

@@ -1,62 +0,0 @@
-/**
- * Type declarations for @xenova/transformers (optional dependency)
- *
- * This package is only needed for browser-based inference.
- * If not installed, browser inference will gracefully fall back.
- */
-
-declare module "@xenova/transformers" {
-  export function pipeline(
-    task: "text-generation",
-    model: string,
-    options?: {
-      device?: "webgpu" | "cpu";
-    }
-  ): Promise<TextGenerationPipeline>;
-
-  export type TextGenerationPipeline = (
-    text: string,
-    options?: {
-      max_new_tokens?: number;
-      temperature?: number;
-      do_sample?: boolean;
-    }
-  ) => Promise<Array<{ generated_text: string }>>;
-
-  export interface Tensor {
-    data: Float32Array;
-    dims: number[];
-  }
-
-  export interface ModelOutput {
-    logits: Tensor;
-  }
-
-  export interface TokenizerOutput {
-    input_ids: Tensor;
-  }
-
-  export interface AutoTokenizer {
-    (text: string, options?: { return_tensors?: string }): Promise<TokenizerOutput>;
-    from_pretrained(modelId: string): Promise<AutoTokenizer>;
-  }
-
-  export interface AutoModelForCausalLM {
-    (inputs: TokenizerOutput): Promise<ModelOutput>;
-    from_pretrained(
-      modelId: string,
-      options?: { device?: string; dtype?: string }
-    ): Promise<AutoModelForCausalLM>;
-  }
-
-  export const AutoTokenizer: {
-    from_pretrained(modelId: string): Promise<AutoTokenizer>;
-  };
-
-  export const AutoModelForCausalLM: {
-    from_pretrained(
-      modelId: string,
-      options?: { device?: string; dtype?: string }
-    ): Promise<AutoModelForCausalLM>;
-  };
-}