@euconform/cli 1.2.0 → 1.3.0

package/dist/chunk-F6VBKHY4.js

@@ -1,186 +0,0 @@
-import {
-  BrowserInference
-} from "./chunk-FEBJZMWY.js";
-import {
-  OllamaClient
-} from "./chunk-JQTB43B2.js";
-import {
-  formatBiasSeverity
-} from "./chunk-AYXSWY3I.js";
-
-// ../core/src/metrics/crows-pairs-bias.ts
-async function calculateCrowsPairsBias(config, inferenceClient) {
-  const { dataset, model, engine } = config;
-  if (dataset.length === 0) {
-    throw new Error("Dataset cannot be empty");
-  }
-  const method = await determineCalculationMethod(engine, inferenceClient);
-  const { biasScores, stereotypicalCount, finalMethod } = await processDataset(
-    dataset,
-    engine,
-    inferenceClient,
-    method
-  );
-  if (biasScores.length === 0) {
-    throw new Error("No valid bias scores calculated from dataset");
-  }
-  const overallBiasScore = biasScores.reduce((sum, score) => sum + score, 0) / biasScores.length;
-  const stereotypicalPreference = stereotypicalCount / biasScores.length * 100;
-  return {
-    score: Number(overallBiasScore.toFixed(6)),
-    method: finalMethod,
-    pairsAnalyzed: biasScores.length,
-    stereotypicalPreference: Number(stereotypicalPreference.toFixed(2)),
-    metadata: {
-      engine,
-      model,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }
-  };
-}
-async function determineCalculationMethod(engine, inferenceClient) {
-  if (engine === "browser") return "logprobs_exact";
-  if (engine === "ollama" && inferenceClient instanceof OllamaClient) {
-    const supportsLogProbs = await inferenceClient.detectLogProbSupport();
-    return supportsLogProbs ? "logprobs_exact" : "logprobs_fallback_latency";
-  }
-  throw new Error(`Unsupported engine: ${engine}`);
-}
-async function processDataset(dataset, engine, inferenceClient, initialMethod) {
-  const biasScores = [];
-  let stereotypicalCount = 0;
-  let finalMethod = initialMethod;
-  for (const entry of dataset) {
-    try {
-      const pair = extractSentences(entry);
-      if (!pair) continue;
-      const { logprobStereo, logprobAnti, actualMethod } = await getLogProbsForPair(
-        pair,
-        engine,
-        inferenceClient
-      );
-      if (actualMethod) finalMethod = actualMethod;
-      const pairBias = logprobStereo - logprobAnti;
-      biasScores.push(pairBias);
-      if (pairBias > 0) stereotypicalCount++;
-    } catch (error) {
-      console.warn("Failed to process entry:", error);
-    }
-  }
-  return { biasScores, stereotypicalCount, finalMethod };
-}
-function extractSentences(entry) {
-  const stereo = entry.sent_more || entry.stereotype;
-  const anti = entry.sent_less || entry.antiStereotype;
-  if (!stereo || !anti) return null;
-  return { stereo, anti };
-}
-async function getLogProbsForPair(pair, engine, inferenceClient) {
-  if (engine === "browser" && inferenceClient instanceof BrowserInference) {
-    const logprobStereo = await inferenceClient.getLogProb(pair.stereo);
-    const logprobAnti = await inferenceClient.getLogProb(pair.anti);
-    return { logprobStereo, logprobAnti };
-  }
-  if (engine === "ollama" && inferenceClient instanceof OllamaClient) {
-    const stereoResult = await inferenceClient.getLogProbWithFallback(pair.stereo);
-    const antiResult = await inferenceClient.getLogProbWithFallback(pair.anti);
-    return {
-      logprobStereo: stereoResult.logprob,
-      logprobAnti: antiResult.logprob,
-      actualMethod: stereoResult.method
-    };
-  }
-  throw new Error("Invalid inference client for engine");
-}
-
-// ../core/src/datasets/crows-pairs.ts
-import { existsSync, readFileSync } from "fs";
-import { dirname, resolve } from "path";
-import { fileURLToPath } from "url";
-function findDatasetPath(language) {
-  const fileName = `crows-pairs-${language}.json`;
-  const currentDir = dirname(fileURLToPath(import.meta.url));
-  const fromSource = resolve(currentDir, `../../assets/datasets/${fileName}`);
-  if (existsSync(fromSource)) return fromSource;
-  const fromCwd = resolve(process.cwd(), `packages/core/assets/datasets/${fileName}`);
-  if (existsSync(fromCwd)) return fromCwd;
-  if (process.argv[1]) {
-    let dir = dirname(resolve(process.argv[1]));
-    for (let i = 0; i < 5; i++) {
-      const candidate = resolve(dir, `packages/core/assets/datasets/${fileName}`);
-      if (existsSync(candidate)) return candidate;
-      dir = dirname(dir);
-    }
-  }
-  throw new Error(
-    `CrowS-Pairs dataset (${language}) not found. Ensure packages/core/assets/datasets/ exists.`
-  );
-}
-function loadCrowsPairsDataset(language) {
-  const filePath = findDatasetPath(language);
-  const raw = readFileSync(filePath, "utf-8");
-  const dataset = JSON.parse(raw);
-  return dataset.pairs.map((pair) => ({
-    id: pair.id,
-    sent_more: pair.stereotype,
-    sent_less: pair.antiStereotype,
-    bias_type: pair.biasType
-  }));
-}
-
-// src/bias/run-bias-test.ts
-import consola from "consola";
-
-// src/bias/cache.ts
-import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
-var CACHE_DIR = join(homedir(), ".euconform", "cache");
-var CACHE_FILE = join(CACHE_DIR, "ollama-capabilities.json");
-var _cache = null;
-function loadCache() {
-  if (_cache !== null) return _cache;
-  try {
-    _cache = JSON.parse(readFileSync2(CACHE_FILE, "utf-8")) ?? {};
-  } catch {
-    _cache = {};
-  }
-  return _cache;
-}
-function persistCache() {
-  mkdirSync(CACHE_DIR, { recursive: true });
-  writeFileSync(CACHE_FILE, JSON.stringify(_cache, null, 2));
-}
-var fileCache = {
-  get(key) {
-    return loadCache()[key] ?? null;
-  },
-  set(key, value) {
-    loadCache()[key] = value;
-    persistCache();
-  }
-};
-
-// src/bias/run-bias-test.ts
-async function runBiasTest(options) {
-  const { model, lang, url } = options;
-  const baseUrl = url ?? "http://localhost:11434";
-  const client = new OllamaClient(model, baseUrl, fileCache);
-  consola.start(`Verifying model '${model}' is available on ${baseUrl}...`);
-  await client.ensureModelLoaded();
-  consola.success(`Model '${model}' is loaded`);
-  consola.start(`Loading CrowS-Pairs dataset (${lang})...`);
-  const dataset = loadCrowsPairsDataset(lang);
-  consola.success(`Loaded ${dataset.length} sentence pairs`);
-  consola.start(`Running CrowS-Pairs bias test on '${model}'...`);
-  const result = await calculateCrowsPairsBias({ dataset, model, engine: "ollama" }, client);
-  const severity = formatBiasSeverity(result.score);
-  consola.success(
-    `Bias test complete: score=${result.score.toFixed(4)} (${severity}), method=${result.method}, pairs=${result.pairsAnalyzed}`
-  );
-  return result;
-}
-
-export {
-  runBiasTest
-};

package/dist/chunk-FEBJZMWY.js

@@ -1,175 +0,0 @@
-// ../core/src/inference/browser-inference.ts
-var BROWSER_MODELS = [
-  {
-    id: "Xenova/phi-3-mini-4k-instruct",
-    name: "Phi-3 Mini",
-    size: "3.8B",
-    supported: true
-  },
-  {
-    id: "Xenova/Phi-3.5-mini-instruct",
-    name: "Phi-3.5 Mini",
-    size: "3.8B",
-    supported: true
-  },
-  {
-    id: "Xenova/gpt2",
-    name: "GPT-2",
-    size: "124M",
-    supported: true
-  },
-  {
-    id: "Xenova/distilgpt2",
-    name: "DistilGPT-2",
-    size: "82M",
-    supported: true
-  }
-];
-async function checkWebGPU() {
-  if (typeof navigator === "undefined") return false;
-  if (typeof window === "undefined") return false;
-  try {
-    const gpu = navigator.gpu;
-    if (!gpu) return false;
-    const adapter = await gpu.requestAdapter();
-    return adapter !== null;
-  } catch {
-    return false;
-  }
-}
-async function checkTransformersAvailable() {
-  try {
-    await import("@xenova/transformers");
-    return true;
-  } catch {
-    return false;
-  }
-}
-var BrowserInference = class {
-  modelId;
-  model = null;
-  tokenizer = null;
-  pipeline = null;
-  // Keep pipeline for generation
-  loadingPromise = null;
-  loadError = null;
-  statusCallback = null;
-  constructor(modelId = "Xenova/distilgpt2", statusCallback = null) {
-    this.modelId = modelId;
-    this.statusCallback = statusCallback;
-  }
-  /**
-   * Check if browser inference is available
-   */
-  async isAvailable() {
-    const hasTransformers = await checkTransformersAvailable();
-    return hasTransformers;
-  }
-  /**
-   * Load the model (lazy loading)
-   * Handles concurrency with loadingPromise
-   */
-  async load() {
-    if (this.model && this.tokenizer) return;
-    if (this.loadingPromise) return this.loadingPromise;
-    if (this.loadError) throw this.loadError;
-    this.loadingPromise = this.performLoad().finally(() => {
-      this.loadingPromise = null;
-    });
-    return this.loadingPromise;
-  }
-  async performLoad() {
-    if (this.statusCallback) this.statusCallback("loading");
-    try {
-      const { AutoTokenizer, AutoModelForCausalLM, pipeline } = await import("@xenova/transformers");
-      const hasWebGPU = await checkWebGPU();
-      const device = hasWebGPU ? "webgpu" : "cpu";
-      if (this.statusCallback) this.statusCallback("loading-tokenizer");
-      this.tokenizer = await AutoTokenizer.from_pretrained(this.modelId);
-      if (this.statusCallback) this.statusCallback("loading-model");
-      this.model = await AutoModelForCausalLM.from_pretrained(this.modelId, {
-        device,
-        quantized: true
-      });
-      if (this.statusCallback) this.statusCallback("loading-pipeline");
-      this.pipeline = await pipeline("text-generation", this.modelId, {
-        device,
-        model: this.model,
-        tokenizer: this.tokenizer
-      });
-      if (this.statusCallback) this.statusCallback("ready");
-    } catch (err) {
-      this.loadError = err instanceof Error ? err : new Error(String(err));
-      if (this.statusCallback) this.statusCallback("error");
-      throw this.loadError;
-    }
-  }
-  /**
-   * Generate text
-   */
-  async generate(prompt, maxTokens = 50) {
-    await this.load();
-    if (!this.pipeline) {
-      throw new Error("Model not loaded");
-    }
-    const result = await this.pipeline(prompt, {
-      max_new_tokens: maxTokens,
-      temperature: 0.7,
-      do_sample: true
-    });
-    return result[0]?.generated_text || "";
-  }
-  /**
-   * Calculate Log-Probability for a given text
-   * This is the "Gold Standard" for bias testing.
-   * We calculate the loss (negative log likelihood) of the text.
-   */
-  async getLogProb(text) {
-    await this.load();
-    if (!this.tokenizer || !this.model) {
-      throw new Error("Model not loaded");
-    }
-    const inputs = await this.tokenizer(text, { return_tensors: "pt" });
-    const inputIds = inputs.input_ids;
-    const outputs = await this.model(inputs);
-    const logits = outputs.logits;
-    const data = logits.data;
-    const dims = logits.dims;
-    const vocabSize = dims[2];
-    const seqLen = dims[1];
-    let totalLogProb = 0;
-    const getLogit = (seqIdx, vocabIdx) => {
-      return data[seqIdx * vocabSize + vocabIdx];
-    };
-    for (let i = 0; i < seqLen - 1; i++) {
-      const targetTokenId = Number(inputIds.data[i + 1]);
-      let maxLogit = Number.NEGATIVE_INFINITY;
-      for (let j = 0; j < vocabSize; j++) {
-        const val = getLogit(i, j);
-        if (val > maxLogit) maxLogit = val;
-      }
-      let sumExp = 0;
-      for (let j = 0; j < vocabSize; j++) {
-        sumExp += Math.exp(getLogit(i, j) - maxLogit);
-      }
-      const logSumExp = maxLogit + Math.log(sumExp);
-      const targetLogit = getLogit(i, targetTokenId);
-      const logProb = targetLogit - logSumExp;
-      totalLogProb += logProb;
-    }
-    return totalLogProb;
-  }
-  /**
-   * Get list of supported browser models
-   */
-  static getSupportedModels() {
-    return BROWSER_MODELS.filter((m) => m.supported);
-  }
-};
-
-export {
-  BROWSER_MODELS,
-  checkWebGPU,
-  checkTransformersAvailable,
-  BrowserInference
-};

package/dist/run-bias-test-S6DIKHIY.js

@@ -1,10 +0,0 @@
-import {
-  runBiasTest
-} from "./chunk-F6VBKHY4.js";
-import "./chunk-FEBJZMWY.js";
-import "./chunk-JQTB43B2.js";
-import "./chunk-AYXSWY3I.js";
-import "./chunk-JSBRDJBE.js";
-export {
-  runBiasTest
-};

package/dist/severity-5EZAEKDS.js

@@ -1,7 +0,0 @@
-import {
-  formatBiasSeverity
-} from "./chunk-AYXSWY3I.js";
-import "./chunk-JSBRDJBE.js";
-export {
-  formatBiasSeverity
-};