@usewhisper/mcp-server 0.2.3 → 0.3.0

package/dist/chunk-7SN3CKDK.js

@@ -0,0 +1,1076 @@
+import {
+  embed,
+  embedSingle,
+  prisma
+} from "./chunk-MEFLJ4PV.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-QGM4M3NI.js";
+
+// ../node_modules/eventemitter3/index.js
+var require_eventemitter3 = __commonJS({
+  "../node_modules/eventemitter3/index.js"(exports, module) {
+    "use strict";
+    var has = Object.prototype.hasOwnProperty;
+    var prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    if ("undefined" !== typeof module) {
+      module.exports = EventEmitter2;
+    }
+  }
+});
+
+// ../src/engine/chunker.ts
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".py",
+  ".java",
+  ".go",
+  ".rb",
+  ".php",
+  ".cs",
+  ".rs",
+  ".swift",
+  ".kt",
+  ".scala",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".sol",
+  ".vy"
+]);
+var CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".ini",
+  ".env",
+  ".xml"
+]);
+function detectChunkType(filePath, content) {
+  if (!filePath) return "text";
+  const ext = "." + filePath.split(".").pop()?.toLowerCase();
+  if (CODE_EXTENSIONS.has(ext)) return "code";
+  if (CONFIG_EXTENSIONS.has(ext)) return "config";
+  if (filePath.includes("schema") || filePath.includes("migration")) return "schema";
+  if (filePath.endsWith(".md") || filePath.endsWith(".mdx") || filePath.endsWith(".rst")) return "documentation";
+  if (filePath.includes("openapi") || filePath.includes("swagger")) return "api_spec";
+  return "text";
+}
+function chunkText(content, opts = {}) {
+  const { chunkSize = 1e3, chunkOverlap = 200, filePath, metadata = {} } = opts;
+  const chunkType = detectChunkType(filePath, content);
+  if (chunkType === "code") {
+    return chunkCode(content, { chunkSize, filePath, metadata });
+  }
+  return chunkBySize(content, { chunkSize, chunkOverlap, chunkType, metadata });
+}
+function chunkCode(content, opts) {
+  const { chunkSize, filePath, metadata = {} } = opts;
+  const lines = content.split("\n");
+  const chunks = [];
+  const boundaries = [
+    /^(export\s+)?(async\s+)?function\s+/,
+    /^(export\s+)?(default\s+)?class\s+/,
+    /^(export\s+)?const\s+\w+\s*=\s*(async\s+)?\(/,
+    /^(export\s+)?const\s+\w+\s*=\s*\{/,
+    /^(export\s+)?interface\s+/,
+    /^(export\s+)?type\s+/,
+    /^(export\s+)?enum\s+/,
+    /^def\s+/,
+    // Python
+    /^class\s+/,
+    // Python/Java
+    /^func\s+/,
+    // Go
+    /^pub\s+(fn|struct|enum|impl)/
+    // Rust
+  ];
+  let currentChunk = [];
+  let currentStart = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trimStart();
+    const isBoundary = boundaries.some((b) => b.test(trimmed));
+    if (isBoundary && currentChunk.length > 0) {
+      const chunkContent = currentChunk.join("\n").trim();
+      if (chunkContent.length > 0) {
+        chunks.push({
+          content: chunkContent,
+          chunkType: "code",
+          chunkIndex: chunks.length,
+          metadata: {
+            ...metadata,
+            filePath,
+            startLine: currentStart + 1,
+            endLine: i
+          }
+        });
+      }
+      currentChunk = [lines[i]];
+      currentStart = i;
+    } else {
+      currentChunk.push(lines[i]);
+    }
+    if (currentChunk.join("\n").length > chunkSize * 1.5) {
+      const chunkContent = currentChunk.join("\n").trim();
+      if (chunkContent.length > 0) {
+        chunks.push({
+          content: chunkContent,
+          chunkType: "code",
+          chunkIndex: chunks.length,
+          metadata: {
+            ...metadata,
+            filePath,
+            startLine: currentStart + 1,
+            endLine: i + 1
+          }
+        });
+      }
+      currentChunk = [];
+      currentStart = i + 1;
+    }
+  }
+  if (currentChunk.length > 0) {
+    const chunkContent = currentChunk.join("\n").trim();
+    if (chunkContent.length > 0) {
+      chunks.push({
+        content: chunkContent,
+        chunkType: "code",
+        chunkIndex: chunks.length,
+        metadata: {
+          ...metadata,
+          filePath,
+          startLine: currentStart + 1,
+          endLine: lines.length
+        }
+      });
+    }
+  }
+  return chunks;
+}
+function chunkBySize(content, opts) {
+  const { chunkSize, chunkOverlap, chunkType, metadata = {} } = opts;
+  const chunks = [];
+  const paragraphs = content.split(/\n\n+/);
+  let current = "";
+  for (const para of paragraphs) {
+    if ((current + "\n\n" + para).length > chunkSize && current.length > 0) {
+      chunks.push({
+        content: current.trim(),
+        chunkType,
+        chunkIndex: chunks.length,
+        metadata
+      });
+      const words = current.split(/\s+/);
+      const overlapWords = words.slice(-Math.floor(chunkOverlap / 5));
+      current = overlapWords.join(" ") + "\n\n" + para;
+    } else {
+      current = current ? current + "\n\n" + para : para;
+    }
+  }
+  if (current.trim().length > 0) {
+    chunks.push({
+      content: current.trim(),
+      chunkType,
+      chunkIndex: chunks.length,
+      metadata
+    });
+  }
+  return chunks;
+}
+
+// ../src/engine/extractor.ts
+import OpenAI from "openai";
+var openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+async function extractEntities(projectId, content, chunkType, metadata = {}, chunkId) {
+  if (content.length < 100) return { entities: 0, relations: 0 };
+  const isCode = ["code", "function", "class"].includes(chunkType);
+  const prompt = isCode ? `Analyze this code and extract entities and relationships.
+
+Entities: functions, classes, interfaces, types, modules, variables, constants, API endpoints, services.
+Relations: imports, exports, calls, implements, extends, depends_on, references, part_of.
+
+Code:
+\`\`\`
+${content.slice(0, 3e3)}
+\`\`\`
+
+Respond with JSON only:
+{
+  "entities": [{"name": "...", "type": "function|class|interface|module|constant|api_endpoint|service", "description": "one line"}],
+  "relations": [{"from": "name", "fromType": "type", "to": "name", "toType": "type", "relation": "imports|calls|extends|implements|depends_on|references|part_of"}]
+}` : `Analyze this text and extract key entities (concepts, people, tools, services, APIs, technologies) and their relationships.
+
+Text:
+${content.slice(0, 3e3)}
+
+Respond with JSON only:
+{
+  "entities": [{"name": "...", "type": "concept|tool|service|api|technology|person|organization", "description": "one line"}],
+  "relations": [{"from": "name", "fromType": "type", "to": "name", "toType": "type", "relation": "references|depends_on|related_to|part_of|supersedes"}]
+}`;
+  try {
+    const res = await openai.chat.completions.create({
+      model: "gpt-4o-mini",
+      messages: [{ role: "user", content: prompt }],
+      temperature: 0,
+      max_tokens: 1e3,
+      response_format: { type: "json_object" }
+    });
+    const text = res.choices[0]?.message?.content?.trim() || "{}";
+    const parsed = JSON.parse(text);
+    const extractedEntities = parsed.entities || [];
+    const extractedRelations = parsed.relations || [];
+    let entityCount = 0;
+    let relationCount = 0;
+    const entityMap = /* @__PURE__ */ new Map();
+    for (const ent of extractedEntities.slice(0, 20)) {
+      if (!ent.name || !ent.type) continue;
+      const embedding = await embedSingle(`${ent.type}: ${ent.name} - ${ent.description || ""}`);
+      const embeddingStr = `[${embedding.join(",")}]`;
+      try {
+        await prisma.$queryRaw`
+          INSERT INTO "entities" (
+            id, "projectId", name, "entityType", description, "sourceChunkId", embedding,
+            "createdAt", "updatedAt"
+          )
+          VALUES (
+            gen_random_uuid(), ${projectId}, ${ent.name}, ${ent.type}, ${ent.description || ""},
+            ${chunkId || null}, ${embeddingStr}::vector, NOW(), NOW()
+          )
+          ON CONFLICT ("projectId", name, "entityType")
+          DO UPDATE SET
+            description = EXCLUDED.description,
+            "sourceChunkId" = EXCLUDED."sourceChunkId",
+            embedding = EXCLUDED.embedding,
+            "updatedAt" = NOW()
+        `;
+        entityMap.set(`${ent.name}:${ent.type}`, ent.name);
+        entityCount++;
+      } catch (err) {
+        console.error("[Extractor] Error upserting entity:", err.message);
+      }
+    }
+    for (const rel of extractedRelations.slice(0, 30)) {
+      if (!rel.from || !rel.to || !rel.relation) continue;
+      const fromId = entityMap.get(`${rel.from}:${rel.fromType}`);
+      const toId = entityMap.get(`${rel.to}:${rel.toType}`);
+      if (!fromId || !toId) continue;
+      const validRelations = [
+        "imports",
+        "exports",
+        "calls",
+        "implements",
+        "extends",
+        "references",
+        "depends_on",
+        "related_to",
+        "part_of",
+        "contradicts",
+        "supersedes"
+      ];
+      if (!validRelations.includes(rel.relation)) continue;
+      await prisma.entityRelation.upsert({
+        where: {
+          fromEntityId_toEntityId_relationType: {
+            fromEntityId: fromId,
+            toEntityId: toId,
+            relationType: rel.relation
+          }
+        },
+        update: {
+          metadata: { autoExtracted: true }
+        },
+        create: {
+          projectId,
+          fromEntityId: fromId,
+          toEntityId: toId,
+          relationType: rel.relation,
+          metadata: { autoExtracted: true }
+        }
+      });
+      relationCount++;
+    }
+    return { entities: entityCount, relations: relationCount };
+  } catch {
+    return { entities: 0, relations: 0 };
+  }
+}
+
+// ../src/engine/ingest.ts
+import { createHash } from "crypto";
+
+// ../node_modules/eventemitter3/index.mjs
+var import_index = __toESM(require_eventemitter3(), 1);
+
+// ../node_modules/p-timeout/index.js
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var AbortError = class extends Error {
+  constructor(message) {
+    super();
+    this.name = "AbortError";
+    this.message = message;
+  }
+};
+var getDOMException = (errorMessage) => globalThis.DOMException === void 0 ? new AbortError(errorMessage) : new DOMException(errorMessage);
+var getAbortedReason = (signal) => {
+  const reason = signal.reason === void 0 ? getDOMException("This operation was aborted.") : signal.reason;
+  return reason instanceof Error ? reason : getDOMException(reason);
+};
+function pTimeout(promise, options) {
+  const {
+    milliseconds,
+    fallback,
+    message,
+    customTimers = { setTimeout, clearTimeout }
+  } = options;
+  let timer;
+  let abortHandler;
+  const wrappedPromise = new Promise((resolve, reject) => {
+    if (typeof milliseconds !== "number" || Math.sign(milliseconds) !== 1) {
+      throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
+    }
+    if (options.signal) {
+      const { signal } = options;
+      if (signal.aborted) {
+        reject(getAbortedReason(signal));
+      }
+      abortHandler = () => {
+        reject(getAbortedReason(signal));
+      };
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    if (milliseconds === Number.POSITIVE_INFINITY) {
+      promise.then(resolve, reject);
+      return;
+    }
+    const timeoutError = new TimeoutError();
+    timer = customTimers.setTimeout.call(void 0, () => {
+      if (fallback) {
+        try {
+          resolve(fallback());
+        } catch (error) {
+          reject(error);
+        }
+        return;
+      }
+      if (typeof promise.cancel === "function") {
+        promise.cancel();
+      }
+      if (message === false) {
+        resolve();
+      } else if (message instanceof Error) {
+        reject(message);
+      } else {
+        timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
+        reject(timeoutError);
+      }
+    }, milliseconds);
+    (async () => {
+      try {
+        resolve(await promise);
+      } catch (error) {
+        reject(error);
+      }
+    })();
+  });
+  const cancelablePromise = wrappedPromise.finally(() => {
+    cancelablePromise.clear();
+    if (abortHandler && options.signal) {
+      options.signal.removeEventListener("abort", abortHandler);
+    }
+  });
+  cancelablePromise.clear = () => {
+    customTimers.clearTimeout.call(void 0, timer);
+    timer = void 0;
+  };
+  return cancelablePromise;
+}
+
+// ../node_modules/p-queue/dist/lower-bound.js
+function lowerBound(array, value, comparator) {
+  let first = 0;
+  let count = array.length;
+  while (count > 0) {
+    const step = Math.trunc(count / 2);
+    let it = first + step;
+    if (comparator(array[it], value) <= 0) {
+      first = ++it;
+      count -= step + 1;
+    } else {
+      count = step;
+    }
+  }
+  return first;
+}
+
+// ../node_modules/p-queue/dist/priority-queue.js
+var PriorityQueue = class {
+  #queue = [];
+  enqueue(run, options) {
+    options = {
+      priority: 0,
+      ...options
+    };
+    const element = {
+      priority: options.priority,
+      id: options.id,
+      run
+    };
+    if (this.size === 0 || this.#queue[this.size - 1].priority >= options.priority) {
+      this.#queue.push(element);
+      return;
+    }
+    const index = lowerBound(this.#queue, element, (a, b) => b.priority - a.priority);
+    this.#queue.splice(index, 0, element);
+  }
+  setPriority(id, priority) {
+    const index = this.#queue.findIndex((element) => element.id === id);
+    if (index === -1) {
+      throw new ReferenceError(`No promise function with the id "${id}" exists in the queue.`);
+    }
+    const [item] = this.#queue.splice(index, 1);
+    this.enqueue(item.run, { priority, id });
+  }
+  dequeue() {
+    const item = this.#queue.shift();
+    return item?.run;
+  }
+  filter(options) {
+    return this.#queue.filter((element) => element.priority === options.priority).map((element) => element.run);
+  }
+  get size() {
+    return this.#queue.length;
+  }
+};
+
+// ../node_modules/p-queue/dist/index.js
+var PQueue = class extends import_index.default {
+  #carryoverConcurrencyCount;
+  #isIntervalIgnored;
+  #intervalCount = 0;
+  #intervalCap;
+  #interval;
+  #intervalEnd = 0;
+  #intervalId;
+  #timeoutId;
+  #queue;
+  #queueClass;
+  #pending = 0;
+  // The `!` is needed because of https://github.com/microsoft/TypeScript/issues/32194
+  #concurrency;
+  #isPaused;
+  #throwOnTimeout;
+  // Use to assign a unique identifier to a promise function, if not explicitly specified
+  #idAssigner = 1n;
+  /**
+      Per-operation timeout in milliseconds. Operations fulfill once `timeout` elapses if they haven't already.
+  
+      Applies to each future operation.
+      */
+  timeout;
+  // TODO: The `throwOnTimeout` option should affect the return types of `add()` and `addAll()`
+  constructor(options) {
+    super();
+    options = {
+      carryoverConcurrencyCount: false,
+      intervalCap: Number.POSITIVE_INFINITY,
+      interval: 0,
+      concurrency: Number.POSITIVE_INFINITY,
+      autoStart: true,
+      queueClass: PriorityQueue,
+      ...options
+    };
+    if (!(typeof options.intervalCap === "number" && options.intervalCap >= 1)) {
+      throw new TypeError(`Expected \`intervalCap\` to be a number from 1 and up, got \`${options.intervalCap?.toString() ?? ""}\` (${typeof options.intervalCap})`);
+    }
+    if (options.interval === void 0 || !(Number.isFinite(options.interval) && options.interval >= 0)) {
+      throw new TypeError(`Expected \`interval\` to be a finite number >= 0, got \`${options.interval?.toString() ?? ""}\` (${typeof options.interval})`);
+    }
+    this.#carryoverConcurrencyCount = options.carryoverConcurrencyCount;
+    this.#isIntervalIgnored = options.intervalCap === Number.POSITIVE_INFINITY || options.interval === 0;
+    this.#intervalCap = options.intervalCap;
+    this.#interval = options.interval;
+    this.#queue = new options.queueClass();
+    this.#queueClass = options.queueClass;
+    this.concurrency = options.concurrency;
+    this.timeout = options.timeout;
+    this.#throwOnTimeout = options.throwOnTimeout === true;
+    this.#isPaused = options.autoStart === false;
+  }
+  get #doesIntervalAllowAnother() {
+    return this.#isIntervalIgnored || this.#intervalCount < this.#intervalCap;
+  }
+  get #doesConcurrentAllowAnother() {
+    return this.#pending < this.#concurrency;
+  }
+  #next() {
+    this.#pending--;
+    this.#tryToStartAnother();
+    this.emit("next");
+  }
+  #onResumeInterval() {
+    this.#onInterval();
+    this.#initializeIntervalIfNeeded();
+    this.#timeoutId = void 0;
+  }
+  get #isIntervalPaused() {
+    const now = Date.now();
+    if (this.#intervalId === void 0) {
+      const delay = this.#intervalEnd - now;
+      if (delay < 0) {
+        this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+      } else {
+        if (this.#timeoutId === void 0) {
+          this.#timeoutId = setTimeout(() => {
+            this.#onResumeInterval();
+          }, delay);
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #tryToStartAnother() {
+    if (this.#queue.size === 0) {
+      if (this.#intervalId) {
+        clearInterval(this.#intervalId);
+      }
+      this.#intervalId = void 0;
+      this.emit("empty");
+      if (this.#pending === 0) {
+        this.emit("idle");
+      }
+      return false;
+    }
+    if (!this.#isPaused) {
+      const canInitializeInterval = !this.#isIntervalPaused;
+      if (this.#doesIntervalAllowAnother && this.#doesConcurrentAllowAnother) {
+        const job = this.#queue.dequeue();
+        if (!job) {
+          return false;
+        }
+        this.emit("active");
+        job();
+        if (canInitializeInterval) {
+          this.#initializeIntervalIfNeeded();
+        }
+        return true;
+      }
+    }
+    return false;
+  }
+  #initializeIntervalIfNeeded() {
+    if (this.#isIntervalIgnored || this.#intervalId !== void 0) {
+      return;
+    }
+    this.#intervalId = setInterval(() => {
+      this.#onInterval();
+    }, this.#interval);
+    this.#intervalEnd = Date.now() + this.#interval;
+  }
+  #onInterval() {
+    if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
+      clearInterval(this.#intervalId);
+      this.#intervalId = void 0;
+    }
+    this.#intervalCount = this.#carryoverConcurrencyCount ? this.#pending : 0;
+    this.#processQueue();
+  }
+  /**
+  Executes all queued functions until it reaches the limit.
+  */
+  #processQueue() {
+    while (this.#tryToStartAnother()) {
+    }
+  }
+  get concurrency() {
+    return this.#concurrency;
+  }
+  set concurrency(newConcurrency) {
+    if (!(typeof newConcurrency === "number" && newConcurrency >= 1)) {
+      throw new TypeError(`Expected \`concurrency\` to be a number from 1 and up, got \`${newConcurrency}\` (${typeof newConcurrency})`);
+    }
+    this.#concurrency = newConcurrency;
+    this.#processQueue();
+  }
+  async #throwOnAbort(signal) {
+    return new Promise((_resolve, reject) => {
+      signal.addEventListener("abort", () => {
+        reject(signal.reason);
+      }, { once: true });
+    });
+  }
+  /**
+      Updates the priority of a promise function by its id, affecting its execution order. Requires a defined concurrency limit to take effect.
+  
+      For example, this can be used to prioritize a promise function to run earlier.
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 0, id: '🦀'});
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦄', {priority: 1});
+  
+      queue.setPriority('🦀', 2);
+      ```
+  
+      In this case, the promise function with `id: '🦀'` runs second.
+  
+      You can also deprioritize a promise function to delay its execution:
+  
+      ```js
+      import PQueue from 'p-queue';
+  
+      const queue = new PQueue({concurrency: 1});
+  
+      queue.add(async () => '🦄', {priority: 1});
+      queue.add(async () => '🦀', {priority: 1, id: '🦀'});
+      queue.add(async () => '🦄');
+      queue.add(async () => '🦄', {priority: 0});
+  
+      queue.setPriority('🦀', -1);
+      ```
+      Here, the promise function with `id: '🦀'` executes last.
+      */
+  setPriority(id, priority) {
+    this.#queue.setPriority(id, priority);
+  }
+  async add(function_, options = {}) {
+    options.id ??= (this.#idAssigner++).toString();
+    options = {
+      timeout: this.timeout,
+      throwOnTimeout: this.#throwOnTimeout,
+      ...options
+    };
+    return new Promise((resolve, reject) => {
+      this.#queue.enqueue(async () => {
+        this.#pending++;
+        try {
+          options.signal?.throwIfAborted();
+          this.#intervalCount++;
+          let operation = function_({ signal: options.signal });
+          if (options.timeout) {
+            operation = pTimeout(Promise.resolve(operation), { milliseconds: options.timeout });
+          }
+          if (options.signal) {
+            operation = Promise.race([operation, this.#throwOnAbort(options.signal)]);
+          }
+          const result = await operation;
+          resolve(result);
+          this.emit("completed", result);
+        } catch (error) {
+          if (error instanceof TimeoutError && !options.throwOnTimeout) {
+            resolve();
+            return;
+          }
+          reject(error);
+          this.emit("error", error);
+        } finally {
+          this.#next();
+        }
+      }, options);
+      this.emit("add");
+      this.#tryToStartAnother();
+    });
+  }
+  async addAll(functions, options) {
+    return Promise.all(functions.map(async (function_) => this.add(function_, options)));
+  }
+  /**
+  Start (or resume) executing enqueued tasks within concurrency limit. No need to call this if queue is not paused (via `options.autoStart = false` or by `.pause()` method.)
+  */
+  start() {
+    if (!this.#isPaused) {
+      return this;
+    }
+    this.#isPaused = false;
+    this.#processQueue();
+    return this;
+  }
+  /**
+  Put queue execution on hold.
+  */
+  pause() {
+    this.#isPaused = true;
+  }
+  /**
+  Clear the queue.
+  */
+  clear() {
+    this.#queue = new this.#queueClass();
+  }
+  /**
+      Can be called multiple times. Useful if you for example add additional items at a later time.
+  
+      @returns A promise that settles when the queue becomes empty.
+      */
+  async onEmpty() {
+    if (this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("empty");
+  }
+  /**
+      @returns A promise that settles when the queue size is less than the given limit: `queue.size < limit`.
+  
+      If you want to avoid having the queue grow beyond a certain size you can `await queue.onSizeLessThan()` before adding a new item.
+  
+      Note that this only limits the number of items waiting to start. There could still be up to `concurrency` jobs already running that this call does not include in its calculation.
+      */
+  async onSizeLessThan(limit) {
+    if (this.#queue.size < limit) {
+      return;
+    }
+    await this.#onEvent("next", () => this.#queue.size < limit);
+  }
+  /**
+      The difference with `.onEmpty` is that `.onIdle` guarantees that all work from the queue has finished. `.onEmpty` merely signals that the queue is empty, but it could mean that some promises haven't completed yet.
+  
+      @returns A promise that settles when the queue becomes empty, and all promises have completed; `queue.size === 0 && queue.pending === 0`.
+      */
+  async onIdle() {
+    if (this.#pending === 0 && this.#queue.size === 0) {
+      return;
+    }
+    await this.#onEvent("idle");
+  }
+  async #onEvent(event, filter) {
+    return new Promise((resolve) => {
+      const listener = () => {
+        if (filter && !filter()) {
+          return;
+        }
+        this.off(event, listener);
+        resolve();
+      };
+      this.on(event, listener);
+    });
+  }
+  /**
+  Size of the queue, the number of queued items waiting to run.
+  */
+  get size() {
+    return this.#queue.size;
+  }
+  /**
+      Size of the queue, filtered by the given options.
+  
+      For example, this can be used to find the number of items remaining in the queue with a specific priority level.
+      */
+  sizeBy(options) {
+    return this.#queue.filter(options).length;
+  }
+  /**
+  Number of running items (no longer in the queue).
+  */
+  get pending() {
+    return this.#pending;
+  }
+  /**
+  Whether the queue is currently paused.
+  */
+  get isPaused() {
+    return this.#isPaused;
+  }
+};
+
+// ../src/engine/ingest.ts
+var queue = new PQueue({ concurrency: 3 });
+var ENABLE_AUTO_EXTRACTION = process.env.DISABLE_AUTO_EXTRACTION !== "true";
+async function ingestDocument(input) {
+  const { sourceId, projectId, externalId, title, content, metadata = {}, filePath } = input;
+  const contentHash = createHash("sha256").update(content).digest("hex");
+  const doc = await prisma.document.upsert({
+    where: {
+      sourceId_externalId: {
+        sourceId,
+        externalId
+      }
+    },
+    update: {
+      title,
+      content,
+      metadata,
+      contentHash,
+      updatedAt: /* @__PURE__ */ new Date()
+    },
+    create: {
+      sourceId,
+      projectId,
+      externalId,
+      title,
+      content,
+      metadata,
+      contentHash
+    }
+  });
+  await prisma.chunk.deleteMany({
+    where: { documentId: doc.id }
+  });
+  const textChunks = chunkText(content, {
+    filePath: filePath || externalId,
+    metadata: { ...metadata, title }
+  });
+  console.log(`[Ingest] Document: ${doc.id}, Chunks to create: ${textChunks.length}`);
+  if (textChunks.length === 0) {
+    console.log(`[Ingest] No chunks to create for document ${doc.id}`);
+    await prisma.source.update({
+      where: { id: sourceId },
+      data: {
+        documentCount: await prisma.document.count({ where: { sourceId } }),
+        chunkCount: 0,
+        lastSyncAt: /* @__PURE__ */ new Date(),
+        status: "READY",
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    return doc;
+  }
+  const batchSize = 50;
+  const insertedChunkIds = [];
+  for (let i = 0; i < textChunks.length; i += batchSize) {
+    const batch = textChunks.slice(i, i + batchSize);
+    console.log(`[Ingest] Processing batch ${i / batchSize + 1}: ${batch.length} chunks`);
+    const embeddingVectors = await embed(batch.map((c) => c.content));
+    for (let j = 0; j < batch.length; j++) {
+      const chunk = batch[j];
+      const vector = embeddingVectors[j];
+      const vectorStr = `[${vector.join(",")}]`;
+      const metadataJson = JSON.stringify(chunk.metadata);
+      try {
+        const inserted = await prisma.$queryRaw`
+          INSERT INTO "chunks" (
+            id, "documentId", "projectId", content, "chunkType", 
+            "chunkIndex", metadata, "tokenCount", embedding, "createdAt", "updatedAt"
+          )
+          VALUES (
+            gen_random_uuid(), ${doc.id}, ${projectId}, ${chunk.content}, ${chunk.chunkType},
+            ${chunk.chunkIndex}, ${metadataJson}::jsonb, ${Math.ceil(chunk.content.length / 4)},
+            ${vectorStr}::vector, NOW(), NOW()
+          )
+          RETURNING id
+        `;
+        const chunkId = inserted[0]?.id;
+        console.log(`[Ingest] Created chunk: ${chunkId}`);
+        insertedChunkIds.push(chunkId);
+      } catch (err) {
+        console.error("[Ingest] Error inserting chunk with embedding:", err.message);
+        try {
+          const inserted = await prisma.$queryRaw`
+            INSERT INTO "chunks" (
+              id, "documentId", "projectId", content, "chunkType", 
+              "chunkIndex", metadata, "tokenCount", "createdAt", "updatedAt"
+            )
+            VALUES (
+              gen_random_uuid(), ${doc.id}, ${projectId}, ${chunk.content}, ${chunk.chunkType},
+              ${chunk.chunkIndex}, ${metadataJson}::jsonb, ${Math.ceil(chunk.content.length / 4)},
+              NOW(), NOW()
+            )
+            RETURNING id
+          `;
+          const chunkId = inserted[0]?.id;
+          console.log(`[Ingest] Created chunk (no embedding): ${chunkId}`);
+          insertedChunkIds.push(chunkId);
+        } catch (err2) {
+          console.error("[Ingest] Error inserting chunk:", err2.message);
+        }
+      }
+    }
+  }
+  console.log(`[Ingest] Total chunks created: ${insertedChunkIds.length} for document ${doc.id}`);
+  if (ENABLE_AUTO_EXTRACTION && !input.skipEntityExtraction) {
+    const chunksToExtract = textChunks.filter((c) => c.content.length > 200).slice(0, 5);
+    for (let i = 0; i < chunksToExtract.length; i++) {
+      const chunk = chunksToExtract[i];
+      const chunkId = insertedChunkIds[textChunks.indexOf(chunk)];
+      extractEntities(projectId, chunk.content, chunk.chunkType, metadata, chunkId).catch(() => {
+      });
+    }
+  }
+  const docCount = await prisma.document.count({
+    where: { sourceId }
+  });
+  const chunkCount = await prisma.chunk.count({
+    where: { documentId: doc.id }
+  });
+  await prisma.source.update({
+    where: { id: sourceId },
+    data: {
+      documentCount: docCount,
+      chunkCount,
+      lastSyncAt: /* @__PURE__ */ new Date(),
+      status: "READY",
+      updatedAt: /* @__PURE__ */ new Date()
+    }
+  });
+  return doc;
+}
+
+export {
+  ingestDocument
+};