@euconform/cli 1.0.0 → 1.1.1

package/dist/chunk-JQTB43B2.js

@@ -0,0 +1,373 @@
+// ../core/src/inference/ollama-client.ts
+var OLLAMA_BASE_URL = "http://localhost:11434";
+async function detectOllama() {
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2e3);
+    const response = await fetch(`${OLLAMA_BASE_URL}/api/tags`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+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 [];
+  }
+}
+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();
+}
+async function getLogProb(model, prompt) {
+  try {
+    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();
+    if (data.prompt_eval_duration && data.prompt_eval_count) {
+      const timePerToken = data.prompt_eval_duration / data.prompt_eval_count / 1e9;
+      return -Math.log(timePerToken + 1e-5);
+    }
+    if (data.eval_duration && data.eval_count) {
+      const timePerToken = data.eval_duration / data.eval_count / 1e9;
+      return -Math.log(timePerToken + 1e-3);
+    }
+    return 0;
+  } catch (error) {
+    console.error(`Error calculating log probability for model ${model}:`, error);
+    throw error;
+  }
+}
+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();
+    if (data.prompt_eval_duration && data.prompt_eval_count) {
+      const avgTimePerToken = data.prompt_eval_duration / data.prompt_eval_count / 1e9;
+      return avgTimePerToken * 1e3;
+    }
+    return 1;
+  } catch (error) {
+    console.error("Failed to get perplexity:", error);
+    return 1;
+  }
+}
+var OllamaClient = class {
+  baseUrl;
+  model;
+  capabilityCache;
+  externalCache;
+  constructor(model, baseUrl = OLLAMA_BASE_URL, cache) {
+    this.baseUrl = baseUrl;
+    this.model = model;
+    this.capabilityCache = /* @__PURE__ */ new Map();
+    this.externalCache = cache ?? null;
+  }
+  isCloudModel() {
+    return this.model.includes(":cloud");
+  }
+  /**
+   * Ensures the model is available in Ollama before proceeding
+   * Throws an error if the model is not found
+   */
+  async ensureModelLoaded() {
+    const models = await listOllamaModels();
+    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) {
+    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() {
+    if (this.isCloudModel()) {
+      console.log(
+        `\u{1F50D} ${this.model} is a cloud model - logprobs not supported, using latency method`
+      );
+      return false;
+    }
+    try {
+      try {
+        const versionResponse = await fetch(`${this.baseUrl}/api/version`);
+        if (versionResponse.ok) {
+          const versionData = await versionResponse.json();
+          console.log(`\u{1F50D} Ollama version: ${versionData.version || "unknown"}`);
+        }
+      } catch {
+      }
+      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(
+          `\u{1F50D} Capability test request failed for ${this.model}: ${response.status} ${response.statusText}`
+        );
+        return false;
+      }
+      const data = await response.json();
+      const hasLogProbs = !!(data.logprobs && Array.isArray(data.logprobs) && data.logprobs.length > 0);
+      console.log(
+        `\u{1F50D} Capability test for ${this.model}: ${hasLogProbs ? "\u2705 supports" : "\u274C no support"} log-probabilities`,
+        data.logprobs ? `(${data.logprobs.length} tokens)` : "(no logprobs field)"
+      );
+      if (!hasLogProbs) {
+        console.log("\u{1F50D} 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 or external cache
+   */
+  getCachedCapability() {
+    try {
+      const cacheKey = `ollama_supports_logprobs_${this.model}`;
+      let cached = null;
+      if (this.externalCache) {
+        cached = this.externalCache.get(cacheKey);
+      } else if (typeof localStorage !== "undefined") {
+        cached = localStorage.getItem(cacheKey);
+      }
+      if (cached) {
+        const capability = JSON.parse(cached);
+        const cacheAge = Date.now() - new Date(capability.testedAt).getTime();
+        const CACHE_TTL = 24 * 60 * 60 * 1e3;
+        if (cacheAge < CACHE_TTL) {
+          return capability;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Cache capability result in localStorage or external cache
+   */
+  setCachedCapability(supports) {
+    try {
+      const cacheKey = `ollama_supports_logprobs_${this.model}`;
+      const capability = {
+        model: this.model,
+        supportsLogProbs: supports,
+        testedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (this.externalCache) {
+        this.externalCache.set(cacheKey, JSON.stringify(capability));
+      } else if (typeof localStorage !== "undefined") {
+        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() {
+    const memoryCache = this.capabilityCache.get(this.model);
+    if (memoryCache) {
+      return memoryCache.supportsLogProbs;
+    }
+    const cached = this.getCachedCapability();
+    if (cached) {
+      this.capabilityCache.set(this.model, cached);
+      return cached.supportsLogProbs;
+    }
+    const supports = await this.testLogProbCapability();
+    this.setCachedCapability(supports);
+    return supports;
+  }
+  async tryExactLogProbs(prompt) {
+    const supportsLogProbs = await this.detectLogProbSupport();
+    if (!supportsLogProbs || this.isCloudModel()) return null;
+    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, temperature: 0 }
+        })
+      });
+      if (!response.ok) {
+        console.warn(
+          `\u274C Log-probability request failed for ${this.model}: ${response.status} ${response.statusText}`
+        );
+        return null;
+      }
+      const data = await response.json();
+      if (!data.logprobs || !Array.isArray(data.logprobs) || data.logprobs.length === 0) {
+        console.warn(`\u274C No logprobs in response for ${this.model}, response:`, data);
+        return null;
+      }
+      const avgLogProb = data.logprobs.reduce(
+        (sum, item) => sum + item.logprob,
+        0
+      ) / data.logprobs.length;
+      console.log(`\u2705 Using exact log-probabilities for ${this.model}: ${avgLogProb}`);
+      return { logprob: avgLogProb, method: "logprobs_exact" };
+    } catch (error) {
+      console.warn(
+        `\u274C Log-probability request failed for ${this.model}, falling back to latency method:`,
+        error
+      );
+      return null;
+    }
+  }
+  async latencyFallback(prompt) {
+    const isCloud = this.isCloudModel();
+    console.log(
+      `\u26A1 Falling back to latency-based method for ${this.model}${isCloud ? " (cloud 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: isCloud ? 1 : 0, temperature: 0 }
+      })
+    });
+    const endTime = performance.now();
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Ollama request failed: ${response.statusText}. ${errorText}`);
+    }
+    const data = await response.json();
+    let latency;
+    if (data.prompt_eval_duration && data.prompt_eval_count) {
+      latency = data.prompt_eval_duration / data.prompt_eval_count / 1e9;
+    } else {
+      const totalTime = (endTime - startTime) / 1e3;
+      const tokenCount = prompt.split(/\s+/).length;
+      latency = totalTime / Math.max(tokenCount, 1);
+    }
+    return { logprob: -Math.log(latency + 1e-5), method: "logprobs_fallback_latency" };
+  }
+  /**
+   * Get log-probability with automatic fallback to latency method
+   * Returns both the calculated value and the method used
+   */
+  async getLogProbWithFallback(prompt) {
+    try {
+      const exact = await this.tryExactLogProbs(prompt);
+      if (exact) return exact;
+      return await this.latencyFallback(prompt);
+    } catch (error) {
+      console.error(`Error in getLogProbWithFallback for model ${this.model}:`, error);
+      throw error;
+    }
+  }
+};
+
+export {
+  detectOllama,
+  listOllamaModels,
+  ollamaGenerate,
+  getLogProb,
+  getPerplexity,
+  OllamaClient
+};

package/dist/chunk-JSBRDJBE.js

@@ -0,0 +1,30 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};