@mobb.ai/cli 1.4.49 → 1.4.50

package/dist/hash_search/index.d.mts

@@ -0,0 +1,10 @@
+import { Buffer } from 'node:buffer';
+
+declare class HashSearchError extends Error {
+    constructor(message: string);
+}
+
+declare function createIndex(originalText: string, windowSize?: number): Promise<Buffer>;
+declare function searchIndex(searchText: string, index: Buffer): Promise<number[]>;
+
+export { HashSearchError, createIndex, searchIndex };

package/dist/hash_search/index.mjs

@@ -0,0 +1,112 @@
+// src/hash_search/index.ts
+import { Buffer } from "buffer";
+import { randomBytes } from "crypto";
+import { blake3 } from "hash-wasm";
+
+// src/hash_search/errors.ts
+var HashSearchError = class _HashSearchError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "HashSearchError";
+    Object.setPrototypeOf(this, _HashSearchError.prototype);
+  }
+};
+
+// src/hash_search/index.ts
+var MIN_WINDOW_SIZE = 8;
+var DEFAULT_WINDOW_SIZE = 30;
+async function createIndex(originalText, windowSize = DEFAULT_WINDOW_SIZE) {
+  if (!originalText || typeof originalText !== "string") {
+    throw new HashSearchError("Original text must be a non-empty string");
+  }
+  if (windowSize < MIN_WINDOW_SIZE) {
+    throw new HashSearchError(`Window size must be at least ${MIN_WINDOW_SIZE}`);
+  }
+  if (originalText.length < windowSize) {
+    throw new HashSearchError(
+      `Text length must be at least ${windowSize} characters (window size)`
+    );
+  }
+  const originalLength = originalText.length;
+  const paddingNeeded = (windowSize - originalLength % windowSize) % windowSize;
+  const paddedText = originalText + "\0".repeat(paddingNeeded);
+  const numChunks = paddedText.length - windowSize + 1;
+  const bufferSize = 12 + numChunks * 24;
+  const buffer = Buffer.alloc(bufferSize);
+  buffer.writeUInt8(114, 0);
+  buffer.writeUInt8(131, 1);
+  buffer.writeUInt8(0, 2);
+  buffer.writeUInt8(1, 3);
+  buffer.writeUInt32BE(originalLength, 4);
+  buffer.writeUInt32BE(windowSize, 8);
+  for (let i = 0; i < numChunks; i++) {
+    const chunk = paddedText.slice(i, i + windowSize);
+    const salt = randomBytes(8);
+    const dataToHash = Buffer.concat([salt, Buffer.from(chunk, "utf-8")]);
+    const hashHex = await blake3(dataToHash, 128);
+    const hash = Buffer.from(hashHex, "hex");
+    const offset = 12 + i * 24;
+    salt.copy(buffer, offset);
+    hash.copy(buffer, offset + 8);
+  }
+  return buffer;
+}
+async function searchIndex(searchText, index) {
+  if (!searchText || typeof searchText !== "string") {
+    throw new HashSearchError("Search text must be a non-empty string");
+  }
+  if (!Buffer.isBuffer(index)) {
+    throw new HashSearchError("Index must be a Buffer");
+  }
+  if (index.length < 12) {
+    throw new HashSearchError("Invalid index buffer: too small");
+  }
+  if ((index.length - 12) % 24 !== 0) {
+    throw new HashSearchError("Invalid index buffer: incorrect structure");
+  }
+  if (index.readUInt8(0) !== 114 || index.readUInt8(1) !== 131 || index.readUInt8(2) !== 0 || index.readUInt8(3) !== 1) {
+    throw new HashSearchError("Invalid magic number in index buffer");
+  }
+  const windowSize = index.readUInt32BE(8);
+  if (searchText.length < windowSize) {
+    throw new HashSearchError(
+      `Search text must be at least ${windowSize} characters (window size)`
+    );
+  }
+  const originalTextLength = index.readUInt32BE(4);
+  const searchLength = searchText.length;
+  const paddingNeeded = (windowSize - searchLength % windowSize) % windowSize;
+  const paddedSearch = searchText + "\0".repeat(paddingNeeded);
+  const numPositions = (index.length - 12) / 24;
+  const searchChunks = searchLength - windowSize + 1;
+  const results = [];
+  for (let startPos = 0; startPos <= numPositions - searchChunks; startPos++) {
+    let match = true;
+    for (let j = 0; j < searchChunks; j++) {
+      const searchChunk = paddedSearch.slice(j, j + windowSize);
+      const saltOffset = 12 + (startPos + j) * 24;
+      const salt = index.subarray(saltOffset, saltOffset + 8);
+      const dataToHash = Buffer.concat([
+        salt,
+        Buffer.from(searchChunk, "utf-8")
+      ]);
+      const expectedHashHex = await blake3(dataToHash, 128);
+      const expectedHash = Buffer.from(expectedHashHex, "hex");
+      const hashOffset = saltOffset + 8;
+      const actualHash = index.subarray(hashOffset, hashOffset + 16);
+      if (!expectedHash.equals(actualHash)) {
+        match = false;
+        break;
+      }
+    }
+    if (match && startPos + searchLength <= originalTextLength) {
+      results.push(startPos);
+    }
+  }
+  return results;
+}
+export {
+  HashSearchError,
+  createIndex,
+  searchIndex
+};

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+
+export {  }