@euconform/core 1.4.0 → 1.6.0

package/src/validation/schema-validator.ts

@@ -0,0 +1,147 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import addFormats from "ajv-formats";
+import Ajv2020 from "ajv/dist/2020";
+
+export interface ValidationError {
+  path: string;
+  message: string;
+  keyword: string;
+  expected?: unknown;
+  received?: unknown;
+}
+
+export type SchemaType =
+  | "report.v1"
+  | "aibom.v1"
+  | "aibom.v1.1"
+  | "ci.v1"
+  | "bundle.v1"
+  | "bias.v1"
+  | "bias.v2"
+  | "external-observation.v1";
+
+export interface ValidationResult {
+  valid: boolean;
+  schemaType: SchemaType;
+  errors: ValidationError[];
+}
+
+export interface ValidateOptions {
+  strict?: boolean;
+}
+
+// Resolve schema directory relative to this file at runtime.
+// When bundled into packages/cli/dist, schemas are copied to dist/schemas/.
+// When running from source at packages/core/src/validation/, schemas are at ../../../../docs/spec/schemas.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const _bundledSchemasDir = resolve(__dirname, "schemas");
+const schemasDir = existsSync(_bundledSchemasDir)
+  ? _bundledSchemasDir
+  : resolve(__dirname, "../../../../docs/spec/schemas");
+
+function loadSchema(filename: string): object {
+  const content = readFileSync(resolve(schemasDir, filename), "utf-8");
+  return JSON.parse(content) as object;
+}
+
+const SCHEMA_MAP: Record<string, { schemaFile: string; type: SchemaType }> = {
+  "euconform.report.v1": { schemaFile: "report-v1.schema.json", type: "report.v1" },
+  "euconform.aibom.v1": { schemaFile: "aibom-v1.schema.json", type: "aibom.v1" },
+  "euconform.aibom.v1.1": { schemaFile: "aibom-v1.1.schema.json", type: "aibom.v1.1" },
+  "euconform.ci.v1": { schemaFile: "ci-v1.schema.json", type: "ci.v1" },
+  "euconform.bundle.v1": { schemaFile: "bundle-v1.schema.json", type: "bundle.v1" },
+  "euconform.bias.v1": { schemaFile: "bias-v1.schema.json", type: "bias.v1" },
+  "euconform.bias.v2": { schemaFile: "bias-v2.schema.json", type: "bias.v2" },
+  "euconform.external-observation.v1": {
+    schemaFile: "external-observation-v1.schema.json",
+    type: "external-observation.v1",
+  },
+};
+
+let ajvInstance: Ajv2020 | null = null;
+
+function getAjv(): Ajv2020 {
+  if (!ajvInstance) {
+    ajvInstance = new Ajv2020({ allErrors: true, strict: false });
+    addFormats(ajvInstance);
+  }
+  return ajvInstance;
+}
+
+export function validate(data: unknown, _options?: ValidateOptions): ValidationResult {
+  if (typeof data !== "object" || data === null) {
+    return {
+      valid: false,
+      schemaType: "report.v1",
+      errors: [
+        {
+          path: "",
+          message: "Input must be a JSON object",
+          keyword: "type",
+          expected: "object",
+          received: typeof data,
+        },
+      ],
+    };
+  }
+
+  const record = data as Record<string, unknown>;
+  const schemaVersion = record.schemaVersion;
+
+  if (typeof schemaVersion !== "string") {
+    return {
+      valid: false,
+      schemaType: "report.v1",
+      errors: [
+        {
+          path: "",
+          message: `Missing or invalid schemaVersion field. Expected one of: ${Object.keys(SCHEMA_MAP).join(", ")}`,
+          keyword: "required",
+        },
+      ],
+    };
+  }
+
+  const entry = SCHEMA_MAP[schemaVersion];
+  if (!entry) {
+    return {
+      valid: false,
+      schemaType: "report.v1",
+      errors: [
+        {
+          path: "/schemaVersion",
+          message: `Unknown schemaVersion "${schemaVersion}". Expected one of: ${Object.keys(SCHEMA_MAP).join(", ")}`,
+          keyword: "const",
+          expected: Object.keys(SCHEMA_MAP),
+          received: schemaVersion,
+        },
+      ],
+    };
+  }
+
+  const ajv = getAjv();
+  let validateFn = ajv.getSchema(schemaVersion);
+  if (!validateFn) {
+    const schema = loadSchema(entry.schemaFile);
+    validateFn = ajv.compile({ ...schema, $id: schemaVersion });
+  }
+
+  const valid = validateFn(data) as boolean;
+
+  if (valid) {
+    return { valid: true, schemaType: entry.type, errors: [] };
+  }
+
+  const errors: ValidationError[] = (validateFn.errors ?? []).map((err) => ({
+    path: err.instancePath ?? "",
+    message: err.message ?? "Validation error",
+    keyword: err.keyword ?? "unknown",
+    expected: err.params,
+    received: undefined,
+  }));
+
+  return { valid: false, schemaType: entry.type, errors };
+}

package/tests/annex-iv-report.test.ts

@@ -78,7 +78,7 @@ describe("Annex IV Report Generation", () => {
           engine: "browser",
           crowsPairsResult: {
             score: 0.15,
-            method: "logprobs_exact",
+            method: "sequence_logprob_sum",
             pairsAnalyzed: 100,
             stereotypicalPreference: 65.5,
             metadata: {

package/tests/capability-detection.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "vitest";
+import {
+  DefaultCapabilityDetectionService,
+  EnhancedCapabilityDetectionService,
+} from "../src/inference/capability-detection";
+
+/**
+ * Browser/transformers.js capability entries are declared from a static model
+ * list — no model is actually loaded or tested to produce them. Reporting
+ * `status: "available"` with a fresh `lastTested` for that would claim a test
+ * ran when it didn't (see Messmotor-Sanierung Task 2). This pins the honest
+ * runtime values: `status: "unverified"` and no `lastTested`.
+ */
+describe("capability detection: browser/transformers entries are not overclaimed", () => {
+  it("DefaultCapabilityDetectionService.detectModelCapability reports 'unverified', not 'available', for browser", async () => {
+    const service = new DefaultCapabilityDetectionService();
+    const capability = await service.detectModelCapability("Xenova/distilgpt2", "browser");
+
+    expect(capability.status).toBe("unverified");
+    expect(capability.lastTested).toBeUndefined();
+    // The declared method may still be reported (renaming is Task 3's job) —
+    // it just must not be dressed up as measured.
+    expect(capability.method).toBe("logprobs_exact");
+  });
+
+  it("EnhancedCapabilityDetectionService.detectModelCapability reports 'unverified', not 'available', for browser", async () => {
+    const service = new EnhancedCapabilityDetectionService();
+    const capability = await service.detectModelCapability("Xenova/distilgpt2", "browser");
+
+    expect(capability.status).toBe("unverified");
+    expect(capability.lastTested).toBeUndefined();
+  });
+
+  it("'unverified' is not scored as 0 by the recommendation ranking (regression guard)", async () => {
+    // Exercise the same code path detectAllCapabilities uses, without touching
+    // the network (no live Ollama in CI): detect a single browser capability
+    // and confirm it sorts ahead of an explicitly zero-scored "error" entry.
+    const service = new DefaultCapabilityDetectionService();
+    const browserCapability = await service.detectModelCapability("Xenova/distilgpt2", "browser");
+    const errorCapability = {
+      modelId: "broken-model",
+      engine: "ollama" as const,
+      method: "logprobs_fallback_latency" as const,
+      status: "error" as const,
+      lastTested: new Date().toISOString(),
+    };
+
+    // sortByRecommendation is protected; reach it through the public
+    // detectAllCapabilities-equivalent ordering contract by calling the same
+    // scoring indirectly via Array#sort with the class's own comparator is not
+    // exposed, so assert the documented invariant directly instead: an
+    // "unverified" capability must score above a definitionally-zero one.
+    // biome-ignore lint/suspicious/noExplicitAny: reaching a protected method for a focused unit check
+    const score = (service as any).getRecommendationScore.bind(service);
+    expect(score(browserCapability)).toBeGreaterThan(score(errorCapability));
+  });
+});