llmist 17.2.1 → 17.3.0

package/dist/index.cjs

@@ -4660,6 +4660,9 @@ var init_create_gadget = __esm({
 });
 
 // src/gadgets/output-viewer.ts
+function pluralize(count, singular, plural = `${singular}s`) {
+  return count === 1 ? singular : plural;
+}
 function applyPattern(lines, pattern) {
   const regex = new RegExp(pattern.regex);
   if (!pattern.include) {
@@ -4684,80 +4687,169 @@ function applyPatterns(lines, patterns) {
   }
   return result;
 }
-function applyLineLimit(lines, limit) {
+function parseLimitWindow(limit) {
   const trimmed = limit.trim();
   if (trimmed.endsWith("-") && !trimmed.startsWith("-")) {
     const n = parseInt(trimmed.slice(0, -1), 10);
-    if (!isNaN(n) && n > 0) {
-      return lines.slice(0, n);
+    if (!Number.isNaN(n) && n > 0) {
+      return { kind: "first", count: n };
     }
   }
   if (trimmed.startsWith("-") && !trimmed.includes("-", 1)) {
     const n = parseInt(trimmed, 10);
-    if (!isNaN(n) && n < 0) {
-      return lines.slice(n);
+    if (!Number.isNaN(n) && n < 0) {
+      return { kind: "last", count: Math.abs(n) };
     }
   }
   const rangeMatch = trimmed.match(/^(\d+)-(\d+)$/);
   if (rangeMatch) {
     const start = parseInt(rangeMatch[1], 10);
     const end = parseInt(rangeMatch[2], 10);
-    if (!isNaN(start) && !isNaN(end) && start > 0 && end >= start) {
-      return lines.slice(start - 1, end);
+    if (!Number.isNaN(start) && !Number.isNaN(end) && start > 0 && end >= start) {
+      return { kind: "range", start, end };
     }
   }
-  return lines;
+  return null;
+}
+function applyLineLimit(lines, limit) {
+  const window = parseLimitWindow(limit);
+  if (!window) return lines;
+  switch (window.kind) {
+    case "first":
+      return lines.slice(0, window.count);
+    case "last":
+      return lines.slice(-window.count);
+    case "range":
+      return lines.slice(window.start - 1, window.end);
+  }
+}
+function applyCharacterLimit(content, limit, maxOutputChars) {
+  const total = content.length;
+  if (total === 0) {
+    return { text: "", start: 0, end: 0, total: 0, truncatedBySize: false, hasMoreAfter: false };
+  }
+  let startIndex = 0;
+  let endExclusive = total;
+  const window = limit ? parseLimitWindow(limit) : null;
+  if (window) {
+    switch (window.kind) {
+      case "first":
+        endExclusive = Math.min(window.count, total);
+        break;
+      case "last":
+        startIndex = Math.max(0, total - window.count);
+        break;
+      case "range":
+        startIndex = Math.min(window.start - 1, total);
+        endExclusive = Math.min(window.end, total);
+        break;
+    }
+  }
+  let text3 = content.slice(startIndex, endExclusive);
+  let truncatedBySize = false;
+  if (text3.length > maxOutputChars) {
+    text3 = window?.kind === "last" ? text3.slice(-maxOutputChars) : text3.slice(0, maxOutputChars);
+    if (window?.kind === "last") {
+      startIndex = endExclusive - text3.length;
+    }
+    truncatedBySize = true;
+  }
+  return {
+    text: text3,
+    start: text3.length === 0 ? 0 : startIndex + 1,
+    end: text3.length === 0 ? 0 : startIndex + text3.length,
+    total,
+    truncatedBySize,
+    hasMoreAfter: startIndex + text3.length < total
+  };
+}
+function buildCharacterRangeHint(start, total) {
+  if (total <= 0 || start > total) return null;
+  const end = Math.min(total, start + CHARACTER_HINT_WINDOW - 1);
+  return `${start}-${end}`;
+}
+function buildCharacterModeSuggestion(stored, opts = {}) {
+  const hint = buildCharacterRangeHint(opts.start ?? 1, stored.charCount);
+  const action = opts.removePatterns ? "Remove patterns and then try" : "Try";
+  const lineLabel = pluralize(stored.lineCount, "line");
+  return `This output is dense (${stored.lineCount.toLocaleString()} ${lineLabel}; longest line ${stored.maxLineLength.toLocaleString()} chars). ${action} mode: "character"` + (hint ? `, limit: "${hint}"` : "") + ".";
+}
+function shouldSuggestCharacterMode(stored, maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS) {
+  return stored.lineCount <= 3 && (stored.maxLineLength > maxOutputChars || stored.maxLineLength >= DENSE_LINE_THRESHOLD);
 }
 function createGadgetOutputViewer(store, maxOutputChars = DEFAULT_MAX_OUTPUT_CHARS) {
   return createGadget({
     name: "GadgetOutputViewer",
-    description: "View stored output from gadgets that returned too much data. Use patterns to filter lines (like grep) and limit to control output size. Patterns are applied first in order, then the limit is applied to the result.",
+    description: 'View stored output from gadgets that returned too much data. Use mode "line" for grep-like filtering and mode "character" for raw chunked browsing when the output is dense or effectively single-line. Patterns work only in line mode.',
     schema: import_zod.z.object({
       id: import_zod.z.string().describe("ID of the stored output (from the truncation message)"),
+      mode: import_zod.z.enum(["line", "character"]).default("line").describe(
+        'Browse by "line" (supports patterns) or by "character" (raw windows for dense output).'
+      ),
       patterns: import_zod.z.array(patternSchema).optional().describe(
-        "Filter patterns applied in order (like piping through grep). Each pattern can include or exclude lines with optional before/after context."
+        'Line-mode filter patterns applied in order (like piping through grep). Not supported in mode "character".'
       ),
       limit: import_zod.z.string().optional().describe(
-        "Line range to return after filtering. Formats: '100-' (first 100), '-25' (last 25), '50-100' (lines 50-100)"
+        `Pagination window. In mode "line" it is a line range; in mode "character" it is a character range. Formats: "100-" (first 100), "-25" (last 25), "50-100" (inclusive range).`
       )
     }),
     examples: [
       {
         comment: "View first 50 lines of stored output",
-        params: { id: "Search_abc12345", limit: "50-" }
+        params: { id: "Search_abc12345", mode: "line", limit: "50-" }
       },
       {
         comment: "Filter for error lines with context",
         params: {
           id: "Search_abc12345",
+          mode: "line",
           patterns: [{ regex: "error|Error|ERROR", include: true, before: 2, after: 5 }]
         }
       },
       {
-        comment: "Exclude blank lines, then show first 100",
+        comment: "Exclude blank lines, then show first 100 lines",
         params: {
           id: "Search_abc12345",
+          mode: "line",
           patterns: [{ regex: "^\\s*$", include: false, before: 0, after: 0 }],
           limit: "100-"
         }
       },
       {
-        comment: "Chain filters: find TODOs, exclude tests, limit to 50 lines",
+        comment: "Browse the raw output by character window when line mode is too dense",
         params: {
           id: "Search_abc12345",
-          patterns: [
-            { regex: "TODO", include: true, before: 1, after: 1 },
-            { regex: "test|spec", include: false, before: 0, after: 0 }
-          ],
-          limit: "50-"
+          mode: "character",
+          limit: "1-2000"
         }
       }
     ],
-    execute: ({ id, patterns, limit }) => {
+    execute: ({ id, mode, patterns, limit }) => {
       const stored = store.get(id);
       if (!stored) {
         return `Error: No stored output with id "${id}". Available IDs: ${store.getIds().join(", ") || "(none)"}`;
       }
+      const suggestCharacterMode = shouldSuggestCharacterMode(stored, maxOutputChars);
+      if (mode === "character") {
+        if (patterns && patterns.length > 0) {
+          return 'Error: patterns are only supported in mode "line". Remove patterns or switch back to mode: "line".';
+        }
+        const window = applyCharacterLimit(stored.content, limit, maxOutputChars);
+        if (window.total === 0) {
+          return "[Mode: character | Output is empty]";
+        }
+        const header2 = [
+          `[Mode: character | Showing chars ${window.start.toLocaleString()}-${window.end.toLocaleString()} of ${window.total.toLocaleString()}${window.truncatedBySize ? " (truncated due to viewer size limit)" : ""}]`
+        ];
+        if (window.hasMoreAfter) {
+          const nextRange = buildCharacterRangeHint(window.end + 1, window.total);
+          if (nextRange) {
+            header2.push(`[Next chunk: mode: "character", limit: "${nextRange}"]`);
+          }
+        }
+        return `${header2.join("\n")}
+${window.text}`;
+      }
       let lines = stored.content.split("\n");
       if (patterns && patterns.length > 0) {
         lines = applyPatterns(
@@ -4773,55 +4865,77 @@ function createGadgetOutputViewer(store, maxOutputChars = DEFAULT_MAX_OUTPUT_CHA
       if (limit) {
         lines = applyLineLimit(lines, limit);
       }
-      let output = lines.join("\n");
       const totalLines = stored.lineCount;
+      const totalLineLabel = pluralize(totalLines, "line");
       const returnedLines = lines.length;
       if (returnedLines === 0) {
-        return `No lines matched the filters. Original output had ${totalLines} lines.`;
+        const base = `No lines matched the filters. Original output had ${totalLines.toLocaleString()} lines.`;
+        if (!suggestCharacterMode) return base;
+        return `${base} ${buildCharacterModeSuggestion(stored, {
+          removePatterns: Boolean(patterns && patterns.length > 0)
+        })}`;
       }
+      let output = lines.join("\n");
       let truncatedBySize = false;
       let linesIncluded = returnedLines;
+      let clippedFirstLine = false;
       if (output.length > maxOutputChars) {
         truncatedBySize = true;
         let truncatedOutput = "";
         linesIncluded = 0;
         for (const line of lines) {
-          if (truncatedOutput.length + line.length + 1 > maxOutputChars) break;
-          truncatedOutput += line + "\n";
+          const addition = linesIncluded === 0 ? line : `
+${line}`;
+          if (truncatedOutput.length + addition.length > maxOutputChars) break;
+          truncatedOutput += addition;
           linesIncluded++;
         }
+        if (linesIncluded === 0) {
+          clippedFirstLine = true;
+          linesIncluded = 1;
+          truncatedOutput = lines[0].slice(0, maxOutputChars);
+        }
         output = truncatedOutput;
       }
       let header;
-      if (truncatedBySize) {
+      if (clippedFirstLine) {
+        header = `[Mode: line | Showing 1 partial line of ${totalLines.toLocaleString()} ${totalLineLabel} (the selected line exceeds the viewer size limit)]
+`;
+      } else if (truncatedBySize) {
         const remainingLines = returnedLines - linesIncluded;
-        header = `[Showing ${linesIncluded} of ${totalLines} lines (truncated due to size limit)]
-[... ${remainingLines.toLocaleString()} more lines. Use limit parameter to paginate, e.g., limit: "${linesIncluded + 1}-${linesIncluded + 200}"]
+        header = `[Mode: line | Showing ${linesIncluded.toLocaleString()} of ${totalLines.toLocaleString()} ${totalLineLabel} (truncated due to size limit)]
+[... ${remainingLines.toLocaleString()} more ${pluralize(remainingLines, "line")}. Use limit parameter to paginate, e.g., limit: "${linesIncluded + 1}-${linesIncluded + 200}"]
 `;
       } else if (returnedLines < totalLines) {
-        header = `[Showing ${returnedLines} of ${totalLines} lines]
+        header = `[Mode: line | Showing ${returnedLines.toLocaleString()} of ${totalLines.toLocaleString()} ${totalLineLabel}]
 `;
       } else {
-        header = `[Showing all ${totalLines} lines]
+        header = `[Mode: line | Showing all ${totalLines.toLocaleString()} ${totalLineLabel}]
 `;
       }
-      return header + output;
+      const footer = suggestCharacterMode || clippedFirstLine ? `
+[Tip: ${buildCharacterModeSuggestion(stored, {
+        removePatterns: Boolean(patterns && patterns.length > 0)
+      })}]` : "";
+      return header + output + footer;
     }
   });
 }
-var import_zod, patternSchema, DEFAULT_MAX_OUTPUT_CHARS;
+var import_zod, DEFAULT_MAX_OUTPUT_CHARS, CHARACTER_HINT_WINDOW, DENSE_LINE_THRESHOLD, patternSchema;
 var init_output_viewer = __esm({
   "src/gadgets/output-viewer.ts"() {
     "use strict";
     import_zod = require("zod");
     init_create_gadget();
+    DEFAULT_MAX_OUTPUT_CHARS = 76800;
+    CHARACTER_HINT_WINDOW = 2e3;
+    DENSE_LINE_THRESHOLD = 4e3;
     patternSchema = import_zod.z.object({
       regex: import_zod.z.string().describe("Regular expression to match"),
       include: import_zod.z.boolean().default(true).describe("true = keep matching lines, false = exclude matching lines"),
       before: import_zod.z.number().int().min(0).default(0).describe("Context lines before each match (like grep -B)"),
       after: import_zod.z.number().int().min(0).default(0).describe("Context lines after each match (like grep -A)")
     });
-    DEFAULT_MAX_OUTPUT_CHARS = 76800;
   }
 });
 
@@ -4843,12 +4957,15 @@ var init_gadget_output_store = __esm({
       store(gadgetName, content) {
         const id = this.generateId(gadgetName);
         const encoder = new TextEncoder();
+        const lines = content.split("\n");
         const stored = {
           id,
           gadgetName,
           content,
+          charCount: content.length,
           byteSize: encoder.encode(content).length,
-          lineCount: content.split("\n").length,
+          lineCount: lines.length,
+          maxLineLength: lines.reduce((max, line) => Math.max(max, line.length), 0),
           timestamp: /* @__PURE__ */ new Date()
         };
         this.outputs.set(id, stored);
@@ -4952,16 +5069,20 @@ var init_output_limit_manager = __esm({
           }
           if (result.length > this.charLimit) {
             const id = this.outputStore.store(ctx.gadgetName, result);
-            const lines = result.split("\n").length;
-            const bytes = new TextEncoder().encode(result).length;
+            const stored = this.outputStore.get(id);
+            const lines = stored?.lineCount ?? result.split("\n").length;
+            const bytes = stored?.byteSize ?? new TextEncoder().encode(result).length;
+            const denseSuggestion = stored && shouldSuggestCharacterMode(stored, this.charLimit) ? ` ${buildCharacterModeSuggestion(stored)}` : "";
             this.logger.info("Gadget output exceeded limit, stored for browsing", {
               gadgetName: ctx.gadgetName,
               outputId: id,
               bytes,
               lines,
+              charCount: stored?.charCount,
+              maxLineLength: stored?.maxLineLength,
               charLimit: this.charLimit
             });
-            return `[Gadget "${ctx.gadgetName}" returned too much data: ${bytes.toLocaleString()} bytes, ${lines.toLocaleString()} lines. Use GadgetOutputViewer with id "${id}" to read it]`;
+            return `[Gadget "${ctx.gadgetName}" returned too much data: ${bytes.toLocaleString()} bytes, ${lines.toLocaleString()} lines. Use GadgetOutputViewer with id "${id}" to read it.]` + denseSuggestion;
           }
           return result;
         };