ultracode 5.4.0 → 5.6.0

package/dist/chunks/chunk-ROQ27LSL.js

@@ -0,0 +1,924 @@
+import { cosineSimilarity, simdL2Normalize } from './chunk-QN237S7C.js';
+import { init_storage_paths, getDataDir } from './chunk-LH4OUKNZ.js';
+import { sleep as sleep$1 } from './chunk-IMQ6WSJV.js';
+import { init_runtime, sleep } from './chunk-BMHPPH2B.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import { __require } from './chunk-NAQKA54E.js';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { connect } from 'net';
+
+// src/semantic/gpu/gpu-client.ts
+init_logging();
+init_storage_paths();
+init_runtime();
+
+// src/semantic/gpu/adaptive-thresholds.ts
+init_logging();
+var DEFAULT_THRESHOLDS = {
+  cudaBatchCosine: {
+    dim384: 2e3,
+    // Very small vectors - high IPC overhead ratio
+    dim768: 1e3,
+    // Medium vectors - ~1ms IPC vs ~1ms compute
+    dim1024: 500,
+    // Larger vectors - compute dominates
+    dim8192: 50
+    // Large vectors - CUDA always wins for batches
+  },
+  cudaNormalize: {
+    dim384: 5e3,
+    // Normalization is simpler - needs more vectors
+    dim768: 2e3,
+    dim1024: 1e3,
+    dim8192: 100
+  },
+  faissIndexBuild: {
+    bulkInsertThreshold: 500,
+    // Use Faiss for 500+ vectors bulk insert
+    rebuildThreshold: 1e3,
+    // Use Faiss if rebuilding index with 1000+ vectors
+    incrementalDeltaPercent: 30
+    // Use Faiss rebuild if delta > 30% of total
+  },
+  faissSearch: {
+    minIndexSize: 100,
+    // Use Faiss HNSW if index has 100+ vectors
+    batchQueryThreshold: 10
+    // Use Faiss batch search for 10+ queries
+  }
+};
+var currentThresholds = { ...DEFAULT_THRESHOLDS };
+function getDimThreshold(thresholds, dimensions) {
+  if (dimensions <= 384) return thresholds.dim384;
+  if (dimensions <= 768) return thresholds.dim768;
+  if (dimensions <= 1024) return thresholds.dim1024;
+  return thresholds.dim8192;
+}
+function shouldUseCudaBatchCosine(vectorCount, dimensions) {
+  const threshold = getDimThreshold(currentThresholds.cudaBatchCosine, dimensions);
+  const shouldUse = vectorCount >= threshold;
+  if (process.env["ADAPTIVE_DEBUG"] === "true") {
+    log.d("ADAPTIVE", "cudaBatchCosine decision", {
+      count: vectorCount,
+      dim: dimensions,
+      threshold,
+      useCuda: shouldUse
+    });
+  }
+  return shouldUse;
+}
+function shouldUseCudaNormalize(vectorCount, dimensions) {
+  const threshold = getDimThreshold(currentThresholds.cudaNormalize, dimensions);
+  return vectorCount >= threshold;
+}
+function shouldUseFaissRebuild(currentIndexSize, deltaCount) {
+  if (currentIndexSize >= currentThresholds.faissIndexBuild.rebuildThreshold) {
+    return true;
+  }
+  return false;
+}
+function shouldUseFaissSearch(indexSize, queryCount = 1) {
+  if (indexSize >= currentThresholds.faissSearch.minIndexSize) {
+    return true;
+  }
+  if (queryCount >= currentThresholds.faissSearch.batchQueryThreshold) {
+    return true;
+  }
+  return false;
+}
+function getRecommendedStrategy(vectorCount, dimensions, isRebuild, queryBatchSize = 1) {
+  const reasons = [];
+  let indexStrategy = "libsql-diskann";
+  if (isRebuild && shouldUseFaissRebuild(vectorCount)) {
+    indexStrategy = "faiss-hnsw";
+    reasons.push(`Faiss HNSW for rebuild (${vectorCount} vectors)`);
+  } else if (vectorCount > 1e4) {
+    indexStrategy = "faiss-ivf";
+    reasons.push(`Faiss IVF for large index (${vectorCount} vectors)`);
+  }
+  let searchStrategy = "libsql";
+  if (shouldUseFaissSearch(vectorCount, queryBatchSize)) {
+    searchStrategy = queryBatchSize > 1 ? "faiss" : "hybrid";
+    reasons.push(`Faiss search (index=${vectorCount}, queries=${queryBatchSize})`);
+  }
+  const useCudaForReranking = shouldUseCudaBatchCosine(vectorCount, dimensions);
+  if (useCudaForReranking) {
+    reasons.push(`CUDA reranking (${vectorCount} \xD7 ${dimensions}-dim)`);
+  }
+  return {
+    indexStrategy,
+    searchStrategy,
+    useCudaForReranking,
+    reason: reasons.join("; ") || "Default CPU strategy"
+  };
+}
+var PIPE_PREFIX = process.platform === "win32" ? "\\\\.\\pipe\\ultracode-gpu-" : "/tmp/ultracode-gpu-";
+var GrowableBuffer = class {
+  buffer;
+  length = 0;
+  initialSize;
+  constructor(initialSize = 65536) {
+    this.initialSize = initialSize;
+    this.buffer = Buffer.allocUnsafe(initialSize);
+  }
+  /** Ensure capacity for additional bytes */
+  ensureCapacity(needed) {
+    const required = this.length + needed;
+    if (required > this.buffer.length) {
+      const newSize = Math.max(this.buffer.length * 2, required);
+      const newBuffer = Buffer.allocUnsafe(newSize);
+      this.buffer.copy(newBuffer, 0, 0, this.length);
+      this.buffer = newBuffer;
+    }
+  }
+  /** Shrink buffer back to initial size if empty and oversized */
+  shrinkIfEmpty() {
+    if (this.length === 0 && this.buffer.length > this.initialSize) {
+      this.buffer = Buffer.allocUnsafe(this.initialSize);
+    }
+  }
+  /** Append chunk to buffer */
+  append(chunk) {
+    this.ensureCapacity(chunk.length);
+    chunk.copy(this.buffer, this.length);
+    this.length += chunk.length;
+  }
+  /** Get current data length */
+  get dataLength() {
+    return this.length;
+  }
+  /** Read UInt32LE at offset */
+  readUInt32LE(offset) {
+    return this.buffer.readUInt32LE(offset);
+  }
+  /** Get subarray view (valid until next append) */
+  subarray(start, end) {
+    return this.buffer.subarray(start, end);
+  }
+  /** Consume bytes from front (shift remaining data) */
+  consume(bytes) {
+    if (bytes >= this.length) {
+      this.length = 0;
+    } else {
+      this.buffer.copy(this.buffer, 0, bytes, this.length);
+      this.length -= bytes;
+    }
+    this.shrinkIfEmpty();
+  }
+  /** Reset buffer */
+  reset() {
+    this.length = 0;
+    this.shrinkIfEmpty();
+  }
+};
+var NamedPipeClient = class {
+  socket = null;
+  options;
+  pipePath;
+  connected = false;
+  pendingRequest = null;
+  responseBuffer = new GrowableBuffer(65536);
+  constructor(options) {
+    this.options = {
+      timeout: 3e4,
+      ...options
+    };
+    this.pipePath = PIPE_PREFIX + options.pipeId;
+  }
+  get path() {
+    return this.pipePath;
+  }
+  get isConnected() {
+    return this.connected;
+  }
+  async connect() {
+    if (this.connected) return;
+    return new Promise((resolve, reject) => {
+      this.socket = connect(this.pipePath);
+      this.socket.on("connect", () => {
+        this.connected = true;
+        this.options.onConnect?.();
+        resolve();
+      });
+      this.socket.on("data", (chunk) => {
+        this.handleData(chunk);
+      });
+      this.socket.on("error", (err) => {
+        this.connected = false;
+        this.options.onError?.(err);
+        if (this.pendingRequest) {
+          this.pendingRequest.reject(err);
+          this.pendingRequest = null;
+        }
+        reject(err);
+      });
+      this.socket.on("close", () => {
+        this.connected = false;
+        this.options.onDisconnect?.();
+        if (this.pendingRequest) {
+          this.pendingRequest.reject(new Error("Connection closed"));
+          this.pendingRequest = null;
+        }
+      });
+    });
+  }
+  handleData(chunk) {
+    this.responseBuffer.append(chunk);
+    if (this.responseBuffer.dataLength >= 4) {
+      const respLen = this.responseBuffer.readUInt32LE(0);
+      if (this.responseBuffer.dataLength >= 4 + respLen) {
+        const response = Buffer.from(this.responseBuffer.subarray(4, 4 + respLen));
+        this.responseBuffer.consume(4 + respLen);
+        if (this.pendingRequest) {
+          this.pendingRequest.resolve(response);
+          this.pendingRequest = null;
+        }
+      }
+    }
+  }
+  async send(packet) {
+    if (!this.socket || !this.connected) {
+      throw new Error("Not connected");
+    }
+    if (this.pendingRequest) {
+      throw new Error("Another request is pending");
+    }
+    const abortController = new AbortController();
+    const responsePromise = new Promise((resolve, reject) => {
+      this.pendingRequest = {
+        resolve: (response) => {
+          abortController.abort();
+          resolve(response);
+        },
+        reject: (error) => {
+          abortController.abort();
+          reject(error);
+        }
+      };
+      const sendBuffer = Buffer.allocUnsafe(4 + packet.length);
+      sendBuffer.writeUInt32LE(packet.length, 0);
+      packet.copy(sendBuffer, 4);
+      this.socket.write(sendBuffer);
+    });
+    const timeoutPromise = (async () => {
+      await sleep$1(this.options.timeout ?? 3e4);
+      if (abortController.signal.aborted) {
+        return new Promise(() => {
+        });
+      }
+      this.pendingRequest = null;
+      throw new Error("Request timeout");
+    })();
+    return Promise.race([responsePromise, timeoutPromise]);
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.destroy();
+      this.socket = null;
+      this.connected = false;
+    }
+  }
+};
+function createPacket(header, vectors) {
+  const headerJson = JSON.stringify(header);
+  const headerBuf = Buffer.from(headerJson);
+  if (!vectors || vectors.length === 0) {
+    const packet2 = Buffer.allocUnsafe(4 + headerBuf.length);
+    packet2.writeUInt32LE(headerBuf.length, 0);
+    headerBuf.copy(packet2, 4);
+    return packet2;
+  }
+  const vectorsBuf = Buffer.from(vectors.buffer, vectors.byteOffset, vectors.byteLength);
+  const packet = Buffer.allocUnsafe(4 + headerBuf.length + vectorsBuf.length);
+  packet.writeUInt32LE(headerBuf.length, 0);
+  headerBuf.copy(packet, 4);
+  vectorsBuf.copy(packet, 4 + headerBuf.length);
+  return packet;
+}
+function parsePacket(packet) {
+  const headerLen = packet.readUInt32LE(0);
+  const headerJson = packet.subarray(4, 4 + headerLen).toString();
+  const header = JSON.parse(headerJson);
+  if (packet.length > 4 + headerLen) {
+    const vectorsOffset = 4 + headerLen;
+    const vectorsLen = packet.length - vectorsOffset;
+    const vectorsBuf = packet.subarray(vectorsOffset);
+    const vectors = new Float32Array(vectorsLen / 4);
+    for (let i = 0; i < vectors.length; i++) {
+      vectors[i] = vectorsBuf.readFloatLE(i * 4);
+    }
+    return { header, vectors };
+  }
+  return { header };
+}
+
+// src/semantic/gpu/type-guards.ts
+function isGpuErrorResponse(response) {
+  return response.success === false && "error" in response;
+}
+function extractGpuError(response) {
+  if (isGpuErrorResponse(response)) {
+    return response.error;
+  }
+  return "Unknown GPU error";
+}
+function isFaissAddRequest(req) {
+  return req.type === "faiss.add";
+}
+function isFaissSearchRequest(req) {
+  return req.type === "faiss.search";
+}
+function isFaissBatchSearchRequest(req) {
+  return req.type === "faiss.batchSearch";
+}
+function isFaissTrainRequest(req) {
+  return req.type === "faiss.train";
+}
+function isCudaCosineRequest(req) {
+  return req.type === "cuda.cosine";
+}
+function isCudaBatchCosineRequest(req) {
+  return req.type === "cuda.batchCosine";
+}
+
+// src/semantic/gpu/request-helpers.ts
+function extractVectorsFromRequest(request) {
+  if (isFaissAddRequest(request)) {
+    const { vectors: v, ...rest } = request;
+    const vectors = v instanceof Float32Array ? v : new Float32Array(v);
+    return { vectors, headerData: rest };
+  }
+  if (isFaissSearchRequest(request)) {
+    const { vector: v, ...rest } = request;
+    const vectors = v instanceof Float32Array ? v : new Float32Array(v);
+    return { vectors, headerData: rest };
+  }
+  if (isFaissBatchSearchRequest(request)) {
+    const { vectors: v, ...rest } = request;
+    const vectors = v instanceof Float32Array ? v : new Float32Array(v);
+    return { vectors, headerData: rest };
+  }
+  if (isFaissTrainRequest(request)) {
+    const { vectors: v, ...rest } = request;
+    const vectors = v instanceof Float32Array ? v : new Float32Array(v);
+    return { vectors, headerData: rest };
+  }
+  if (isCudaCosineRequest(request)) {
+    const { a, b, ...rest } = request;
+    const aArr = a instanceof Float32Array ? a : new Float32Array(a);
+    const bArr = b instanceof Float32Array ? b : new Float32Array(b);
+    const totalLen = aArr.length + bArr.length;
+    const vectors = new Float32Array(totalLen);
+    vectors.set(aArr, 0);
+    vectors.set(bArr, aArr.length);
+    const headerData2 = {
+      ...rest,
+      dimensions: aArr.length
+    };
+    return { vectors, headerData: headerData2 };
+  }
+  if (isCudaBatchCosineRequest(request)) {
+    const { query, database, ...rest } = request;
+    const queryArr = query instanceof Float32Array ? query : new Float32Array(query);
+    const dbArrs = database.map((d) => d instanceof Float32Array ? d : new Float32Array(d));
+    const totalLen = queryArr.length + dbArrs.reduce((sum, arr) => sum + arr.length, 0);
+    const vectors = new Float32Array(totalLen);
+    vectors.set(queryArr, 0);
+    let offset = queryArr.length;
+    for (const arr of dbArrs) {
+      vectors.set(arr, offset);
+      offset += arr.length;
+    }
+    const headerData2 = {
+      ...rest,
+      dimensions: queryArr.length,
+      queryCount: 1,
+      databaseCount: dbArrs.length
+    };
+    return { vectors, headerData: headerData2 };
+  }
+  const headerData = { ...request };
+  return { headerData };
+}
+
+// src/semantic/gpu/gpu-client.ts
+var DEFAULT_CONFIG = {
+  nodePath: "node",
+  workerPath: "",
+  timeout: 3e4,
+  autoRestart: true,
+  maxRestarts: 3,
+  forceSubprocess: false
+};
+var GpuSubprocessClient = class {
+  config;
+  worker = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  requestId = 0;
+  restartCount = 0;
+  isShuttingDown = false;
+  faissInitConfig = null;
+  responseBuffer = "";
+  _cudaAvailable = false;
+  // Named Pipe client for binary IPC
+  namedPipeClient = null;
+  namedPipePath = null;
+  useNamedPipe = false;
+  // Mutex for start() to prevent race condition with concurrent calls
+  startPromise = null;
+  // Request queue for Named Pipe (only supports one pending request at a time)
+  namedPipeRequestQueue = Promise.resolve({});
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    if (!this.config.workerPath) {
+      this.config.workerPath = this.findWorkerPath();
+    }
+    this.registerCleanupHandlers();
+  }
+  registerCleanupHandlers() {
+    const cleanup = () => {
+      if (this.worker && !this.isShuttingDown) {
+        this.isShuttingDown = true;
+        log.d("GPU", "Parent exiting, killing worker...");
+        if (this.namedPipeClient) {
+          this.namedPipeClient.disconnect();
+          this.namedPipeClient = null;
+        }
+        this.worker.kill();
+        this.worker = null;
+        for (const [, pending] of this.pendingRequests) {
+          pending.abortController.abort();
+          pending.reject(new Error("Client shutting down"));
+        }
+        this.pendingRequests.clear();
+      }
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  }
+  findWorkerPath() {
+    const candidates = [];
+    const currentDir = dirname(fileURLToPath(import.meta.url));
+    let distRoot = currentDir;
+    if (currentDir.includes("chunks")) {
+      distRoot = dirname(currentDir);
+    } else if (currentDir.includes("semantic")) {
+      distRoot = dirname(dirname(currentDir));
+    }
+    candidates.push(join(distRoot, "semantic", "gpu", "gpu-worker.js"));
+    candidates.push(join(currentDir, "gpu-worker.js"));
+    try {
+      const pkgPath = __require.resolve("ultracode");
+      candidates.push(join(dirname(pkgPath), "semantic/gpu/gpu-worker.js"));
+    } catch {
+    }
+    candidates.push(join(process.cwd(), "dist/semantic/gpu/gpu-worker.js"));
+    for (const path of candidates) {
+      if (existsSync(path)) {
+        log.d("GPU", "Found worker at", { path });
+        return path;
+      }
+    }
+    const fallback = candidates[0] ?? join(process.cwd(), "dist/semantic/gpu/gpu-worker.js");
+    log.w("GPU", "Worker not found, using fallback", { path: fallback, candidates });
+    return fallback;
+  }
+  async start() {
+    if (this.startPromise) {
+      return this.startPromise;
+    }
+    if (this.worker) return true;
+    if (process.env["ULTRACODE_NO_SUBPROCESS"] === "1") {
+      log.d("GPU", "SKIPPED (ULTRACODE_NO_SUBPROCESS=1)");
+      return false;
+    }
+    this.startPromise = this.startInternal();
+    return this.startPromise;
+  }
+  async startInternal() {
+    try {
+      log.i("GPU", "Starting worker", {
+        nodePath: this.config.nodePath,
+        workerPath: this.config.workerPath
+      });
+      const isWindows = process.platform === "win32";
+      const isBun = typeof Bun !== "undefined";
+      if (!isBun || isWindows) {
+        const { spawn } = await import('child_process');
+        this.worker = spawn(this.config.nodePath, ["--expose-gc", this.config.workerPath], {
+          stdio: ["pipe", "pipe", "pipe"],
+          // Capture stderr for logging
+          windowsHide: true
+        });
+        this.worker.unref();
+        if (this.worker.stderr) {
+          this.worker.stderr.on("data", (data) => {
+            const msg = data.toString().trim();
+            if (msg) {
+              log.d("GPU", msg);
+            }
+          });
+        }
+      } else {
+        const global = globalThis;
+        const proc = global.Bun?.["spawn"]([this.config.nodePath, "--expose-gc", this.config.workerPath], {
+          stdin: "pipe",
+          stdout: "pipe",
+          stderr: "pipe"
+          // Capture stderr for logging
+        });
+        const wrapper = {
+          stdin: proc.stdin,
+          stdout: proc.stdout,
+          stderr: proc.stderr,
+          pid: proc.pid,
+          kill: () => proc.kill(),
+          on: (event, handler) => {
+            if (event === "exit" || event === "close") {
+              proc.exited.then((code) => handler(code));
+            }
+          }
+        };
+        this.worker = wrapper;
+      }
+      this.setupStdoutReader();
+      await this.waitForReady();
+      try {
+        const info = await this.cudaInfo();
+        this._cudaAvailable = info.available;
+      } catch {
+      }
+      log.i("GPU", "Worker started", { cuda: this._cudaAvailable });
+      return true;
+    } catch (error) {
+      log.e("GPU", "Failed to start worker", { error: error.message });
+      return false;
+    }
+  }
+  setupStdoutReader() {
+    if (!this.worker?.stdout) return;
+    this.worker.stdout.on("data", (data) => {
+      this.responseBuffer += data.toString();
+      this.processResponseBuffer();
+    });
+    this.worker.stdout.on("error", (error) => {
+      if (!this.isShuttingDown) {
+        log.e("GPU", "stdout read error", { error: error.message });
+        this.handleWorkerCrash();
+      }
+    });
+    this.worker.on("exit", (code) => {
+      if (!this.isShuttingDown) {
+        log.w("GPU", "Worker exited", { code });
+        this.handleWorkerCrash();
+      }
+    });
+  }
+  processResponseBuffer() {
+    const lines = this.responseBuffer.split("\n");
+    this.responseBuffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed.type === "pipe.ready" && parsed.path) {
+          this.namedPipePath = parsed.path;
+          log.d("GPU", "Received pipe.ready", { path: parsed.path });
+          continue;
+        }
+        const response = parsed;
+        this.handleResponse(response);
+      } catch {
+      }
+    }
+  }
+  handleResponse(response) {
+    const entry = this.pendingRequests.entries().next().value;
+    if (entry) {
+      const [requestId, pending] = entry;
+      pending.abortController.abort();
+      this.pendingRequests.delete(requestId);
+      pending.resolve(response);
+    }
+  }
+  async waitForReady() {
+    const timeout = 5e3;
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      if (this.namedPipePath) break;
+      await sleep(50);
+    }
+    if (this.namedPipePath) {
+      try {
+        const pipeId = this.namedPipePath.split(/[/\\]/).pop()?.replace("ultracode-gpu-", "").replace(".sock", "") || "";
+        this.namedPipeClient = new NamedPipeClient({
+          pipeId,
+          timeout: this.config.timeout,
+          onConnect: () => {
+            log.i("GPU", "Connected to Named Pipe", { path: this.namedPipePath });
+          },
+          onDisconnect: () => {
+            log.d("GPU", "Named Pipe disconnected");
+            this.useNamedPipe = false;
+          },
+          onError: (err) => {
+            log.w("GPU", "Named Pipe error", { error: err.message });
+            this.useNamedPipe = false;
+          }
+        });
+        await this.namedPipeClient.connect();
+        this.useNamedPipe = true;
+        log.i("GPU", "Using Named Pipe for binary IPC");
+      } catch (error) {
+        log.w("GPU", "Failed to connect to Named Pipe, using stdin/stdout", {
+          error: error.message
+        });
+        this.namedPipeClient = null;
+        this.useNamedPipe = false;
+      }
+    } else {
+      log.d("GPU", "Named Pipe not available, using stdin/stdout");
+      await sleep(100);
+    }
+  }
+  async handleWorkerCrash() {
+    if (this.isShuttingDown) return;
+    for (const [, pending] of this.pendingRequests) {
+      pending.abortController.abort();
+      pending.reject(new Error("Worker crashed"));
+    }
+    this.pendingRequests.clear();
+    this.worker = null;
+    if (this.config.autoRestart && this.restartCount < this.config.maxRestarts) {
+      this.restartCount++;
+      const started = await this.start();
+      if (started && this.faissInitConfig) {
+        await this.faissInitialize(this.faissInitConfig);
+      }
+    }
+  }
+  async stop() {
+    this.isShuttingDown = true;
+    if (this.namedPipeClient) {
+      this.namedPipeClient.disconnect();
+      this.namedPipeClient = null;
+      this.useNamedPipe = false;
+    }
+    if (this.worker) {
+      try {
+        this.worker.stdin?.write(`${JSON.stringify({ type: "shutdown" })}
+`);
+        await sleep(500);
+      } catch {
+      }
+      if (this.worker) {
+        try {
+          this.worker.kill("SIGTERM");
+        } catch {
+        }
+        this.worker = null;
+      }
+    }
+    for (const [, pending] of this.pendingRequests) {
+      pending.abortController.abort();
+      pending.reject(new Error("Client shutting down"));
+    }
+    this.pendingRequests.clear();
+  }
+  isRunning() {
+    return this.worker !== null && !this.isShuttingDown;
+  }
+  async sendRequest(request) {
+    if (!this.worker?.stdin) {
+      throw new Error("Worker not running");
+    }
+    if (this.useNamedPipe && this.namedPipeClient?.isConnected) {
+      log.i("GPU", "Using Named Pipe", { type: request.type });
+      return this.sendNamedPipeRequest(request);
+    }
+    const jsonStr = JSON.stringify(request);
+    log.i("GPU", "Using stdin/stdout JSON", {
+      type: request.type,
+      jsonLen: jsonStr.length
+    });
+    const requestId = ++this.requestId;
+    const abortController = new AbortController();
+    const responsePromise = new Promise((resolve, reject) => {
+      this.pendingRequests.set(requestId, { resolve, reject, abortController });
+      this.worker.stdin.write(`${jsonStr}
+`);
+    });
+    const timeoutPromise = (async () => {
+      await sleep(this.config.timeout);
+      if (abortController.signal.aborted) {
+        return new Promise(() => {
+        });
+      }
+      this.pendingRequests.delete(requestId);
+      throw new Error(`Request timeout: ${request.type}`);
+    })();
+    return Promise.race([responsePromise, timeoutPromise]);
+  }
+  /**
+   * Send request via Named Pipe (binary protocol)
+   * Uses queue to ensure only one request is pending at a time
+   */
+  async sendNamedPipeRequest(request) {
+    const previousRequest = this.namedPipeRequestQueue;
+    const currentRequest = previousRequest.catch(() => {
+    }).then(() => this.sendNamedPipeRequestInternal(request));
+    this.namedPipeRequestQueue = currentRequest;
+    return currentRequest;
+  }
+  /**
+   * Internal Named Pipe request handler (called sequentially via queue)
+   */
+  async sendNamedPipeRequestInternal(request) {
+    if (!this.namedPipeClient?.isConnected) {
+      throw new Error("Named Pipe not connected");
+    }
+    const { vectors, headerData } = extractVectorsFromRequest(request);
+    const packet = createPacket(headerData, vectors);
+    const responseBuffer = await this.namedPipeClient.send(packet);
+    const { header } = parsePacket(responseBuffer);
+    return header;
+  }
+  // =========================================================================
+  // Faiss Operations
+  // =========================================================================
+  async faissInitialize(config, loadPath) {
+    this.faissInitConfig = config;
+    if (!this.worker) {
+      await this.start();
+    }
+    const response = await this.sendRequest({ type: "faiss.init", config, loadPath });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+  async faissAdd(ids, vectors) {
+    const vectorArray = vectors instanceof Float32Array ? Array.from(vectors) : vectors;
+    const response = await this.sendRequest({ type: "faiss.add", ids, vectors: vectorArray });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+  async faissSearch(vector, k) {
+    const vectorArray = vector instanceof Float32Array ? Array.from(vector) : vector;
+    log.i("GPU", "faissSearch input", {
+      vectorLen: vectorArray?.length,
+      k,
+      isArray: Array.isArray(vectorArray)
+    });
+    const request = { type: "faiss.search", vector: vectorArray, k };
+    log.i("GPU", "faissSearch request", {
+      hasVector: !!request.vector,
+      vectorLen: request.vector?.length,
+      keys: Object.keys(request)
+    });
+    const response = await this.sendRequest(request);
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response.results;
+  }
+  async faissBatchSearch(vectors, nQueries, k) {
+    const vectorArray = vectors instanceof Float32Array ? Array.from(vectors) : vectors;
+    const response = await this.sendRequest({ type: "faiss.batchSearch", vectors: vectorArray, nQueries, k });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response.results;
+  }
+  async faissTrain(vectors, nVectors) {
+    const vectorArray = vectors instanceof Float32Array ? Array.from(vectors) : vectors;
+    const response = await this.sendRequest({ type: "faiss.train", vectors: vectorArray, nVectors });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+  async faissSave(path) {
+    const savePath = path || join(getDataDir(), "faiss-index.bin");
+    const response = await this.sendRequest({ type: "faiss.save", path: savePath });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+  async faissLoad(path) {
+    const response = await this.sendRequest({ type: "faiss.load", path });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+  async faissRemove(ids) {
+    const response = await this.sendRequest({ type: "faiss.remove", ids });
+    if (!response.success) throw new Error(extractGpuError(response));
+  }
+  async faissGetStats() {
+    const response = await this.sendRequest({ type: "faiss.stats" });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response.stats;
+  }
+  // =========================================================================
+  // CUDA Operations
+  // =========================================================================
+  async cudaInfo() {
+    const response = await this.sendRequest({ type: "cuda.info" });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+  isCudaAvailable() {
+    return this._cudaAvailable;
+  }
+  async cudaCosineSimilarity(a, b) {
+    const vecA = a instanceof Float32Array ? Array.from(a) : a;
+    const vecB = b instanceof Float32Array ? Array.from(b) : b;
+    const response = await this.sendRequest({ type: "cuda.cosine", a: vecA, b: vecB });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response.similarity;
+  }
+  async cudaBatchCosineSimilarity(query, database) {
+    const queryArr = query instanceof Float32Array ? Array.from(query) : query;
+    const dbArr = database.map((v) => v instanceof Float32Array ? Array.from(v) : v);
+    const response = await this.sendRequest({ type: "cuda.batchCosine", query: queryArr, database: dbArr });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return new Float32Array(response.similarities);
+  }
+  async cudaEuclideanDistance(a, b) {
+    const vecA = a instanceof Float32Array ? Array.from(a) : a;
+    const vecB = b instanceof Float32Array ? Array.from(b) : b;
+    const response = await this.sendRequest({ type: "cuda.euclidean", a: vecA, b: vecB });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response.distance;
+  }
+  async cudaNormalizeVectors(vectors) {
+    const input = vectors.map((v) => v instanceof Float32Array ? Array.from(v) : v);
+    const response = await this.sendRequest({ type: "cuda.normalize", vectors: input });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response.vectors.map((v) => new Float32Array(v));
+  }
+  // =========================================================================
+  // Adaptive Operations (auto-select CUDA vs CPU)
+  // =========================================================================
+  async adaptiveBatchCosineSimilarity(query, database) {
+    const vectorCount = database.length;
+    const dimensions = query.length;
+    if (this._cudaAvailable && shouldUseCudaBatchCosine(vectorCount, dimensions)) {
+      try {
+        const similarities2 = await this.cudaBatchCosineSimilarity(query, database);
+        return { similarities: similarities2, usedCuda: true };
+      } catch (error) {
+        log.w("GPU", "CUDA batch cosine failed, falling back to CPU", {
+          error: error.message
+        });
+      }
+    }
+    const similarities = new Float32Array(vectorCount);
+    for (let i = 0; i < vectorCount; i++) {
+      similarities[i] = cosineSimilarity(query, database[i]);
+    }
+    return { similarities, usedCuda: false };
+  }
+  async adaptiveNormalizeVectors(vectors) {
+    const vectorCount = vectors.length;
+    const dimensions = vectors[0]?.length ?? 0;
+    if (this._cudaAvailable && shouldUseCudaNormalize(vectorCount, dimensions)) {
+      try {
+        const normalized2 = await this.cudaNormalizeVectors(vectors);
+        return { normalized: normalized2, usedCuda: true };
+      } catch (error) {
+        log.w("GPU", "CUDA normalize failed, falling back to CPU", {
+          error: error.message
+        });
+      }
+    }
+    const normalized = vectors.map((v) => {
+      const copy = new Float32Array(v);
+      return simdL2Normalize(copy);
+    });
+    return { normalized, usedCuda: false };
+  }
+  getRecommendedStrategy(vectorCount, dimensions, isRebuild, queryBatchSize = 1) {
+    return getRecommendedStrategy(vectorCount, dimensions, isRebuild, queryBatchSize);
+  }
+  // =========================================================================
+  // Combined Stats
+  // =========================================================================
+  async getStats() {
+    const response = await this.sendRequest({ type: "stats" });
+    if (!response.success) throw new Error(extractGpuError(response));
+    return response;
+  }
+};
+var gpuClient = null;
+function getGpuClient(config) {
+  if (!gpuClient) {
+    log.i("GPU", "Using subprocess mode");
+    gpuClient = new GpuSubprocessClient(config);
+  }
+  return gpuClient;
+}
+async function shutdownGpuClient() {
+  if (gpuClient) {
+    await gpuClient.stop();
+    gpuClient = null;
+  }
+}
+
+export { getGpuClient, getRecommendedStrategy, shutdownGpuClient };
+//# sourceMappingURL=chunk-ROQ27LSL.js.map
+//# sourceMappingURL=chunk-ROQ27LSL.js.map