@euconform/core 1.0.0

package/dist/inference/ollama-client.js

@@ -0,0 +1,386 @@
+/**
+ * Ollama Client for local LLM inference
+ * Connects to Ollama running on localhost:11434
+ */
+const OLLAMA_BASE_URL = "http://localhost:11434";
+/**
+ * Check if Ollama is running and accessible
+ */
+export async function detectOllama() {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 2000);
+        const response = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get list of available models from Ollama
+ */
+export async function listOllamaModels() {
+    try {
+        const response = await fetch(`${OLLAMA_BASE_URL}/api/tags`);
+        if (!response.ok) {
+            throw new Error(`Failed to list models: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data.models || [];
+    }
+    catch (error) {
+        console.error("Failed to list Ollama models:", error);
+        return [];
+    }
+}
+/**
+ * Generate text with Ollama
+ */
+export async function ollamaGenerate(options) {
+    const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            ...options,
+            stream: false,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Ollama generate failed (${response.status}): ${errorText || response.statusText}`);
+    }
+    return response.json();
+}
+/**
+ * Get log probability for a prompt (for bias scoring)
+ * Uses the /api/generate endpoint with num_predict: 0 to get prompt logprobs
+ */
+export async function getLogProb(model, prompt) {
+    try {
+        // Use generate with num_predict: 0 to ONLY evaluate the prompt
+        // This forces the model to process the input tokens, giving us prompt_eval metrics
+        const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model,
+                prompt,
+                stream: false,
+                options: {
+                    num_predict: 0, // Don't generate, just evaluate prompt
+                    temperature: 0,
+                },
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Failed to get logprob for model '${model}': ${errorText || response.statusText}`);
+        }
+        const data = await response.json();
+        // Optimization: Use prompt_eval metrics (processing time of the input)
+        // This is a better proxy for "perplexity" or "likelihood" of the sentence than generation speed
+        if (data.prompt_eval_duration && data.prompt_eval_count) {
+            const timePerToken = data.prompt_eval_duration / data.prompt_eval_count / 1e9; // ns to s
+            // Normalize: faster processing = higher probability (lower surprise)
+            // We return negative log of time to mimic log-prob scale (higher is better)
+            return -Math.log(timePerToken + 0.00001); // Smaller epsilon for precision
+        }
+        // Fallback: use eval metrics if prompt metrics missing (rare)
+        if (data.eval_duration && data.eval_count) {
+            const timePerToken = data.eval_duration / data.eval_count / 1e9;
+            return -Math.log(timePerToken + 0.001);
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(`Error calculating log probability for model ${model}:`, error);
+        throw error; // Re-throw to let caller handle it
+    }
+}
+/**
+ * Calculate perplexity for a text (alternative bias metric)
+ */
+export async function getPerplexity(model, text) {
+    try {
+        const response = await fetch(`${OLLAMA_BASE_URL}/api/generate`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model,
+                prompt: text,
+                stream: false,
+                options: {
+                    num_predict: 0, // Don't generate, just evaluate prompt
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to get perplexity: ${response.statusText}`);
+        }
+        const data = await response.json();
+        // Perplexity approximation from eval metrics
+        if (data.prompt_eval_duration && data.prompt_eval_count) {
+            // Normalize by token count for fair comparison across different lengths
+            const avgTimePerToken = data.prompt_eval_duration / data.prompt_eval_count / 1e9;
+            return avgTimePerToken * 1000; // Scale for readability
+        }
+        return 1;
+    }
+    catch (error) {
+        console.error("Failed to get perplexity:", error);
+        return 1;
+    }
+}
+/**
+ * Ollama client class for stateful operations
+ */
+export class OllamaClient {
+    baseUrl;
+    model;
+    capabilityCache;
+    constructor(model, baseUrl = OLLAMA_BASE_URL) {
+        this.baseUrl = baseUrl;
+        this.model = model;
+        this.capabilityCache = new Map();
+    }
+    /**
+     * Ensures the model is available in Ollama before proceeding
+     * Throws an error if the model is not found
+     */
+    async ensureModelLoaded() {
+        const models = await listOllamaModels();
+        // Check if exact match or if the model name is contained (e.g. "llama3.2" in "llama3.2:latest")
+        const modelExists = models.some((m) => m.name === this.model ||
+            m.name.startsWith(`${this.model}:`) ||
+            this.model.startsWith(`${m.name}:`));
+        if (!modelExists) {
+            throw new Error(`Model '${this.model}' not found in Ollama. Please run 'ollama pull ${this.model}' first.`);
+        }
+    }
+    async isAvailable() {
+        return detectOllama();
+    }
+    async generate(prompt) {
+        await this.ensureModelLoaded();
+        const response = await ollamaGenerate({
+            model: this.model,
+            prompt,
+        });
+        return response.response;
+    }
+    async getLogProb(prompt) {
+        // Use the enhanced getLogProbWithFallback method that supports both exact and fallback methods
+        const result = await this.getLogProbWithFallback(prompt);
+        return result.logprob;
+    }
+    async getPerplexity(text) {
+        return getPerplexity(this.model, text);
+    }
+    /**
+     * Test if the current model supports log-probabilities
+     * Sends a test request with "Der" prompt to detect capability
+     */
+    async testLogProbCapability() {
+        try {
+            // First check Ollama version
+            try {
+                const versionResponse = await fetch(`${this.baseUrl}/api/version`);
+                if (versionResponse.ok) {
+                    const versionData = await versionResponse.json();
+                    console.log(`🔍 Ollama version: ${versionData.version || "unknown"}`);
+                }
+            }
+            catch {
+                // Version check is optional
+            }
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: this.model,
+                    prompt: "Der",
+                    stream: false,
+                    logprobs: true,
+                    options: {
+                        num_predict: 1,
+                        temperature: 0,
+                    },
+                }),
+            });
+            if (!response.ok) {
+                console.warn(`🔍 Capability test request failed for ${this.model}: ${response.status} ${response.statusText}`);
+                return false;
+            }
+            const data = await response.json();
+            // Check if logprobs are present and valid
+            const hasLogProbs = !!(data.logprobs &&
+                Array.isArray(data.logprobs) &&
+                data.logprobs.length > 0);
+            console.log(`🔍 Capability test for ${this.model}: ${hasLogProbs ? "✅ supports" : "❌ no support"} log-probabilities`, data.logprobs ? `(${data.logprobs.length} tokens)` : "(no logprobs field)");
+            if (!hasLogProbs) {
+                console.log("🔍 Full response for debugging:", JSON.stringify(data, null, 2));
+            }
+            return hasLogProbs;
+        }
+        catch (error) {
+            console.warn(`Log-probability capability test failed for model ${this.model}:`, error);
+            return false;
+        }
+    }
+    /**
+     * Get cached capability result from localStorage
+     */
+    getCachedCapability() {
+        try {
+            const cacheKey = `ollama_supports_logprobs_${this.model}`;
+            const cached = localStorage.getItem(cacheKey);
+            if (cached) {
+                const capability = JSON.parse(cached);
+                // Check if cache is still valid (24 hours)
+                const cacheAge = Date.now() - new Date(capability.testedAt).getTime();
+                const maxAge = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+                if (cacheAge < maxAge) {
+                    return capability;
+                }
+            }
+        }
+        catch (error) {
+            console.warn("Failed to read capability cache:", error);
+        }
+        return null;
+    }
+    /**
+     * Cache capability result in localStorage
+     */
+    setCachedCapability(supports) {
+        try {
+            const cacheKey = `ollama_supports_logprobs_${this.model}`;
+            const capability = {
+                model: this.model,
+                supportsLogProbs: supports,
+                testedAt: new Date().toISOString(),
+            };
+            localStorage.setItem(cacheKey, JSON.stringify(capability));
+            this.capabilityCache.set(this.model, capability);
+        }
+        catch (error) {
+            console.warn("Failed to cache capability result:", error);
+        }
+    }
+    /**
+     * Detect if the current model supports log-probabilities
+     * Checks cache first, then runs test if needed
+     */
+    async detectLogProbSupport() {
+        // Check in-memory cache first
+        const memoryCache = this.capabilityCache.get(this.model);
+        if (memoryCache) {
+            return memoryCache.supportsLogProbs;
+        }
+        // Check localStorage cache
+        const cached = this.getCachedCapability();
+        if (cached) {
+            this.capabilityCache.set(this.model, cached);
+            return cached.supportsLogProbs;
+        }
+        // Run capability test
+        const supports = await this.testLogProbCapability();
+        this.setCachedCapability(supports);
+        return supports;
+    }
+    /**
+     * Get log-probability with automatic fallback to latency method
+     * Returns both the calculated value and the method used
+     */
+    async getLogProbWithFallback(prompt) {
+        try {
+            // First, check if model supports log-probabilities
+            const supportsLogProbs = await this.detectLogProbSupport();
+            if (supportsLogProbs) {
+                // Try to get exact log-probabilities
+                try {
+                    const response = await fetch(`${this.baseUrl}/api/generate`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({
+                            model: this.model,
+                            prompt,
+                            stream: false,
+                            logprobs: true,
+                            options: {
+                                num_predict: 0, // Only evaluate prompt, don't generate
+                                temperature: 0,
+                            },
+                        }),
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        if (data.logprobs && Array.isArray(data.logprobs) && data.logprobs.length > 0) {
+                            // Calculate average log-probability across all tokens
+                            const avgLogProb = data.logprobs.reduce((sum, item) => sum + item.logprob, 0) / data.logprobs.length;
+                            console.log(`✅ Using exact log-probabilities for ${this.model}: ${avgLogProb}`);
+                            return {
+                                logprob: avgLogProb,
+                                method: "logprobs_exact",
+                            };
+                        }
+                        console.warn(`❌ No logprobs in response for ${this.model}, response:`, data);
+                    }
+                    else {
+                        console.warn(`❌ Log-probability request failed for ${this.model}: ${response.status} ${response.statusText}`);
+                    }
+                }
+                catch (error) {
+                    console.warn(`❌ Log-probability request failed for ${this.model}, falling back to latency method:`, error);
+                }
+            }
+            // Fallback to latency-based method
+            console.log(`⚡ Falling back to latency-based method for ${this.model}`);
+            const startTime = performance.now();
+            const response = await fetch(`${this.baseUrl}/api/generate`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    model: this.model,
+                    prompt,
+                    stream: false,
+                    options: {
+                        num_predict: 0, // Only evaluate prompt
+                        temperature: 0,
+                    },
+                }),
+            });
+            const endTime = performance.now();
+            if (!response.ok) {
+                throw new Error(`Ollama request failed: ${response.statusText}`);
+            }
+            const data = await response.json();
+            // Calculate latency-based pseudo log-probability
+            let latency;
+            if (data.prompt_eval_duration && data.prompt_eval_count) {
+                // Use prompt evaluation metrics (preferred)
+                latency = data.prompt_eval_duration / data.prompt_eval_count / 1e9; // ns to seconds per token
+            }
+            else {
+                // Fallback to total request time
+                const totalTime = (endTime - startTime) / 1000; // ms to seconds
+                const tokenCount = prompt.split(/\s+/).length; // rough token estimate
+                latency = totalTime / Math.max(tokenCount, 1);
+            }
+            // Convert latency to pseudo log-probability (faster = higher probability)
+            const pseudoLogProb = -Math.log(latency + 0.00001);
+            return {
+                logprob: pseudoLogProb,
+                method: "logprobs_fallback_latency",
+            };
+        }
+        catch (error) {
+            console.error(`Error in getLogProbWithFallback for model ${this.model}:`, error);
+            throw error;
+        }
+    }
+}

package/dist/legal-checks/annex-iv-report.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Annex IV – Technical Documentation Report Builder (structured JSON)
+ *
+ * Provides a strict section structure (1–7) matching the requested outline:
+ *  1. Allgemeine Beschreibung
+ *  2. Design-Spezifikationen
+ *  3. Datenmanagement
+ *  4. Risikomanagement & Mitigation
+ *  5. Performance & Fairness-Metriken
+ *  6. Human Oversight
+ *  7. Technische Dokumentation
+ *
+ * IMPORTANT: This is a documentation scaffold to support a user's own conformity assessment.
+ * It is not legal advice and not a legal determination of compliance.
+ */
+import type { BiasCalculationMethod, BiasTestResult, RiskLevel } from "../types";
+import type { Citation } from "./bias-metrics";
+import type { DataGovernanceChecklistResult } from "./data-governance";
+import type { HumanOversightRecommendation } from "./human-oversight-logging";
+import type { AnnexIIIRiskResult } from "./risk-classifier";
+export interface AnnexIVStructuredReportV1 {
+    meta: {
+        reportVersion: "annex-iv.v1";
+        generatedAt: string;
+        tool: {
+            name: string;
+            version?: string;
+        };
+        disclaimer: string;
+        legalSources: Citation[];
+        reproducibility: {
+            seed?: number;
+            notes: string[];
+        };
+    };
+    section1_generalDescription: {
+        provider: {
+            name: string;
+            address?: string;
+            contact?: string;
+        };
+        system: {
+            name: string;
+            intendedPurpose: string;
+            deploymentContext?: string;
+            userGroups?: string[];
+            riskLevel: RiskLevel;
+            annexIII: AnnexIIIRiskResult;
+        };
+    };
+    section2_designSpecifications: {
+        architecture?: string;
+        modelType?: string;
+        interfaces?: {
+            inputs?: string;
+            outputs?: string;
+        };
+        assumptionsAndLimitations?: string[];
+    };
+    section3_dataManagement: {
+        datasets?: Array<{
+            name: string;
+            description?: string;
+            timeframe?: string;
+            license?: string;
+            preprocessing?: string;
+            version?: string;
+            knownLimitations?: string[];
+        }>;
+        dataGovernanceChecklist?: DataGovernanceChecklistResult;
+    };
+    section4_riskManagementAndMitigation: {
+        processDescription?: string;
+        identifiedRisks?: string[];
+        mitigations?: string[];
+        monitoringPlan?: string[];
+    };
+    section5_performanceAndFairness: {
+        performanceMetrics?: Array<{
+            name: string;
+            value: number | string;
+            notes?: string;
+        }>;
+        biasAndFairness?: Array<BiasTestResult | unknown>;
+        biasMethodology?: {
+            method: BiasCalculationMethod;
+            engine: "browser" | "ollama";
+            dataset: string;
+            citation: string;
+            description: string;
+        };
+        thresholdsAndInterpretationNotes: string[];
+    };
+    section6_humanOversight: {
+        humanOversight?: HumanOversightRecommendation;
+        loggingNotes?: string[];
+    };
+    section7_technicalDocumentation: {
+        artifacts?: Array<{
+            name: string;
+            description?: string;
+            location?: string;
+        }>;
+        changeLog?: Array<{
+            date: string;
+            change: string;
+        }>;
+        references: Citation[];
+    };
+}
+export declare function buildAnnexIVReportV1(input: {
+    provider: AnnexIVStructuredReportV1["section1_generalDescription"]["provider"];
+    system: Omit<AnnexIVStructuredReportV1["section1_generalDescription"]["system"], "riskLevel"> & {
+        riskLevel: RiskLevel;
+    };
+    legalSources: Citation[];
+    reproducibility?: AnnexIVStructuredReportV1["meta"]["reproducibility"];
+    design?: AnnexIVStructuredReportV1["section2_designSpecifications"];
+    dataManagement?: AnnexIVStructuredReportV1["section3_dataManagement"];
+    riskManagement?: AnnexIVStructuredReportV1["section4_riskManagementAndMitigation"];
+    performanceAndFairness?: AnnexIVStructuredReportV1["section5_performanceAndFairness"];
+    humanOversight?: AnnexIVStructuredReportV1["section6_humanOversight"];
+    technicalDocumentation?: Partial<AnnexIVStructuredReportV1["section7_technicalDocumentation"]>;
+    biasMethodology?: AnnexIVStructuredReportV1["section5_performanceAndFairness"]["biasMethodology"];
+    tool?: {
+        name: string;
+        version?: string;
+    };
+    disclaimer?: string;
+}): AnnexIVStructuredReportV1;
+//# sourceMappingURL=annex-iv-report.d.ts.map

package/dist/legal-checks/annex-iv-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annex-iv-report.d.ts","sourceRoot":"","sources":["../../src/legal-checks/annex-iv-report.ts"],"names":[],"mappings":"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"}

package/dist/legal-checks/annex-iv-report.js

@@ -0,0 +1,62 @@
+/**
+ * Annex IV – Technical Documentation Report Builder (structured JSON)
+ *
+ * Provides a strict section structure (1–7) matching the requested outline:
+ *  1. Allgemeine Beschreibung
+ *  2. Design-Spezifikationen
+ *  3. Datenmanagement
+ *  4. Risikomanagement & Mitigation
+ *  5. Performance & Fairness-Metriken
+ *  6. Human Oversight
+ *  7. Technische Dokumentation
+ *
+ * IMPORTANT: This is a documentation scaffold to support a user's own conformity assessment.
+ * It is not legal advice and not a legal determination of compliance.
+ */
+export function buildAnnexIVReportV1(input) {
+    const generatedAt = new Date().toISOString();
+    return {
+        meta: {
+            reportVersion: "annex-iv.v1",
+            generatedAt,
+            tool: input.tool ?? { name: "AImpact" },
+            disclaimer: input.disclaimer ??
+                "This tool provides technical assistance and guidance. The results do not replace a legally binding conformity assessment by a notified body or legal advice.",
+            legalSources: input.legalSources,
+            reproducibility: input.reproducibility ?? {
+                notes: ["Alle stichprobenbasierten Tests sollten Seed/Versionen dokumentieren."],
+            },
+        },
+        section1_generalDescription: {
+            provider: input.provider,
+            system: {
+                ...input.system,
+                riskLevel: input.system.riskLevel,
+            },
+        },
+        section2_designSpecifications: input.design ?? {
+            assumptionsAndLimitations: [
+                "Dieses Report-Gerüst ersetzt keine vollständige technische Dokumentation; ergänzen Sie modell- und domänenspezifische Details.",
+            ],
+        },
+        section3_dataManagement: input.dataManagement ?? {},
+        section4_riskManagementAndMitigation: input.riskManagement ?? {},
+        section5_performanceAndFairness: {
+            ...(input.performanceAndFairness ?? {
+                thresholdsAndInterpretationNotes: [
+                    "Thresholds in diesem Tool sind als technische Screening-Indikatoren markiert; sie sind keine Rechts- oder Compliance-Schwellenwerte.",
+                    "Disparate Impact < 0.8 gilt als Indiz für potenzielle Diskriminierung (weitere Prüfung empfohlen).",
+                ],
+            }),
+            biasMethodology: input.biasMethodology,
+        },
+        section6_humanOversight: input.humanOversight ?? {},
+        section7_technicalDocumentation: {
+            artifacts: input.technicalDocumentation?.artifacts ?? [],
+            changeLog: input.technicalDocumentation?.changeLog ?? [
+                { date: generatedAt.slice(0, 10), change: "Report generated" },
+            ],
+            references: input.technicalDocumentation?.references ?? input.legalSources,
+        },
+    };
+}