aiwcli 0.15.7 → 0.17.0

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/index.ts

@@ -4,51 +4,51 @@
  * Public API re-exports for programmatic use from hooks/agents.
  */
 
-export { checkOllamaHealth, embed, embedOne, type OllamaConfig } from "./ollama-client.js";
+export {
+  CURRENT_SCHEMA_VERSION,
+  CLAUDE_PROJECTS_DIR,
+  RLM_INDEX_DIR,
+  RLM_VECTOR_DB_PATH,
+  OLLAMA_BASE_URL,
+  OLLAMA_EMBED_MODEL,
+  EMBED_DIMENSIONS,
+  VECTOR_TOP_K,
+  MAX_LOADER_CHARS,
+  MAX_PARALLEL_SUMMARIZERS,
+  TOP_N_HEAP,
+  WEIGHT,
+  type SessionIndex,
+  type SearchResult,
+  type LoadedSegment,
+  type IndexSegment,
+  type VectorSearchResult,
+  type ChunkSummary,
+  type RankedSession,
+  type RetrievalResult,
+} from "./types.js";
 
 export {
   discoverSessions,
   indexSession,
+  writeIndex,
   needsIndexing,
   runBatch,
-  writeIndex,
 } from "./transcript-indexer.js";
 
-export { loadTranscript } from "./transcript-loader.js";
+export { search, scoreIndex, tokenize, type SearchOptions } from "./transcript-searcher.js";
 
-export { scoreIndex, search, type SearchOptions, tokenize } from "./transcript-searcher.js";
+export { loadTranscript } from "./transcript-loader.js";
 
-export {
-  type ChunkSummary,
-  CLAUDE_PROJECTS_DIR,
-  CURRENT_SCHEMA_VERSION,
-  EMBED_DIMENSIONS,
-  type IndexSegment,
-  type LoadedSegment,
-  MAX_LOADER_CHARS,
-  MAX_PARALLEL_SUMMARIZERS,
-  OLLAMA_BASE_URL,
-  OLLAMA_EMBED_MODEL,
-  type RankedSession,
-  type RetrievalResult,
-  RLM_INDEX_DIR,
-  RLM_VECTOR_DB_PATH,
-  type SearchResult,
-  type SessionIndex,
-  TOP_N_HEAP,
-  VECTOR_TOP_K,
-  type VectorSearchResult,
-  WEIGHT,
-} from "./types.js";
+export { checkOllamaHealth, embed, embedOne, type OllamaConfig } from "./ollama-client.js";
 
 export {
-  type ChunkRow,
-  deleteSessionChunks,
-  getStats,
+  openVectorDb,
   insertChunks,
-  isSessionEmbedded,
   markSessionEmbedded,
-  openVectorDb,
+  isSessionEmbedded,
+  deleteSessionChunks,
   searchKnn,
+  getStats,
+  type ChunkRow,
   type VectorStats,
 } from "./vector-store.js";

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/logger.ts

@@ -25,18 +25,16 @@ try {
   logDebug = mod.logDebug;
 } catch {
   // Fallback: minimal stderr+file logger for standalone CLI execution
-  // eslint-disable-next-line unicorn/consistent-function-scoping -- must be inside catch for conditional init
-  const fallback = (level: string) => (hookName: string, message: string, opts?: Record<string, unknown>) => {
+  const fallback = (level: string) => {
+    return (hookName: string, message: string, opts?: Record<string, unknown>) => {
       const shouldStderr = opts?.stderr === true || level === "error";
       if (shouldStderr) {
         process.stderr.write(`[${hookName}] ${message}\n`);
       }
       // Also try JSONL file logging
       try {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef -- dynamic require in fallback path
-        const fs = require("node:fs");
-        // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef -- dynamic require in fallback path
-        const path = require("node:path");
+        const fs = require("fs");
+        const path = require("path");
         const logDir = path.join(process.cwd(), "_output");
         fs.mkdirSync(logDir, { recursive: true });
         const entry = JSON.stringify({
@@ -50,10 +48,11 @@ try {
         // Never crash on logging failure
       }
     };
+  };
   logInfo = fallback("info");
   logWarn = fallback("warn");
   logError = fallback("error");
   logDebug = fallback("debug");
 }
 
-export { logDebug, logError, logInfo, logWarn };
+export { logInfo, logWarn, logError, logDebug };

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/ollama-client.ts

@@ -1,4 +1,3 @@
-/* eslint-disable n/no-unsupported-features/node-builtins -- Bun runtime provides fetch */
 /**
  * Ollama HTTP client for local embeddings.
  *
@@ -7,14 +6,13 @@
  */
 
 import { z } from "zod";
-
-import { logDebug } from "./logger.js";
 import {
   OLLAMA_BASE_URL,
   OLLAMA_EMBED_MODEL,
   EMBED_DIMENSIONS,
   HYDE_OLLAMA_MODEL,
 } from "./types.js";
+import { logDebug, logError } from "./logger.js";
 
 const HOOK_NAME = "rlm_ollama";
 const BATCH_SIZE = 32;
@@ -54,7 +52,7 @@ export async function checkOllamaHealth(
   const cfg = { ...DEFAULT_CONFIG, ...config };
   try {
     const resp = await fetch(`${cfg.baseUrl}/api/tags`, {
-      signal: AbortSignal.timeout(5000),
+      signal: AbortSignal.timeout(5_000),
     });
     if (!resp.ok) {
       return { ok: false, error: `Ollama responded with ${resp.status}` };
@@ -76,8 +74,8 @@ export async function checkOllamaHealth(
       };
     }
     return { ok: true };
-  } catch (error: unknown) {
-    const msg = error instanceof Error ? error.message : String(error);
+  } catch (e: unknown) {
+    const msg = e instanceof Error ? e.message : String(e);
     return {
       ok: false,
       error: `Cannot reach Ollama at ${cfg.baseUrl}: ${msg}. Is Ollama running?`,
@@ -119,7 +117,7 @@ export async function embed(
       throw new Error(`Invalid Ollama embed response: ${parseResult.error.message}`);
     }
 
-    const {data} = parseResult;
+    const data = parseResult.data;
     if (data.embeddings.length !== batch.length) {
       throw new Error(
         `Expected ${batch.length} embeddings, got ${data.embeddings.length}`,
@@ -199,11 +197,11 @@ export async function generateText(
       text: data.response || "",
       latency_ms: Date.now() - startTime,
     };
-  } catch (error) {
+  } catch (e) {
     return {
       success: false,
       text: "",
-      error: String(error),
+      error: String(e),
       latency_ms: Date.now() - startTime,
     };
   }

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/retrieval-pipeline.ts

@@ -13,11 +13,6 @@
  */
 
 import { z } from "zod";
-
-import { hydeQueryEmbedding } from "./hyde.js";
-import { logInfo, logWarn, logError } from "./logger.js";
-import { checkOllamaHealth, embedOne } from "./ollama-client.js";
-import { loadTranscript } from "./transcript-loader.js";
 import {
   VECTOR_TOP_K,
   MAX_PARALLEL_SUMMARIZERS,
@@ -31,7 +26,11 @@ import {
   type RankedSession,
   type RetrievalResult,
 } from "./types.js";
+import { logInfo, logWarn, logError, logDebug } from "./logger.js";
+import { checkOllamaHealth, embedOne } from "./ollama-client.js";
 import { openVectorDb, searchKnn } from "./vector-store.js";
+import { loadTranscript } from "./transcript-loader.js";
+import { hydeQueryEmbedding } from "./hyde.js";
 
 const HOOK_NAME = "rlm_retrieve";
 
@@ -79,12 +78,10 @@ if (!query) {
   );
   process.exitCode = 1;
 } else {
-  try {
-    await runPipeline(query, topK, projectFilter);
-  } catch (error) {
-    logError(HOOK_NAME, `Fatal: ${error}`, { stderr: true });
+  runPipeline(query, topK, projectFilter).catch((e) => {
+    logError(HOOK_NAME, `Fatal: ${e}`, { stderr: true });
     process.exitCode = 1;
-  }
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -130,8 +127,8 @@ async function runPipeline(
       });
       hydeTiming = Date.now() - hydeStart;
       logInfo(HOOK_NAME, `HyDE query embedding completed in ${hydeTiming}ms`);
-    } catch (error) {
-      logWarn(HOOK_NAME, `HyDE failed: ${error}, falling back to direct query embedding`);
+    } catch (e) {
+      logWarn(HOOK_NAME, `HyDE failed: ${e}, falling back to direct query embedding`);
       queryEmbedding = await embedOne(query);
     }
   } else {
@@ -185,7 +182,7 @@ async function runPipeline(
       }
     }
   }
-  const sessions = [...sessionMap.values()];
+  const sessions = Array.from(sessionMap.values());
   logInfo(
     HOOK_NAME,
     `Stage 2: ${results.length} chunks → ${sessions.length} sessions`,
@@ -257,10 +254,10 @@ async function summarizeSessions(
     const promises = batch.map(async (session) => {
       try {
         return await summarizeOneSession(query, session);
-      } catch (error) {
+      } catch (e) {
         logWarn(
           HOOK_NAME,
-          `Summarize failed for ${session.result.session_id}: ${error}`,
+          `Summarize failed for ${session.result.session_id}: ${e}`,
         );
         return null;
       }
@@ -400,8 +397,8 @@ async function rankSessions(
         key_findings: r.key_findings,
       };
     }).filter((r): r is RankedSession => r !== null);
-  } catch (error) {
-    logWarn(HOOK_NAME, `Rank parse failed: ${error}, marking all as relevant`);
+  } catch (e) {
+    logWarn(HOOK_NAME, `Rank parse failed: ${e}, marking all as relevant`);
     return summaries.map((s) => ({
       session_id: s.session_id,
       project: s.project,

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-indexer.ts

@@ -12,18 +12,18 @@
  *   bun transcript-indexer.ts --batch --project=aiwcli   # Index matching project only
  */
 
-import { createReadStream, existsSync } from "node:fs";
-import { readdir, stat, mkdir, writeFile } from "node:fs/promises";
-import { join, basename } from "node:path";
-import { createInterface } from "node:readline";
-
-import { logInfo, logWarn, logError } from "./logger.js";
+import { readdir, stat, mkdir, readFile, writeFile } from "fs/promises";
+import { createReadStream, existsSync, readFileSync } from "fs";
+import { join, basename } from "path";
+import { createInterface } from "readline";
 import {
   CURRENT_SCHEMA_VERSION,
   CLAUDE_PROJECTS_DIR,
   RLM_INDEX_DIR,
   type SessionIndex,
+  type IndexSegment,
 } from "./types.js";
+import { logInfo, logWarn, logError, logDebug } from "./logger.js";
 
 const HOOK_NAME = "rlm_indexer";
 
@@ -39,12 +39,10 @@ const projectArg = args.find((a) => a.startsWith("--project="));
 const projectFilter = projectArg ? projectArg.split("=")[1] : null;
 
 if (isBatch) {
-  try {
-    await runBatch();
-  } catch (error) {
-    logError(HOOK_NAME, `Fatal: ${error}`, { stderr: true });
+  runBatch().catch((e) => {
+    logError(HOOK_NAME, `Fatal: ${e}`, { stderr: true });
     process.exitCode = 1;
-  }
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -91,24 +89,22 @@ async function discoverSessions(): Promise<SessionFile[]> {
   return sessions;
 }
 
-function needsIndexing(session: SessionFile, _sourceMtime: number): boolean {
+function needsIndexing(session: SessionFile, sourceMtime: number): boolean {
   const indexPath = join(RLM_INDEX_DIR, session.project, `${session.sessionId}.index.json`);
   if (!existsSync(indexPath)) return true;
   try {
     // Fast path: Read only first 100 bytes to check schema_version
     // If version matches, skip without checking mtime (schema bumps trigger full reindex anyway)
-    // eslint-disable-next-line @typescript-eslint/no-require-imports, no-undef -- dynamic fs for perf
-    const nodeFs = require("node:fs");
-    const fd = nodeFs.openSync(indexPath, "r");
+    const fd = require("fs").openSync(indexPath, "r");
     const buffer = Buffer.alloc(100);
-    const bytesRead = nodeFs.readSync(fd, buffer, 0, 100, 0);
-    nodeFs.closeSync(fd);
+    const bytesRead = require("fs").readSync(fd, buffer, 0, 100, 0);
+    require("fs").closeSync(fd);
 
     const partial = buffer.toString("utf-8", 0, bytesRead);
     const versionMatch = partial.match(/"schema_version"\s*:\s*(\d+)/);
 
     // If version matches, skip (no mtime check needed - schema version bump handles major changes)
-    if (versionMatch && parseInt(versionMatch[1], 10) === CURRENT_SCHEMA_VERSION) {
+    if (versionMatch && parseInt(versionMatch[1]) === CURRENT_SCHEMA_VERSION) {
       return false; // Skip - index is current
     }
 
@@ -156,9 +152,9 @@ async function runBatch(): Promise<void> {
       if (indexed % 10 === 0 || indexed === 1) {
         logInfo(HOOK_NAME, `Indexing: ${indexed} indexed, ${skipped} skipped, ${errors} errors (of ${allSessions.length} total)`, { stderr: true });
       }
-    } catch (error) {
+    } catch (e) {
       errors++;
-      logError(HOOK_NAME, `Error indexing ${session.sessionId}: ${error}`);
+      logError(HOOK_NAME, `Error indexing ${session.sessionId}: ${e}`);
     }
   }
 
@@ -238,7 +234,7 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
         index.user_message_count++;
         const msg = obj.message as Record<string, unknown> | undefined;
         if (msg) {
-          const {content} = msg;
+          const content = msg.content;
           if (typeof content === "string") {
             const snippet = content.slice(0, 200);
             userSnippets.push(snippet);
@@ -248,7 +244,7 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
           } else if (Array.isArray(content)) {
             for (const block of content) {
               if (typeof block === "object" && block !== null && "text" in block) {
-                const {text} = (block as Record<string, unknown>);
+                const text = (block as Record<string, unknown>).text;
                 if (typeof text === "string") {
                   extractKeywords(text, keywordBag);
                   extractKeywords(text, segmentKeywordBag);
@@ -259,8 +255,8 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
           // Extract cwd for context
           const cwd = obj.cwd as string | undefined;
           if (cwd) {
-            const parts = cwd.replaceAll('\\', "/").split("/");
-            const last = parts.at(-1);
+            const parts = cwd.replace(/\\/g, "/").split("/");
+            const last = parts[parts.length - 1];
             if (last) addKeyword(keywordBag, last);
           }
           // Git branch
@@ -273,7 +269,7 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
         index.assistant_message_count++;
         const msg = obj.message as Record<string, unknown> | undefined;
         if (msg) {
-          const {content} = msg;
+          const content = msg.content;
           if (Array.isArray(content)) {
             for (const block of content) {
               if (typeof block !== "object" || block === null) continue;
@@ -344,19 +340,19 @@ async function indexSession(session: SessionFile, sourceMtime: number): Promise<
 // ---------------------------------------------------------------------------
 
 const STOP_WORDS = new Set([
-  "a", "about", "above", "after", "all", "also", "an", "and", "any", "are",
-  "as", "at", "be", "been", "before", "being", "below", "between", "both",
-  "but", "by", "can", "class", "const", "could", "default", "did", "do",
-  "does", "during", "each", "either", "every", "export", "false", "few", "for",
-  "from", "function", "had", "has", "have", "he", "here",
-  "how", "i", "if", "import", "in", "into", "is", "it", "its", "just",
-  "let", "may", "me", "might", "more", "most", "must", "my", "neither",
-  "new", "no", "nor", "not", "now", "null", "of", "on", "or",
-  "other", "our", "return", "shall", "she", "should", "so", "some", "such",
-  "than", "that", "the", "their", "them", "then", "there", "these", "they", "this",
-  "those", "through", "to", "too", "true", "type", "undefined", "var", "very",
-  "was", "we", "were", "what", "when", "where", "which",
-  "who", "why", "will", "with", "would", "yet", "you", "your",
+  "the", "a", "an", "is", "are", "was", "were", "be", "been", "being",
+  "have", "has", "had", "do", "does", "did", "will", "would", "shall",
+  "should", "may", "might", "must", "can", "could", "of", "in", "to",
+  "for", "with", "on", "at", "from", "by", "about", "as", "into",
+  "through", "during", "before", "after", "above", "below", "between",
+  "and", "but", "or", "nor", "not", "no", "so", "yet", "both", "either",
+  "neither", "each", "every", "all", "any", "few", "more", "most", "other",
+  "some", "such", "than", "too", "very", "just", "also", "now", "then",
+  "here", "there", "when", "where", "why", "how", "what", "which", "who",
+  "this", "that", "these", "those", "it", "its", "i", "me", "my", "we",
+  "our", "you", "your", "he", "she", "they", "them", "their", "if",
+  "true", "false", "null", "undefined", "function", "return", "const",
+  "let", "var", "import", "export", "default", "class", "new", "type",
 ]);
 
 function extractKeywords(text: string, bag: Map<string, number>): void {
@@ -395,9 +391,9 @@ function extractToolMetadata(
   // File paths from Read, Edit, Write, Glob
   const filePath = input.file_path as string | undefined;
   if (filePath) {
-    const normalized = filePath.replaceAll('\\', "/");
+    const normalized = filePath.replace(/\\/g, "/");
     const parts = normalized.split("/");
-    const fileName = parts.at(-1);
+    const fileName = parts[parts.length - 1];
     if (fileName) {
       files.add(fileName);
       addKeyword(keywords, fileName.replace(/\.[^.]+$/, "")); // stem
@@ -447,4 +443,4 @@ async function writeIndex(project: string, sessionId: string, index: SessionInde
 // Exports for programmatic use
 // ---------------------------------------------------------------------------
 
-export { discoverSessions, indexSession, needsIndexing, runBatch, writeIndex };
+export { discoverSessions, indexSession, writeIndex, needsIndexing, runBatch };

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-loader.ts

@@ -11,12 +11,11 @@
  *   bun transcript-loader.ts <jsonl-path> --lines=46-120
  */
 
-import { createReadStream } from "node:fs";
-import { basename } from "node:path";
-import { createInterface } from "node:readline";
-
-import { logInfo, logError } from "./logger.js";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import { basename } from "path";
 import { MAX_LOADER_CHARS, type LoadedSegment } from "./types.js";
+import { logInfo, logWarn, logError } from "./logger.js";
 
 const HOOK_NAME = "rlm_loader";
 
@@ -36,16 +35,17 @@ if (linesArg) {
 }
 
 if (jsonlPath && !process.env.RLM_LIB_MODE) {
-  try {
-    const seg = await loadTranscript(jsonlPath, lineRange);
-    process.stdout.write(seg.content);
-    if (seg.truncated) {
-      logInfo(HOOK_NAME, "Output truncated at 50K chars", { stderr: true });
-    }
-  } catch (error) {
-    logError(HOOK_NAME, `Load failed: ${error}`, { stderr: true });
-    process.exitCode = 1;
-  }
+  loadTranscript(jsonlPath, lineRange)
+    .then((seg) => {
+      process.stdout.write(seg.content);
+      if (seg.truncated) {
+        logInfo(HOOK_NAME, "Output truncated at 50K chars", { stderr: true });
+      }
+    })
+    .catch((e) => {
+      logError(HOOK_NAME, `Load failed: ${e}`, { stderr: true });
+      process.exitCode = 1;
+    });
 }
 
 // ---------------------------------------------------------------------------
@@ -135,9 +135,9 @@ async function loadTranscript(
   }
 
   // Derive project from path
-  const pathParts = filePath.replaceAll('\\', "/").split("/");
+  const pathParts = filePath.replace(/\\/g, "/").split("/");
   const projectsIdx = pathParts.indexOf("projects");
-  if (projectsIdx !== -1 && projectsIdx + 1 < pathParts.length) {
+  if (projectsIdx >= 0 && projectsIdx + 1 < pathParts.length) {
     project = pathParts[projectsIdx + 1];
   }
 
@@ -155,7 +155,7 @@ async function loadTranscript(
 // ---------------------------------------------------------------------------
 
 function extractContent(msg: Record<string, unknown>): string | null {
-  const {content} = msg;
+  const content = msg.content;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
     const texts: string[] = [];
@@ -187,7 +187,7 @@ function extractAssistantContent(msg: Record<string, unknown>): {
   text: string;
   toolUses: ToolUse[];
 } {
-  const {content} = msg;
+  const content = msg.content;
   let text = "";
   const toolUses: ToolUse[] = [];
 
@@ -219,36 +219,26 @@ function extractAssistantContent(msg: Record<string, unknown>): {
 function summarizeToolInput(toolName: string, input?: Record<string, unknown>): string {
   if (!input) return "";
   switch (toolName) {
-    case "Bash": {
-      return input.command ? `${(input.command as string).slice(0, 80)}` : "";
-    }
-    case "Edit": {
+    case "Read":
       return input.file_path ? `${input.file_path}` : "";
-    }
-    case "Glob": {
+    case "Write":
+      return input.file_path ? `${input.file_path}` : "";
+    case "Edit":
+      return input.file_path ? `${input.file_path}` : "";
+    case "Bash":
+      return input.command ? `${(input.command as string).slice(0, 80)}` : "";
+    case "Glob":
       return input.pattern ? `${input.pattern}` : "";
-    }
-    case "Grep": {
+    case "Grep":
       return input.pattern ? `/${input.pattern}/` : "";
-    }
-    case "Read": {
-      return input.file_path ? `${input.file_path}` : "";
-    }
-    case "Task": {
+    case "Task":
       return input.description ? `${input.description}` : "";
-    }
-    case "WebFetch": {
-      return input.url ? `${input.url}` : "";
-    }
-    case "WebSearch": {
+    case "WebSearch":
       return input.query ? `"${input.query}"` : "";
-    }
-    case "Write": {
-      return input.file_path ? `${input.file_path}` : "";
-    }
-    default: {
+    case "WebFetch":
+      return input.url ? `${input.url}` : "";
+    default:
       return Object.keys(input).slice(0, 3).join(", ");
-    }
   }
 }
 

package/dist/templates/cc-native/_cc-native/lib-ts/rlm/transcript-searcher.ts

@@ -11,11 +11,12 @@
  *   bun transcript-searcher.ts "plan review" --project=aiwcli
  */
 
-import { existsSync } from "node:fs";
-import { readdir, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { readdir, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { logInfo, logWarn, logError, logDebug } from "./logger.js";
 
-import { logInfo, logWarn, logError } from "./logger.js";
+const HOOK_NAME = "rlm_searcher";
 import {
   CURRENT_SCHEMA_VERSION,
   CLAUDE_PROJECTS_DIR,
@@ -27,8 +28,6 @@ import {
   type IndexSegment,
 } from "./types.js";
 
-const HOOK_NAME = "rlm_searcher";
-
 // ---------------------------------------------------------------------------
 // CLI entry
 // ---------------------------------------------------------------------------
@@ -41,19 +40,20 @@ const projectArg = args.find((a) => a.startsWith("--project="));
 const projectFilter = projectArg ? projectArg.split("=")[1] : null;
 
 if (query && !process.env.RLM_LIB_MODE) {
-  try {
-    const results = await search(query, { topN, projectFilter });
-    if (typeof results === "string") {
-      logWarn(HOOK_NAME, results, { stderr: true });
+  search(query, { topN, projectFilter })
+    .then((results) => {
+      if (typeof results === "string") {
+        logWarn(HOOK_NAME, results, { stderr: true });
+        process.exitCode = 1;
+      } else {
+        logInfo(HOOK_NAME, `Search returned ${results.length} results`);
+        process.stdout.write(JSON.stringify(results, null, 2) + "\n");
+      }
+    })
+    .catch((e) => {
+      logError(HOOK_NAME, `Search failed: ${e}`, { stderr: true });
       process.exitCode = 1;
-    } else {
-      logInfo(HOOK_NAME, `Search returned ${results.length} results`);
-      process.stdout.write(JSON.stringify(results, null, 2) + "\n");
-    }
-  } catch (error) {
-    logError(HOOK_NAME, `Search failed: ${error}`, { stderr: true });
-    process.exitCode = 1;
-  }
+    });
 }
 
 // ---------------------------------------------------------------------------
@@ -251,7 +251,7 @@ function tokenize(query: string): string[] {
   return query
     .toLowerCase()
     .split(/\s+/)
-    .map((t) => t.replaceAll(/[^a-z0-9_-]/g, ""))
+    .map((t) => t.replace(/[^a-z0-9_-]/g, ""))
     .filter((t) => t.length >= 2);
 }
 
@@ -271,4 +271,4 @@ function insertSorted(arr: SearchResult[], item: SearchResult, maxSize: number):
 // Exports
 // ---------------------------------------------------------------------------
 
-export { scoreIndex, search, type SearchOptions, tokenize };
+export { search, scoreIndex, tokenize, type SearchOptions };