@ulpi/codemap 0.1.0

package/dist/chunk-7SDODQZD.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+import {
+  resolveApiKey,
+  resolveUlpiUrl
+} from "./chunk-SNG7R3UC.js";
+
+// ../../packages/intelligence/embed-engine/dist/chunk-PDPVAD7W.js
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS = 1e3;
+var BATCH_POLL_INTERVAL_MS = 2e3;
+var UlpiEmbedder = class {
+  provider = "ulpi";
+  model;
+  dimensions;
+  supportsBatch = true;
+  baseUrl;
+  apiKey;
+  constructor(model = "code", dimensions = 1024, baseUrl) {
+    this.model = model;
+    this.dimensions = dimensions;
+    this.baseUrl = baseUrl ?? resolveUlpiUrl();
+    this.apiKey = resolveApiKey("ulpi");
+  }
+  get headers() {
+    const h = { "Content-Type": "application/json" };
+    if (this.apiKey) h["Authorization"] = `Bearer ${this.apiKey}`;
+    return h;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    const body = {
+      model: this.model,
+      input: texts,
+      encoding_format: "float"
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(`${this.baseUrl}/api/v1/embeddings`, {
+          method: "POST",
+          headers: this.headers,
+          body: JSON.stringify(body),
+          redirect: "error"
+        });
+        if (!response.ok) {
+          lastError = await this.handleErrorResponse(response);
+          if (response.status === 429 || response.status >= 500) {
+            await sleep(RETRY_BASE_MS * Math.pow(2, attempt));
+            continue;
+          }
+          throw lastError;
+        }
+        const data = await this.safeJson(response);
+        if (!Array.isArray(data.data)) {
+          throw new Error(
+            `ULPI embedding API error (${response.status}): ${JSON.stringify(data)}`
+          );
+        }
+        const sorted = data.data.sort((a, b) => a.index - b.index);
+        return sorted.map((item) => item.embedding);
+      } catch (err) {
+        lastError = this.classifyError(err, attempt);
+        if (lastError !== err && attempt < MAX_RETRIES - 1) {
+          await sleep(RETRY_BASE_MS * Math.pow(2, attempt));
+          continue;
+        }
+        throw lastError;
+      }
+    }
+    throw lastError ?? new Error("ULPI embedding failed after retries");
+  }
+  /**
+   * Submit all texts as an async batch (up to 10,000).
+   * Returns immediately with a batch ID for polling.
+   */
+  async submitBatch(texts, webhookUrl) {
+    if (texts.length === 0) throw new Error("Cannot submit empty batch");
+    const body = {
+      model: this.model,
+      input: texts
+    };
+    if (webhookUrl) {
+      body.webhook_url = webhookUrl;
+    }
+    const payload = JSON.stringify(body);
+    const totalChars = texts.reduce((sum, t) => sum + t.length, 0);
+    const avgChars = Math.round(totalChars / texts.length);
+    const maxChars = Math.max(...texts.map((t) => t.length));
+    console.error(
+      `[ulpi-embedder] submitBatch: ${texts.length} texts, payload=${(payload.length / 1024).toFixed(0)}KB, chars: total=${totalChars} avg=${avgChars} max=${maxChars}, model=${this.model}, url=${this.baseUrl}/api/v1/embeddings/batch`
+    );
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 6e4);
+    try {
+      const response = await fetch(`${this.baseUrl}/api/v1/embeddings/batch`, {
+        method: "POST",
+        headers: this.headers,
+        body: payload,
+        redirect: "error",
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw await this.handleErrorResponse(response);
+      }
+      const result = await this.safeJson(response);
+      if (!result.data?.id) {
+        throw new Error(
+          `ULPI batch API error (${response.status}): ${JSON.stringify(result)}`
+        );
+      }
+      console.error(`[ulpi-embedder] submitBatch: got batchId=${result.data.id}`);
+      return result.data.id;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Poll the status of an async batch.
+   * Returns all available results on every poll (cumulative, sorted by index).
+   * This enables progressive storage — callers can store partial results
+   * as they arrive rather than waiting for full batch completion.
+   */
+  async pollBatch(batchId) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const response = await fetch(
+        `${this.baseUrl}/api/v1/embeddings/batch/${encodeURIComponent(batchId)}`,
+        { headers: this.headers, redirect: "error", signal: controller.signal }
+      );
+      if (!response.ok) {
+        throw await this.handleErrorResponse(response);
+      }
+      const json = await this.safeJson(response);
+      const batch = json.data;
+      let results;
+      if (json.results?.data && json.results.data.length > 0) {
+        const sorted = json.results.data.sort((a, b) => a.index - b.index);
+        results = sorted.map((item) => item.embedding);
+      }
+      const allProcessed = batch.processed_inputs >= batch.total_inputs;
+      return {
+        id: batch.id,
+        status: allProcessed && batch.status !== "failed" ? "completed" : batch.status,
+        totalInputs: batch.total_inputs,
+        processedInputs: batch.processed_inputs,
+        results
+      };
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  /**
+   * Parse JSON from response, guarding against HTML error pages.
+   */
+  async safeJson(response) {
+    const ct = response.headers.get("content-type") ?? "";
+    if (ct.includes("text/html")) {
+      const snippet = (await response.text()).slice(0, 200);
+      throw new Error(
+        `ULPI embedding API returned HTML instead of JSON (${response.status}). The endpoint may be misconfigured. Response: ${snippet}`
+      );
+    }
+    return await response.json();
+  }
+  async handleErrorResponse(response) {
+    const errorText = await response.text();
+    if (response.status === 401 || response.status === 403) {
+      return new Error(
+        `Authentication failed (${response.status}). Check your ULPI API key with: ulpi config get ulpi-key`
+      );
+    }
+    if (response.status === 402) {
+      return new Error(
+        "Insufficient credits. Visit https://ulpi.io/billing to add credits to your account."
+      );
+    }
+    return new Error(`ULPI embedding API error (${response.status}): ${errorText.slice(0, 200)}`);
+  }
+  classifyError(err, _attempt) {
+    if (!(err instanceof Error)) return new Error(String(err));
+    if (err.message.startsWith("Authentication failed") || err.message.startsWith("Insufficient credits")) {
+      throw err;
+    }
+    if (err.message.includes("fetch") || err.message.includes("ECONNREFUSED")) {
+      throw new Error(
+        `Cannot connect to ULPI embedding service at ${this.baseUrl}. Check your network connection or configure the URL with: ulpi config set ulpi-url <url>`
+      );
+    }
+    return err;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  BATCH_POLL_INTERVAL_MS,
+  UlpiEmbedder
+};

package/dist/chunk-SNG7R3UC.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+// ../../packages/intelligence/embed-engine/dist/chunk-GWXOGQ7U.js
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var _cached;
+function loadSettings() {
+  if (_cached) return _cached;
+  try {
+    const raw = readFileSync(join(homedir(), ".ulpi", "settings.json"), "utf8");
+    _cached = JSON.parse(raw);
+    return _cached;
+  } catch {
+    _cached = {};
+    return _cached;
+  }
+}
+function resolveApiKey(provider) {
+  const settings = loadSettings();
+  const fromSettings = settings.apiKeys?.[provider];
+  if (fromSettings) return fromSettings;
+  const envMap = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    ulpi: "ULPI_API_KEY"
+  };
+  return process.env[envMap[provider]];
+}
+function resolveUlpiUrl() {
+  const settings = loadSettings();
+  return settings.ulpiUrl ?? process.env.ULPI_EMBED_URL ?? "http://localhost:10271";
+}
+
+export {
+  resolveApiKey,
+  resolveUlpiUrl
+};

package/dist/chunk-WUVKW5JG.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+// ../../packages/intelligence/embed-engine/dist/chunk-RU4VHMIP.js
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var MAX_RETRIES = 3;
+var RETRY_BASE_MS = 500;
+var OllamaEmbedder = class {
+  provider = "ollama";
+  model;
+  dimensions;
+  baseUrl;
+  constructor(model = "nomic-embed-text", dimensions = 768) {
+    this.model = model;
+    this.dimensions = dimensions;
+    this.baseUrl = process.env.OLLAMA_HOST ?? DEFAULT_OLLAMA_URL;
+  }
+  async embed(texts) {
+    if (texts.length === 0) return [];
+    const results = [];
+    for (const text of texts) {
+      const embedding = await this.embedSingle(text);
+      results.push(embedding);
+    }
+    return results;
+  }
+  async embedSingle(text) {
+    let lastError = null;
+    for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+      try {
+        const response = await fetch(`${this.baseUrl}/api/embed`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ model: this.model, input: text })
+        });
+        if (!response.ok) {
+          const errorText = await response.text();
+          lastError = new Error(`Ollama API error (${response.status}): ${errorText.slice(0, 200)}`);
+          if (response.status >= 500) {
+            const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+            await sleep(delay);
+            continue;
+          }
+          throw lastError;
+        }
+        const data = await response.json();
+        if (!data.embeddings || data.embeddings.length === 0) {
+          throw new Error("Ollama returned empty embeddings");
+        }
+        return data.embeddings[0];
+      } catch (err) {
+        if (err instanceof Error && err.message.includes("fetch")) {
+          throw new Error(
+            `Cannot connect to Ollama at ${this.baseUrl}. Is Ollama running? Start it with: ollama serve`
+          );
+        }
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < MAX_RETRIES - 1) {
+          const delay = RETRY_BASE_MS * Math.pow(2, attempt);
+          await sleep(delay);
+        }
+      }
+    }
+    throw lastError ?? new Error("Ollama embedding failed after retries");
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export {
+  OllamaEmbedder
+};