@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-2FQL4PDC.js

@@ -0,0 +1,292 @@
+import {
+  noOpLogger
+} from "./chunk-WBPVKEEE.js";
+import {
+  readBundledInstructionText
+} from "./chunk-5S437PRC.js";
+import {
+  estimateMessageTokens,
+  estimateTextTokens
+} from "./chunk-FSWCWSTS.js";
+import {
+  isTextBlock
+} from "./chunk-O37BQ65S.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/utils/compaction-preview.ts
+var PATH_HINT_PATTERN = /(?:(?:[A-Za-z]:)?[./\\]?[\w@.-]+(?:[\\/][\w@(). -]+)+\.[A-Za-z0-9]{1,12})/g;
+var PATH_BACKSLASH_PATTERN = /\\/g;
+var PATH_TRIM_PATTERN = /^["'`]+|["'`),;:]+$/g;
+var ERROR_LINE_PATTERN = /\b(error|exception|failed|failure|fatal|panic|timeout|denied|enoent|eacces|eperm)\b/i;
+var NEWLINE_SPLIT_PATTERN = /\r?\n/;
+var WHITESPACE_COLLAPSE_PATTERN = /\s+/g;
+function buildCompactionPreview(message, maxChars = 600) {
+  if (maxChars <= 0) return "";
+  if (typeof message.content === "string") {
+    return truncatePreview(message.content, maxChars);
+  }
+  const parts = [];
+  for (const block of message.content) {
+    if (isTextBlock(block)) {
+      const text = truncatePreview(block.text, maxChars);
+      if (text) parts.push(text);
+      continue;
+    }
+    if (block.type === "tool_use") {
+      const input = truncatePreview(safePreviewString(block.input), 220);
+      parts.push(`[tool_use: ${block.name}${input ? `; input=${input}` : ""}]`);
+      continue;
+    }
+    if (block.type === "tool_result") {
+      const raw = safePreviewString(block.content);
+      const details = [block.is_error ? "error" : "ok"];
+      if (block.name) details.push(`tool=${block.name}`);
+      const files = extractPathHints(raw).slice(0, 5);
+      if (files.length > 0) details.push(`files=${files.join(", ")}`);
+      const error = firstErrorLine(raw);
+      if (error) details.push(`error=${error}`);
+      const sample = truncatePreview(raw, 260);
+      if (sample) details.push(`sample=${sample}`);
+      parts.push(`[tool_result: ${details.join("; ")}]`);
+      continue;
+    }
+    parts.push(`[${block.type}]`);
+  }
+  return truncatePreview(parts.join(" "), maxChars);
+}
+function safePreviewString(value) {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function truncatePreview(value, maxChars) {
+  const compact = value.replace(WHITESPACE_COLLAPSE_PATTERN, " ").trim();
+  if (compact.length <= maxChars) return compact;
+  return `${compact.slice(0, Math.max(0, maxChars - 1))}\u2026`;
+}
+function extractPathHints(content) {
+  const text = safePreviewString(content);
+  const out = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(PATH_HINT_PATTERN)) {
+    const clean = match[0]?.replace(PATH_BACKSLASH_PATTERN, "/").replace(PATH_TRIM_PATTERN, "");
+    if (clean) out.add(clean);
+  }
+  return [...out];
+}
+function firstErrorLine(content) {
+  const text = safePreviewString(content);
+  for (const line of text.split(NEWLINE_SPLIT_PATTERN)) {
+    if (!ERROR_LINE_PATTERN.test(line)) continue;
+    const trimmed = line.replace(WHITESPACE_COLLAPSE_PATTERN, " ").trim();
+    if (trimmed) return truncatePreview(trimmed, 220);
+  }
+  return void 0;
+}
+
+// src/models/llm-selector.ts
+var DEFAULT_SYSTEM_PROMPT = readBundledInstructionText("llm/llm-selector.md");
+function formatMessages(messages, maxTokens = 2048) {
+  const previewChars = Math.max(
+    120,
+    Math.min(600, Math.floor(maxTokens * 3.2 / Math.max(1, messages.length)))
+  );
+  const lines = [];
+  for (let i = 0; i < messages.length; i++) {
+    const m = expectDefined(messages[i]);
+    const role = m.role.padEnd(10, " ");
+    const line = `[${i}][${role}]: ${buildCompactionPreview(m, previewChars)}`;
+    lines.push({ index: i, text: line, tokens: estimateTextTokens(line) });
+  }
+  const total = lines.reduce((sum, line) => sum + line.tokens, 0);
+  if (total <= maxTokens) return lines.map((line) => line.text).join("\n");
+  const recentCount = Math.min(8, lines.length);
+  const recentStart = lines.length - recentCount;
+  const tail = [];
+  let usedTokens = 0;
+  for (let i = lines.length - 1; i >= recentStart; i--) {
+    const line = expectDefined(lines[i]);
+    if (tail.length >= 2 && usedTokens + line.tokens > Math.floor(maxTokens * 0.45)) continue;
+    tail.unshift(line);
+    usedTokens += line.tokens;
+  }
+  const head = [];
+  for (let i = 0; i < recentStart; i++) {
+    const line = expectDefined(lines[i]);
+    if (usedTokens + line.tokens > maxTokens) break;
+    head.push(line);
+    usedTokens += line.tokens;
+  }
+  const omitted = Math.max(0, recentStart - head.length);
+  const marker = omitted > 0 ? [`[\u2026 ${omitted} middle message(s) omitted from selector preview \u2026]`] : [];
+  return [...head.map((line) => line.text), ...marker, ...tail.map((line) => line.text)].join("\n");
+}
+var LLMSelector = class {
+  provider;
+  model;
+  maxContextTokens;
+  systemPrompt;
+  maxOutputTokens;
+  oneShotOrchestrator;
+  logger;
+  constructor(opts) {
+    this.provider = opts.provider;
+    this.model = opts.model ?? "unknown";
+    this.logger = opts.logger ?? noOpLogger;
+    if (this.model === "unknown" && (process.env["NODE_ENV"] === "development" || process.env["WRONGSTACK_DEBUG"] === "1")) {
+      this.logger.warn(
+        "[LLMSelector] model not set \u2014 selector will use the provider default. Set `model` explicitly in LLMSelectorOptions to silence this warning."
+      );
+    }
+    this.maxContextTokens = opts.maxContextTokens ?? 4e4;
+    this.systemPrompt = opts.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+    this.maxOutputTokens = opts.maxOutputTokens ?? 1024;
+    this.oneShotOrchestrator = opts.oneShotOrchestrator;
+  }
+  async select(messages, maxToKeep) {
+    const effectiveBudget = Math.min(maxToKeep, this.maxContextTokens);
+    const totalTokens = estimateMessageTokens(messages);
+    const systemText = `${this.systemPrompt}
+
+Conversation (${messages.length} messages, ~${totalTokens} tokens, budget: ${effectiveBudget}):
+`;
+    const systemTokens = estimateTextTokens(systemText);
+    const historyBudget = Math.max(512, effectiveBudget - systemTokens - this.maxOutputTokens);
+    const historyText = formatMessages(messages, historyBudget);
+    const budgetInstruction = totalTokens > effectiveBudget ? `
+
+IMPORTANT: Total conversation (${totalTokens} tokens) exceeds budget (${effectiveBudget}). You MUST collapse enough to fit. Prefer collapsing older/lower-importance ranges.` : "";
+    const req = {
+      model: this.model,
+      system: [{ type: "text", text: systemText + budgetInstruction }],
+      messages: [{ role: "user", content: historyText }],
+      maxTokens: this.maxOutputTokens
+    };
+    let raw;
+    const ac = new AbortController();
+    try {
+      if (this.oneShotOrchestrator) {
+        const result = await this.oneShotOrchestrator.call({
+          system: systemText + budgetInstruction,
+          userPrompt: historyText,
+          maxTokens: this.maxOutputTokens,
+          timeoutMs: 3e4
+        });
+        if (result.error) throw new Error(result.error);
+        raw = result.text;
+      } else {
+        const timeoutSignal = AbortSignal.timeout(3e4);
+        const res = await this.provider.complete(req, {
+          signal: AbortSignal.any([ac.signal, timeoutSignal])
+        });
+        const textBlocks = res.content.filter(isTextBlock);
+        raw = textBlocks.map((b) => b.text).join("\n").trim();
+      }
+    } catch (err) {
+      if (err instanceof Error) {
+        this.logger.warn(`selector call failed, using recency fallback: ${err.message}`, {
+          event: "llm_selector.call_failed"
+        });
+      }
+      return this.fallbackSelect(messages, effectiveBudget);
+    } finally {
+      ac.abort();
+    }
+    return this.parseSelectorOutput(raw, messages);
+  }
+  fallbackSelect(messages, budget) {
+    const toKeep = [];
+    const toCollapse = [];
+    let tokenCount = 0;
+    let startIdx = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const m = expectDefined(messages[i]);
+      const cost = estimateMessageTokens([m]);
+      if (tokenCount + cost <= budget) {
+        tokenCount += cost;
+      } else {
+        startIdx = i + 1;
+        break;
+      }
+    }
+    if (startIdx > 0) {
+      toCollapse.push({ from: 0, to: startIdx - 1 });
+    }
+    toKeep.push({ from: startIdx, to: messages.length - 1, importance: "high" });
+    return {
+      kept: toKeep,
+      collapsed: toCollapse,
+      reasoning: `Fallback: kept last ${messages.length - startIdx} messages within ${budget} token budget`
+    };
+  }
+  /**
+   * Parse and validate the raw LLM output into a SelectorResult.
+   * Falls back to recency-based selection if the LLM output is malformed,
+   * out-of-bounds, or internally inconsistent.
+   */
+  parseSelectorOutput(raw, messages) {
+    const messageCount = messages.length;
+    if (messageCount === 0) {
+      return { kept: [], collapsed: [], reasoning: "empty session" };
+    }
+    const jsonStart = raw.indexOf("{");
+    const jsonEnd = raw.lastIndexOf("}");
+    if (jsonStart === -1 || jsonEnd === -1) {
+      return this.fallbackSelect(messages, this.maxContextTokens);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw.slice(jsonStart, jsonEnd + 1));
+    } catch {
+      return this.fallbackSelect(messages, this.maxContextTokens);
+    }
+    const obj = parsed;
+    const keptRaw = obj.kept ?? [];
+    const collapsedRaw = obj.collapsed ?? [];
+    const kept = [];
+    for (const k of keptRaw) {
+      if (typeof k.from !== "number" || typeof k.to !== "number" || k.from < 0 || k.to >= messageCount || k.from > k.to) {
+        return this.fallbackSelect(messages, this.maxContextTokens);
+      }
+      kept.push({
+        from: k.from,
+        to: k.to,
+        importance: k.importance ?? "medium"
+      });
+    }
+    const collapsed = [];
+    for (const c of collapsedRaw) {
+      if (typeof c.from !== "number" || typeof c.to !== "number" || c.from < 0 || c.to >= messageCount || c.from > c.to) {
+        return this.fallbackSelect(messages, this.maxContextTokens);
+      }
+      collapsed.push({ from: c.from, to: c.to, summary: c.summary });
+    }
+    const allRanges = [...kept, ...collapsed];
+    for (let i = 0; i < allRanges.length; i++) {
+      const a = allRanges[i];
+      if (!a) continue;
+      for (let j = i + 1; j < allRanges.length; j++) {
+        const b = allRanges[j];
+        if (!b) continue;
+        if (a.from <= b.to && a.to >= b.from) {
+          return this.fallbackSelect(messages, this.maxContextTokens);
+        }
+      }
+    }
+    return {
+      kept,
+      collapsed,
+      reasoning: typeof obj.reasoning === "string" ? obj.reasoning : ""
+    };
+  }
+};
+
+export {
+  buildCompactionPreview,
+  LLMSelector
+};
+//# sourceMappingURL=chunk-2FQL4PDC.js.map