0sec-cli 0.15.0 → 0.18.0

package/chunks/chunk-RRMJC3ZE.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+import { createRequire as __0secCreateRequire } from "node:module";
+const require = __0secCreateRequire(import.meta.url);
+
+// packages/core/dist/agent/output-truncation.js
+var BYTES_PER_TOKEN = 4;
+var DEFAULT_TOOL_OUTPUT_TOKENS = 1e4;
+function utf8Size(codePoint) {
+  if (codePoint < 128)
+    return 1;
+  if (codePoint < 2048)
+    return 2;
+  if (codePoint < 65536)
+    return 3;
+  return 4;
+}
+function headSlice(text, byteBudget) {
+  let bytes = 0;
+  let i = 0;
+  while (i < text.length) {
+    const cp = text.codePointAt(i);
+    const size = utf8Size(cp);
+    if (bytes + size > byteBudget)
+      break;
+    bytes += size;
+    i += cp > 65535 ? 2 : 1;
+  }
+  return text.slice(0, i);
+}
+function tailSlice(text, byteBudget) {
+  let bytes = 0;
+  let end = text.length;
+  while (end > 0) {
+    let start = end - 1;
+    const unit = text.charCodeAt(start);
+    if (unit >= 56320 && unit <= 57343 && start > 0) {
+      const prev = text.charCodeAt(start - 1);
+      if (prev >= 55296 && prev <= 56319)
+        start -= 1;
+    }
+    const size = utf8Size(text.codePointAt(start));
+    if (bytes + size > byteBudget)
+      break;
+    bytes += size;
+    end = start;
+  }
+  return text.slice(end);
+}
+function truncateMiddle(text, options = {}) {
+  const limit = options.limit ?? DEFAULT_TOOL_OUTPUT_TOKENS;
+  const mode = options.mode ?? "tokens";
+  const byteBudget = Math.max(0, mode === "tokens" ? limit * BYTES_PER_TOKEN : limit);
+  const totalBytes = Buffer.byteLength(text, "utf8");
+  const originalTokens = Math.ceil(totalBytes / BYTES_PER_TOKEN);
+  const originalLines = text.length === 0 ? 0 : text.split("\n").length;
+  if (totalBytes <= byteBudget) {
+    return { text, truncated: false, originalTokens, originalLines, truncatedTokens: 0 };
+  }
+  const headBudget = Math.floor(byteBudget / 2);
+  const head = headSlice(text, headBudget);
+  const tail = tailSlice(text, byteBudget - headBudget);
+  const keptBytes = Buffer.byteLength(head, "utf8") + Buffer.byteLength(tail, "utf8");
+  const truncatedTokens = Math.ceil((totalBytes - keptBytes) / BYTES_PER_TOKEN);
+  return {
+    text: `${head}
+\u2026${truncatedTokens} tokens truncated\u2026
+${tail}`,
+    truncated: true,
+    originalTokens,
+    originalLines,
+    truncatedTokens
+  };
+}
+function formatTruncated(text, policy = {}) {
+  const initial = truncateMiddle(text, policy);
+  if (!initial.truncated)
+    return initial.text;
+  const limit = policy.limit ?? DEFAULT_TOOL_OUTPUT_TOKENS;
+  const mode = policy.mode ?? "tokens";
+  const byteBudget = Math.max(0, mode === "tokens" ? limit * BYTES_PER_TOKEN : limit);
+  const header = [
+    `Warning: truncated output (original token count: ${initial.originalTokens})`,
+    `Total output lines: ${initial.originalLines}`,
+    ""
+  ].join("\n");
+  const headerBytes = Buffer.byteLength(header, "utf8");
+  if (headerBytes >= byteBudget)
+    return headSlice(header, byteBudget);
+  let bodyBudget = byteBudget - headerBytes;
+  let body = truncateMiddle(text, { mode: "bytes", limit: bodyBudget });
+  let rendered = `${header}
+${body.text}`;
+  while (Buffer.byteLength(rendered, "utf8") > byteBudget && bodyBudget > 0) {
+    bodyBudget = Math.max(0, bodyBudget - (Buffer.byteLength(rendered, "utf8") - byteBudget));
+    body = truncateMiddle(text, { mode: "bytes", limit: bodyBudget });
+    rendered = `${header}
+${body.text}`;
+  }
+  return Buffer.byteLength(rendered, "utf8") <= byteBudget ? rendered : headSlice(rendered, byteBudget);
+}
+
+export {
+  truncateMiddle,
+  formatTruncated
+};