sweet-search 2.5.2 → 2.5.3

package/core/infrastructure/structural-source-definitions.js

@@ -0,0 +1,100 @@
+function escapeRegExp(text) {
+  return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function definitionPattern(name) {
+  const n = escapeRegExp(name);
+  return new RegExp([
+    `^\\s*(?:export\\s+)?(?:const|let|var)\\s+${n}\\b`,
+    `^\\s*(?:export\\s+)?(?:async\\s+)?function\\s+${n}\\s*\\(`,
+    `^\\s*(?:export\\s+)?(?:class|interface|enum|type)\\s+${n}\\b`,
+    `^\\s*(?:pub(?:\\([^)]*\\))?\\s+)?(?:const|static|fn|struct|enum|trait|type)\\s+${n}\\b`,
+    `^\\s*(?:const|var|type)\\s+${n}\\b`,
+    `^\\s*func\\s+(?:\\([^)]*\\)\\s+)?${n}\\s*\\(`,
+    `^\\s*(?:def|class)\\s+${n}\\s*[(:]`,
+  ].join('|'));
+}
+
+function definitionType(line) {
+  if (/\b(const|static)\b/.test(line)) return 'const';
+  if (/\b(var|let)\b/.test(line)) return 'variable';
+  if (/\b(class|struct)\b/.test(line)) return 'class';
+  if (/\b(interface|trait)\b/.test(line)) return 'interface';
+  if (/\benum\b/.test(line)) return 'enum';
+  if (/\b(type)\b/.test(line)) return 'type';
+  return 'function';
+}
+
+function memberAssignmentPattern(name) {
+  const n = escapeRegExp(name);
+  return new RegExp([
+    `^\\s*(?:exports|module\\.exports|[A-Za-z_$][\\w$]*)(?:\\.prototype)?(?:\\.${n}|\\[['"]${n}['"]\\])\\s*=\\s*(?:async\\s+)?function(?:\\s+${n})?\\s*\\(`,
+    `^\\s*defineGetter\\([^,]+,\\s*['"]${n}['"]\\s*,\\s*function(?:\\s+${n})?\\s*\\(`,
+  ].join('|'));
+}
+
+function findBlockEnd(lines, start) {
+  let depth = 0, seenBrace = false;
+  for (let i = start; i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === '{') { depth++; seenBrace = true; }
+      else if (ch === '}') depth--;
+    }
+    if (seenBrace && depth <= 0) return i + 1;
+  }
+  return start + 1;
+}
+
+function compactSnippet(lines, start, end) {
+  return lines.slice(start, Math.min(end, start + 4)).map(line => line.trim()).filter(Boolean).join(' ');
+}
+
+export function findSameFileDefinition({ name, filePath, readFileRange }) {
+  if (!name || !filePath || !readFileRange) return null;
+  const text = readFileRange(filePath, 1, 20000);
+  if (!text) return null;
+  const re = definitionPattern(name);
+  const lines = text.split('\n');
+  const idx = lines.findIndex(line => re.test(line));
+  if (idx < 0) return null;
+  const end = findBlockEnd(lines, idx);
+  return {
+    id: `synthetic:def:${filePath}:${idx + 1}:${name}`,
+    name,
+    type: definitionType(lines[idx]),
+    filePath,
+    startLine: idx + 1,
+    endLine: end,
+    signature: lines[idx].trim(),
+    summary: compactSnippet(lines, idx, end),
+  };
+}
+
+export function findAssignedMemberDefinitions({ name, files, readFileRange, limit = 12 }) {
+  if (!name || !files?.length || !readFileRange) return [];
+  const re = memberAssignmentPattern(name);
+  const out = [];
+  for (const filePath of files) {
+    const text = readFileRange(filePath, 1, 20000);
+    if (!text) continue;
+    const lines = text.split('\n');
+    const idx = lines.findIndex(line => re.test(line));
+    if (idx < 0) continue;
+    out.push({
+      id: `synthetic:member:${filePath}:${idx + 1}:${name}`,
+      name,
+      type: 'method',
+      filePath,
+      startLine: idx + 1,
+      endLine: findBlockEnd(lines, idx),
+      signature: lines[idx].trim(),
+      summary: 'Member assignment definition found from source text',
+    });
+    if (out.length >= limit) break;
+  }
+  return out;
+}
+
+export function findAssignedMemberDefinition(opts) {
+  return findAssignedMemberDefinitions(opts)[0] || null;
+}

package/core/infrastructure/tombstone-bitmap-reader.js

@@ -0,0 +1,139 @@
+/**
+ * Tombstone bitmap helpers for query-time artifact filtering and soft-delete
+ * writers that live outside the incremental-indexing bounded context.
+ *
+ * The writer lives in the incremental-indexing bounded context. Runtime
+ * readers in ranking/vector-store cannot import that context without
+ * violating dependency direction, so this infrastructure module owns the
+ * stable on-disk bitmap layout used by those readers.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+const HEADER_MAGIC = Buffer.from('SSTB', 'ascii');
+const HEADER_VERSION = 1;
+const HEADER_RESERVED = 64;
+const BITS_PER_BYTE = 8;
+
+function payloadByteLength(capacityBits) {
+  const minBytes = Math.ceil(capacityBits / BITS_PER_BYTE);
+  return Math.ceil(minBytes / 64) * 64;
+}
+
+export function createBitmap(capacityBits) {
+  if (!Number.isInteger(capacityBits) || capacityBits <= 0) {
+    throw new Error(`createBitmap: capacityBits must be a positive integer, got ${capacityBits}`);
+  }
+  return {
+    capacity: capacityBits,
+    payload: Buffer.alloc(payloadByteLength(capacityBits)),
+  };
+}
+
+export function loadBitmap(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const raw = fs.readFileSync(filePath);
+  if (raw.length < HEADER_RESERVED) {
+    throw new Error(`loadBitmap: ${filePath} too short (${raw.length} bytes)`);
+  }
+  if (!raw.subarray(0, 4).equals(HEADER_MAGIC)) {
+    throw new Error(`loadBitmap: ${filePath} magic mismatch`);
+  }
+  const version = raw.readUInt32LE(4);
+  if (version !== HEADER_VERSION) {
+    throw new Error(`loadBitmap: unsupported version ${version}`);
+  }
+  const capacity = Number(raw.readBigUInt64LE(8));
+  const expectedLength = HEADER_RESERVED + payloadByteLength(capacity);
+  if (raw.length < expectedLength) {
+    throw new Error(`loadBitmap: ${filePath} truncated payload (${raw.length} bytes, expected ${expectedLength})`);
+  }
+  const payload = raw.subarray(HEADER_RESERVED, HEADER_RESERVED + payloadByteLength(capacity));
+  return { capacity, payload: Buffer.from(payload) };
+}
+
+export function saveBitmap(filePath, bitmap) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const tmp = filePath + '.tmp';
+  const header = Buffer.alloc(HEADER_RESERVED);
+  HEADER_MAGIC.copy(header, 0);
+  header.writeUInt32LE(HEADER_VERSION, 4);
+  header.writeBigUInt64LE(BigInt(bitmap.capacity), 8);
+  const out = Buffer.concat([header, bitmap.payload]);
+
+  const fd = fs.openSync(tmp, 'w');
+  try {
+    fs.writeSync(fd, out);
+    fs.fsyncSync(fd);
+  } finally {
+    fs.closeSync(fd);
+  }
+  fs.renameSync(tmp, filePath);
+  try {
+    const dirFd = fs.openSync(path.dirname(filePath), 'r');
+    try { fs.fsyncSync(dirFd); } finally { fs.closeSync(dirFd); }
+  } catch {
+    // Best effort: some container/tmpfs filesystems reject directory fsync.
+  }
+}
+
+export function resizeBitmap(bitmap, newCapacityBits) {
+  if (newCapacityBits <= bitmap.capacity) return bitmap;
+  const fresh = Buffer.alloc(payloadByteLength(newCapacityBits));
+  bitmap.payload.copy(fresh, 0, 0, bitmap.payload.length);
+  bitmap.capacity = newCapacityBits;
+  bitmap.payload = fresh;
+  return bitmap;
+}
+
+function byteAndMask(index) {
+  const byte = index >>> 3;
+  const mask = 1 << (index & 7);
+  return { byte, mask };
+}
+
+export function isSet(bitmap, index) {
+  if (!bitmap || index < 0 || index >= bitmap.capacity) return false;
+  const { byte, mask } = byteAndMask(index);
+  return (bitmap.payload[byte] & mask) !== 0;
+}
+
+export function setBit(bitmap, index) {
+  if (index < 0 || index >= bitmap.capacity) {
+    throw new RangeError(`setBit: ${index} outside bitmap capacity ${bitmap.capacity}`);
+  }
+  const { byte, mask } = byteAndMask(index);
+  bitmap.payload[byte] |= mask;
+}
+
+export function popcount(bitmap) {
+  if (!bitmap) return 0;
+  let count = 0;
+  const buf = bitmap.payload;
+  const fullBytes = Math.floor(bitmap.capacity / BITS_PER_BYTE);
+  const wordBytes = fullBytes - (fullBytes % 4);
+  for (let i = 0; i < wordBytes; i += 4) {
+    let x = buf.readUInt32LE(i);
+    while (x !== 0) {
+      x &= x - 1;
+      count += 1;
+    }
+  }
+  for (let i = wordBytes; i < fullBytes; i++) {
+    let b = buf[i];
+    while (b !== 0) {
+      b &= b - 1;
+      count += 1;
+    }
+  }
+  const tailBits = bitmap.capacity % BITS_PER_BYTE;
+  if (tailBits > 0) {
+    let b = buf[fullBytes] & ((1 << tailBits) - 1);
+    while (b !== 0) {
+      b &= b - 1;
+      count += 1;
+    }
+  }
+  return count;
+}