lcclaude 1.0.0

package/dist/src/utils/hash.js

@@ -0,0 +1,21 @@
+export function djb2Hash(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i) | 0;
+  }
+  return hash;
+}
+export function hashContent(content) {
+  if (typeof Bun !== "undefined") {
+    return Bun.hash(content).toString();
+  }
+  const crypto = require("crypto");
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+export function hashPair(a, b) {
+  if (typeof Bun !== "undefined") {
+    return Bun.hash(b, Bun.hash(a)).toString();
+  }
+  const crypto = require("crypto");
+  return crypto.createHash("sha256").update(a).update("\x00").update(b).digest("hex");
+}

package/dist/src/utils/headlessProfiler.js

@@ -0,0 +1,95 @@
+import { getIsNonInteractiveSession } from "../bootstrap/state.js";
+import {
+  logEvent
+} from "../services/analytics/index.js";
+import { logForDebugging } from "./debug.js";
+import { isEnvTruthy } from "./envUtils.js";
+import { getPerformance } from "./profilerBase.js";
+import { jsonStringify } from "./slowOperations.js";
+const DETAILED_PROFILING = isEnvTruthy(process.env.CLAUDE_CODE_PROFILE_STARTUP);
+const STATSIG_SAMPLE_RATE = 0.05;
+const STATSIG_LOGGING_SAMPLED = process.env.USER_TYPE === "ant" || Math.random() < STATSIG_SAMPLE_RATE;
+const SHOULD_PROFILE = DETAILED_PROFILING || STATSIG_LOGGING_SAMPLED;
+const MARK_PREFIX = "headless_";
+let currentTurnNumber = -1;
+function clearHeadlessMarks() {
+  const perf = getPerformance();
+  const allMarks = perf.getEntriesByType("mark");
+  for (const mark of allMarks) {
+    if (mark.name.startsWith(MARK_PREFIX)) {
+      perf.clearMarks(mark.name);
+    }
+  }
+}
+export function headlessProfilerStartTurn() {
+  if (!getIsNonInteractiveSession())
+    return;
+  if (!SHOULD_PROFILE)
+    return;
+  currentTurnNumber++;
+  clearHeadlessMarks();
+  const perf = getPerformance();
+  perf.mark(`${MARK_PREFIX}turn_start`);
+  if (DETAILED_PROFILING) {
+    logForDebugging(`[headlessProfiler] Started turn ${currentTurnNumber}`);
+  }
+}
+export function headlessProfilerCheckpoint(name) {
+  if (!getIsNonInteractiveSession())
+    return;
+  if (!SHOULD_PROFILE)
+    return;
+  const perf = getPerformance();
+  perf.mark(`${MARK_PREFIX}${name}`);
+  if (DETAILED_PROFILING) {
+    logForDebugging(`[headlessProfiler] Checkpoint: ${name} at ${perf.now().toFixed(1)}ms`);
+  }
+}
+export function logHeadlessProfilerTurn() {
+  if (!getIsNonInteractiveSession())
+    return;
+  if (!SHOULD_PROFILE)
+    return;
+  const perf = getPerformance();
+  const allMarks = perf.getEntriesByType("mark");
+  const marks = allMarks.filter((mark) => mark.name.startsWith(MARK_PREFIX));
+  if (marks.length === 0)
+    return;
+  const checkpointTimes = new Map;
+  for (const mark of marks) {
+    const name = mark.name.slice(MARK_PREFIX.length);
+    checkpointTimes.set(name, mark.startTime);
+  }
+  const turnStart = checkpointTimes.get("turn_start");
+  if (turnStart === undefined)
+    return;
+  const metadata = {
+    turn_number: currentTurnNumber
+  };
+  const systemMessageTime = checkpointTimes.get("system_message_yielded");
+  if (systemMessageTime !== undefined && currentTurnNumber === 0) {
+    metadata.time_to_system_message_ms = Math.round(systemMessageTime);
+  }
+  const queryStartTime = checkpointTimes.get("query_started");
+  if (queryStartTime !== undefined) {
+    metadata.time_to_query_start_ms = Math.round(queryStartTime - turnStart);
+  }
+  const firstChunkTime = checkpointTimes.get("first_chunk");
+  if (firstChunkTime !== undefined) {
+    metadata.time_to_first_response_ms = Math.round(firstChunkTime - turnStart);
+  }
+  const apiRequestTime = checkpointTimes.get("api_request_sent");
+  if (queryStartTime !== undefined && apiRequestTime !== undefined) {
+    metadata.query_overhead_ms = Math.round(apiRequestTime - queryStartTime);
+  }
+  metadata.checkpoint_count = marks.length;
+  if (process.env.CLAUDE_CODE_ENTRYPOINT) {
+    metadata.entrypoint = process.env.CLAUDE_CODE_ENTRYPOINT;
+  }
+  if (STATSIG_LOGGING_SAMPLED) {
+    logEvent("tengu_headless_latency", metadata);
+  }
+  if (DETAILED_PROFILING) {
+    logForDebugging(`[headlessProfiler] Turn ${currentTurnNumber} metrics: ${jsonStringify(metadata)}`);
+  }
+}

package/dist/src/utils/heapDumpService.js

@@ -0,0 +1,157 @@
+import { createWriteStream, writeFileSync } from "fs";
+import { readdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import { pipeline } from "stream/promises";
+import {
+  getHeapSnapshot,
+  getHeapSpaceStatistics,
+  getHeapStatistics
+} from "v8";
+import { getSessionId } from "../bootstrap/state.js";
+import { logEvent } from "../services/analytics/index.js";
+import { logForDebugging } from "./debug.js";
+import { toError } from "./errors.js";
+import { getDesktopPath } from "./file.js";
+import { getFsImplementation } from "./fsOperations.js";
+import { logError } from "./log.js";
+import { jsonStringify } from "./slowOperations.js";
+export async function captureMemoryDiagnostics(trigger, dumpNumber = 0) {
+  const usage = process.memoryUsage();
+  const heapStats = getHeapStatistics();
+  const resourceUsage = process.resourceUsage();
+  const uptimeSeconds = process.uptime();
+  let heapSpaceStats;
+  try {
+    heapSpaceStats = getHeapSpaceStatistics();
+  } catch {}
+  const activeHandles = process._getActiveHandles().length;
+  const activeRequests = process._getActiveRequests().length;
+  let openFileDescriptors;
+  try {
+    openFileDescriptors = (await readdir("/proc/self/fd")).length;
+  } catch {}
+  let smapsRollup;
+  try {
+    smapsRollup = await readFile("/proc/self/smaps_rollup", "utf8");
+  } catch {}
+  const nativeMemory = usage.rss - usage.heapUsed;
+  const bytesPerSecond = uptimeSeconds > 0 ? usage.rss / uptimeSeconds : 0;
+  const mbPerHour = bytesPerSecond * 3600 / (1024 * 1024);
+  const potentialLeaks = [];
+  if (heapStats.number_of_detached_contexts > 0) {
+    potentialLeaks.push(`${heapStats.number_of_detached_contexts} detached context(s) - possible iframe/context leak`);
+  }
+  if (activeHandles > 100) {
+    potentialLeaks.push(`${activeHandles} active handles - possible timer/socket leak`);
+  }
+  if (nativeMemory > usage.heapUsed) {
+    potentialLeaks.push("Native memory > heap - leak may be in native addons (node-pty, sharp, etc.)");
+  }
+  if (mbPerHour > 100) {
+    potentialLeaks.push(`High memory growth rate: ${mbPerHour.toFixed(1)} MB/hour`);
+  }
+  if (openFileDescriptors && openFileDescriptors > 500) {
+    potentialLeaks.push(`${openFileDescriptors} open file descriptors - possible file/socket leak`);
+  }
+  return {
+    timestamp: new Date().toISOString(),
+    sessionId: getSessionId(),
+    trigger,
+    dumpNumber,
+    uptimeSeconds,
+    memoryUsage: {
+      heapUsed: usage.heapUsed,
+      heapTotal: usage.heapTotal,
+      external: usage.external,
+      arrayBuffers: usage.arrayBuffers,
+      rss: usage.rss
+    },
+    memoryGrowthRate: {
+      bytesPerSecond,
+      mbPerHour
+    },
+    v8HeapStats: {
+      heapSizeLimit: heapStats.heap_size_limit,
+      mallocedMemory: heapStats.malloced_memory,
+      peakMallocedMemory: heapStats.peak_malloced_memory,
+      detachedContexts: heapStats.number_of_detached_contexts,
+      nativeContexts: heapStats.number_of_native_contexts
+    },
+    v8HeapSpaces: heapSpaceStats?.map((space) => ({
+      name: space.space_name,
+      size: space.space_size,
+      used: space.space_used_size,
+      available: space.space_available_size
+    })),
+    resourceUsage: {
+      maxRSS: resourceUsage.maxRSS * 1024,
+      userCPUTime: resourceUsage.userCPUTime,
+      systemCPUTime: resourceUsage.systemCPUTime
+    },
+    activeHandles,
+    activeRequests,
+    openFileDescriptors,
+    analysis: {
+      potentialLeaks,
+      recommendation: potentialLeaks.length > 0 ? `WARNING: ${potentialLeaks.length} potential leak indicator(s) found. See potentialLeaks array.` : "No obvious leak indicators. Check heap snapshot for retained objects."
+    },
+    smapsRollup,
+    platform: process.platform,
+    nodeVersion: process.version,
+    ccVersion: MACRO.VERSION
+  };
+}
+export async function performHeapDump(trigger = "manual", dumpNumber = 0) {
+  try {
+    const sessionId = getSessionId();
+    const diagnostics = await captureMemoryDiagnostics(trigger, dumpNumber);
+    const toGB = (bytes) => (bytes / 1024 / 1024 / 1024).toFixed(3);
+    logForDebugging(`[HeapDump] Memory state:
+  heapUsed: ${toGB(diagnostics.memoryUsage.heapUsed)} GB (in snapshot)
+  external: ${toGB(diagnostics.memoryUsage.external)} GB (NOT in snapshot)
+  rss: ${toGB(diagnostics.memoryUsage.rss)} GB (total process)
+  ${diagnostics.analysis.recommendation}`);
+    const dumpDir = getDesktopPath();
+    await getFsImplementation().mkdir(dumpDir);
+    const suffix = dumpNumber > 0 ? `-dump${dumpNumber}` : "";
+    const heapFilename = `${sessionId}${suffix}.heapsnapshot`;
+    const diagFilename = `${sessionId}${suffix}-diagnostics.json`;
+    const heapPath = join(dumpDir, heapFilename);
+    const diagPath = join(dumpDir, diagFilename);
+    await writeFile(diagPath, jsonStringify(diagnostics, null, 2), {
+      mode: 384
+    });
+    logForDebugging(`[HeapDump] Diagnostics written to ${diagPath}`);
+    await writeHeapSnapshot(heapPath);
+    logForDebugging(`[HeapDump] Heap dump written to ${heapPath}`);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: true
+    });
+    return { success: true, heapPath, diagPath };
+  } catch (err) {
+    const error = toError(err);
+    logError(error);
+    logEvent("tengu_heap_dump", {
+      triggerManual: trigger === "manual",
+      triggerAuto15GB: trigger === "auto-1.5GB",
+      dumpNumber,
+      success: false
+    });
+    return { success: false, error: error.message };
+  }
+}
+async function writeHeapSnapshot(filepath) {
+  if (typeof Bun !== "undefined") {
+    writeFileSync(filepath, Bun.generateHeapSnapshot("v8", "arraybuffer"), {
+      mode: 384
+    });
+    Bun.gc(true);
+    return;
+  }
+  const writeStream = createWriteStream(filepath, { mode: 384 });
+  const heapSnapshotStream = getHeapSnapshot();
+  await pipeline(heapSnapshotStream, writeStream);
+}

package/dist/src/utils/heatmap.js

@@ -0,0 +1,118 @@
+import chalk from "chalk";
+import { toDateString } from "./statsCache.js";
+function calculatePercentiles(dailyActivity) {
+  const counts = dailyActivity.map((a) => a.messageCount).filter((c) => c > 0).sort((a, b) => a - b);
+  if (counts.length === 0)
+    return null;
+  return {
+    p25: counts[Math.floor(counts.length * 0.25)],
+    p50: counts[Math.floor(counts.length * 0.5)],
+    p75: counts[Math.floor(counts.length * 0.75)]
+  };
+}
+export function generateHeatmap(dailyActivity, options = {}) {
+  const { terminalWidth = 80, showMonthLabels = true } = options;
+  const dayLabelWidth = 4;
+  const availableWidth = terminalWidth - dayLabelWidth;
+  const width = Math.min(52, Math.max(10, availableWidth));
+  const activityMap = new Map;
+  for (const activity of dailyActivity) {
+    activityMap.set(activity.date, activity);
+  }
+  const percentiles = calculatePercentiles(dailyActivity);
+  const today = new Date;
+  today.setHours(0, 0, 0, 0);
+  const currentWeekStart = new Date(today);
+  currentWeekStart.setDate(today.getDate() - today.getDay());
+  const startDate = new Date(currentWeekStart);
+  startDate.setDate(startDate.getDate() - (width - 1) * 7);
+  const grid = Array.from({ length: 7 }, () => Array(width).fill(""));
+  const monthStarts = [];
+  let lastMonth = -1;
+  const currentDate = new Date(startDate);
+  for (let week = 0;week < width; week++) {
+    for (let day = 0;day < 7; day++) {
+      if (currentDate > today) {
+        grid[day][week] = " ";
+        currentDate.setDate(currentDate.getDate() + 1);
+        continue;
+      }
+      const dateStr = toDateString(currentDate);
+      const activity = activityMap.get(dateStr);
+      if (day === 0) {
+        const month = currentDate.getMonth();
+        if (month !== lastMonth) {
+          monthStarts.push({ month, week });
+          lastMonth = month;
+        }
+      }
+      const intensity = getIntensity(activity?.messageCount || 0, percentiles);
+      grid[day][week] = getHeatmapChar(intensity);
+      currentDate.setDate(currentDate.getDate() + 1);
+    }
+  }
+  const lines = [];
+  if (showMonthLabels) {
+    const monthNames = [
+      "Jan",
+      "Feb",
+      "Mar",
+      "Apr",
+      "May",
+      "Jun",
+      "Jul",
+      "Aug",
+      "Sep",
+      "Oct",
+      "Nov",
+      "Dec"
+    ];
+    const uniqueMonths = monthStarts.map((m) => m.month);
+    const labelWidth = Math.floor(width / Math.max(uniqueMonths.length, 1));
+    const monthLabels = uniqueMonths.map((month) => monthNames[month].padEnd(labelWidth)).join("");
+    lines.push("    " + monthLabels);
+  }
+  const dayLabels = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+  for (let day = 0;day < 7; day++) {
+    const label = [1, 3, 5].includes(day) ? dayLabels[day].padEnd(3) : "   ";
+    const row = label + " " + grid[day].join("");
+    lines.push(row);
+  }
+  lines.push("");
+  lines.push("    Less " + [
+    claudeOrange("░"),
+    claudeOrange("▒"),
+    claudeOrange("▓"),
+    claudeOrange("█")
+  ].join(" ") + " More");
+  return lines.join(`
+`);
+}
+function getIntensity(messageCount, percentiles) {
+  if (messageCount === 0 || !percentiles)
+    return 0;
+  if (messageCount >= percentiles.p75)
+    return 4;
+  if (messageCount >= percentiles.p50)
+    return 3;
+  if (messageCount >= percentiles.p25)
+    return 2;
+  return 1;
+}
+const claudeOrange = chalk.hex("#da7756");
+function getHeatmapChar(intensity) {
+  switch (intensity) {
+    case 0:
+      return chalk.gray("·");
+    case 1:
+      return claudeOrange("░");
+    case 2:
+      return claudeOrange("▒");
+    case 3:
+      return claudeOrange("▓");
+    case 4:
+      return claudeOrange("█");
+    default:
+      return chalk.gray("·");
+  }
+}

package/dist/src/utils/highlightMatch.js

@@ -0,0 +1,28 @@
+import * as React from "react";
+import { Text } from "../ink.js";
+export function highlightMatch(text, query) {
+  if (!query)
+    return text;
+  const queryLower = query.toLowerCase();
+  const textLower = text.toLowerCase();
+  const parts = [];
+  let offset = 0;
+  let idx = textLower.indexOf(queryLower, offset);
+  if (idx === -1)
+    return text;
+  while (idx !== -1) {
+    if (idx > offset)
+      parts.push(text.slice(offset, idx));
+    parts.push(jsxDEV_7x81h0kn(Text, {
+      inverse: true,
+      children: text.slice(idx, idx + query.length)
+    }, idx, false, undefined, this));
+    offset = idx + query.length;
+    idx = textLower.indexOf(queryLower, offset);
+  }
+  if (offset < text.length)
+    parts.push(text.slice(offset));
+  return jsxDEV_7x81h0kn(Fragment_8vg9x3sq, {
+    children: parts
+  }, undefined, false, undefined, this);
+}

package/dist/src/utils/hooks/AsyncHookRegistry.js

@@ -0,0 +1,190 @@
+import { logForDebugging } from "../debug.js";
+import { invalidateSessionEnvCache } from "../sessionEnvironment.js";
+import { jsonParse, jsonStringify } from "../slowOperations.js";
+import { emitHookResponse, startHookProgressInterval } from "./hookEvents.js";
+const pendingHooks = new Map;
+export function registerPendingAsyncHook({
+  processId,
+  hookId,
+  asyncResponse,
+  hookName,
+  hookEvent,
+  command,
+  shellCommand,
+  toolName,
+  pluginId
+}) {
+  const timeout = asyncResponse.asyncTimeout || 15000;
+  logForDebugging(`Hooks: Registering async hook ${processId} (${hookName}) with timeout ${timeout}ms`);
+  const stopProgressInterval = startHookProgressInterval({
+    hookId,
+    hookName,
+    hookEvent,
+    getOutput: async () => {
+      const taskOutput = pendingHooks.get(processId)?.shellCommand?.taskOutput;
+      if (!taskOutput) {
+        return { stdout: "", stderr: "", output: "" };
+      }
+      const stdout = await taskOutput.getStdout();
+      const stderr = taskOutput.getStderr();
+      return { stdout, stderr, output: stdout + stderr };
+    }
+  });
+  pendingHooks.set(processId, {
+    processId,
+    hookId,
+    hookName,
+    hookEvent,
+    toolName,
+    pluginId,
+    command,
+    startTime: Date.now(),
+    timeout,
+    responseAttachmentSent: false,
+    shellCommand,
+    stopProgressInterval
+  });
+}
+export function getPendingAsyncHooks() {
+  return Array.from(pendingHooks.values()).filter((hook) => !hook.responseAttachmentSent);
+}
+async function finalizeHook(hook, exitCode, outcome) {
+  hook.stopProgressInterval();
+  const taskOutput = hook.shellCommand?.taskOutput;
+  const stdout = taskOutput ? await taskOutput.getStdout() : "";
+  const stderr = taskOutput?.getStderr() ?? "";
+  hook.shellCommand?.cleanup();
+  emitHookResponse({
+    hookId: hook.hookId,
+    hookName: hook.hookName,
+    hookEvent: hook.hookEvent,
+    output: stdout + stderr,
+    stdout,
+    stderr,
+    exitCode,
+    outcome
+  });
+}
+export async function checkForAsyncHookResponses() {
+  const responses = [];
+  const pendingCount = pendingHooks.size;
+  logForDebugging(`Hooks: Found ${pendingCount} total hooks in registry`);
+  const hooks = Array.from(pendingHooks.values());
+  const settled = await Promise.allSettled(hooks.map(async (hook) => {
+    const stdout = await hook.shellCommand?.taskOutput.getStdout() ?? "";
+    const stderr = hook.shellCommand?.taskOutput.getStderr() ?? "";
+    logForDebugging(`Hooks: Checking hook ${hook.processId} (${hook.hookName}) - attachmentSent: ${hook.responseAttachmentSent}, stdout length: ${stdout.length}`);
+    if (!hook.shellCommand) {
+      logForDebugging(`Hooks: Hook ${hook.processId} has no shell command, removing from registry`);
+      hook.stopProgressInterval();
+      return { type: "remove", processId: hook.processId };
+    }
+    logForDebugging(`Hooks: Hook shell status ${hook.shellCommand.status}`);
+    if (hook.shellCommand.status === "killed") {
+      logForDebugging(`Hooks: Hook ${hook.processId} is ${hook.shellCommand.status}, removing from registry`);
+      hook.stopProgressInterval();
+      hook.shellCommand.cleanup();
+      return { type: "remove", processId: hook.processId };
+    }
+    if (hook.shellCommand.status !== "completed") {
+      return { type: "skip" };
+    }
+    if (hook.responseAttachmentSent || !stdout.trim()) {
+      logForDebugging(`Hooks: Skipping hook ${hook.processId} - already delivered/sent or no stdout`);
+      hook.stopProgressInterval();
+      return { type: "remove", processId: hook.processId };
+    }
+    const lines = stdout.split(`
+`);
+    logForDebugging(`Hooks: Processing ${lines.length} lines of stdout for ${hook.processId}`);
+    const execResult = await hook.shellCommand.result;
+    const exitCode = execResult.code;
+    let response = {};
+    for (const line of lines) {
+      if (line.trim().startsWith("{")) {
+        logForDebugging(`Hooks: Found JSON line: ${line.trim().substring(0, 100)}...`);
+        try {
+          const parsed = jsonParse(line.trim());
+          if (!("async" in parsed)) {
+            logForDebugging(`Hooks: Found sync response from ${hook.processId}: ${jsonStringify(parsed)}`);
+            response = parsed;
+            break;
+          }
+        } catch {
+          logForDebugging(`Hooks: Failed to parse JSON from ${hook.processId}: ${line.trim()}`);
+        }
+      }
+    }
+    hook.responseAttachmentSent = true;
+    await finalizeHook(hook, exitCode, exitCode === 0 ? "success" : "error");
+    return {
+      type: "response",
+      processId: hook.processId,
+      isSessionStart: hook.hookEvent === "SessionStart",
+      payload: {
+        processId: hook.processId,
+        response,
+        hookName: hook.hookName,
+        hookEvent: hook.hookEvent,
+        toolName: hook.toolName,
+        pluginId: hook.pluginId,
+        stdout,
+        stderr,
+        exitCode
+      }
+    };
+  }));
+  let sessionStartCompleted = false;
+  for (const s of settled) {
+    if (s.status !== "fulfilled") {
+      logForDebugging(`Hooks: checkForAsyncHookResponses callback rejected: ${s.reason}`, { level: "error" });
+      continue;
+    }
+    const r = s.value;
+    if (r.type === "remove") {
+      pendingHooks.delete(r.processId);
+    } else if (r.type === "response") {
+      responses.push(r.payload);
+      pendingHooks.delete(r.processId);
+      if (r.isSessionStart)
+        sessionStartCompleted = true;
+    }
+  }
+  if (sessionStartCompleted) {
+    logForDebugging(`Invalidating session env cache after SessionStart hook completed`);
+    invalidateSessionEnvCache();
+  }
+  logForDebugging(`Hooks: checkForNewResponses returning ${responses.length} responses`);
+  return responses;
+}
+export function removeDeliveredAsyncHooks(processIds) {
+  for (const processId of processIds) {
+    const hook = pendingHooks.get(processId);
+    if (hook && hook.responseAttachmentSent) {
+      logForDebugging(`Hooks: Removing delivered hook ${processId}`);
+      hook.stopProgressInterval();
+      pendingHooks.delete(processId);
+    }
+  }
+}
+export async function finalizePendingAsyncHooks() {
+  const hooks = Array.from(pendingHooks.values());
+  await Promise.all(hooks.map(async (hook) => {
+    if (hook.shellCommand?.status === "completed") {
+      const result = await hook.shellCommand.result;
+      await finalizeHook(hook, result.code, result.code === 0 ? "success" : "error");
+    } else {
+      if (hook.shellCommand && hook.shellCommand.status !== "killed") {
+        hook.shellCommand.kill();
+      }
+      await finalizeHook(hook, 1, "cancelled");
+    }
+  }));
+  pendingHooks.clear();
+}
+export function clearAllAsyncHooks() {
+  for (const hook of pendingHooks.values()) {
+    hook.stopProgressInterval();
+  }
+  pendingHooks.clear();
+}

package/dist/src/utils/hooks/apiQueryHookHelper.js

@@ -0,0 +1,67 @@
+import { randomUUID } from "crypto";
+import { queryModelWithoutStreaming } from "../../services/api/claude.js";
+import { createAbortController } from "../../utils/abortController.js";
+import { logError } from "../../utils/log.js";
+import { toError } from "../errors.js";
+import { extractTextContent } from "../messages.js";
+import { asSystemPrompt } from "../systemPromptType.js";
+export function createApiQueryHook(config) {
+  return async (context) => {
+    try {
+      const shouldRun = await config.shouldRun(context);
+      if (!shouldRun) {
+        return;
+      }
+      const uuid = randomUUID();
+      const messages = config.buildMessages(context);
+      context.queryMessageCount = messages.length;
+      const systemPrompt = config.systemPrompt ? asSystemPrompt([config.systemPrompt]) : context.systemPrompt;
+      const useTools = config.useTools ?? true;
+      const tools = useTools ? context.toolUseContext.options.tools : [];
+      const model = config.getModel(context);
+      const response = await queryModelWithoutStreaming({
+        messages,
+        systemPrompt,
+        thinkingConfig: { type: "disabled" },
+        tools,
+        signal: createAbortController().signal,
+        options: {
+          getToolPermissionContext: async () => {
+            const appState = context.toolUseContext.getAppState();
+            return appState.toolPermissionContext;
+          },
+          model,
+          toolChoice: undefined,
+          isNonInteractiveSession: context.toolUseContext.options.isNonInteractiveSession,
+          hasAppendSystemPrompt: !!context.toolUseContext.options.appendSystemPrompt,
+          temperatureOverride: 0,
+          agents: context.toolUseContext.options.agentDefinitions.activeAgents,
+          querySource: config.name,
+          mcpTools: [],
+          agentId: context.toolUseContext.agentId
+        }
+      });
+      const content = extractTextContent(response.message.content).trim();
+      try {
+        const result = config.parseResponse(content, context);
+        config.logResult({
+          type: "success",
+          queryName: config.name,
+          result,
+          messageId: response.message.id,
+          model,
+          uuid
+        }, context);
+      } catch (error) {
+        config.logResult({
+          type: "error",
+          queryName: config.name,
+          error,
+          uuid
+        }, context);
+      }
+    } catch (error) {
+      logError(toError(error));
+    }
+  };
+}