@zhijiewang/openharness 2.25.0 → 2.26.0

package/dist/Tool.d.ts

@@ -8,6 +8,7 @@ import type { PermissionMode, RiskLevel } from "./types/permissions.js";
 export type ToolResult = {
     output: string;
     isError: boolean;
+    outputType?: "json" | "markdown" | "image" | "plain";
 };
 export type ToolContext = {
     workingDir: string;

package/dist/renderer/json-tree.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Static JSON tree renderer for tool output.
+ * Theme-colored, indented, depth-truncated, line-truncated.
+ */
+import type { CellGrid } from "./cells.js";
+export declare function resetJsonStyleCache(): void;
+export declare function renderJsonTree(grid: CellGrid, row: number, col: number, value: unknown, width: number, opts: {
+    maxLines: number;
+    limit: number;
+}): number;
+//# sourceMappingURL=json-tree.d.ts.map

package/dist/renderer/json-tree.js

@@ -0,0 +1,194 @@
+/**
+ * Static JSON tree renderer for tool output.
+ * Theme-colored, indented, depth-truncated, line-truncated.
+ */
+import { getTheme } from "../utils/theme-data.js";
+const s = (fg, bold = false, dim = false) => ({ fg, bg: null, bold, dim, underline: false });
+const MAX_DEPTH = 3;
+let S_KEY;
+let S_STRING;
+let S_NUMBER;
+let S_PUNCT;
+let S_TRUNC;
+let _stylesInit = false;
+export function resetJsonStyleCache() {
+    _stylesInit = false;
+}
+function ensureStyles() {
+    if (_stylesInit)
+        return;
+    _stylesInit = true;
+    const t = getTheme();
+    S_KEY = s(t.user);
+    S_STRING = s(t.success);
+    S_NUMBER = s(t.tool);
+    S_PUNCT = s(null, false, true);
+    S_TRUNC = s(null, false, true);
+}
+export function renderJsonTree(grid, row, col, value, width, opts) {
+    ensureStyles();
+    const lines = [];
+    const seen = new Set();
+    emitValue(lines, value, 0, 0, seen);
+    const maxRows = Math.min(opts.limit - row, opts.maxLines);
+    if (maxRows <= 0)
+        return 0;
+    const truncated = lines.length > maxRows;
+    const visible = truncated ? lines.slice(0, maxRows - 1) : lines;
+    let r = row;
+    for (const line of visible) {
+        if (r >= opts.limit)
+            break;
+        let c = col + line.indent;
+        for (const tok of line.tokens) {
+            for (let i = 0; i < tok.text.length; i++) {
+                if (c >= col + width)
+                    break;
+                grid.setCell(r, c, tok.text[i], tok.style);
+                c++;
+            }
+        }
+        r++;
+    }
+    if (truncated && r < opts.limit) {
+        const footer = `… (${lines.length} lines total)`;
+        grid.writeText(r, col, footer.slice(0, width), S_TRUNC);
+        r++;
+    }
+    return r - row;
+}
+function emitValue(out, value, indent, depth, seen) {
+    if (value === null) {
+        out.push({ indent, tokens: [{ text: "null", style: S_NUMBER }] });
+        return;
+    }
+    if (typeof value === "string") {
+        out.push({ indent, tokens: [{ text: JSON.stringify(value), style: S_STRING }] });
+        return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+        out.push({ indent, tokens: [{ text: String(value), style: S_NUMBER }] });
+        return;
+    }
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            out.push({ indent, tokens: [{ text: "[]", style: S_PUNCT }] });
+            return;
+        }
+        if (depth >= MAX_DEPTH) {
+            out.push({ indent, tokens: [{ text: `[${value.length} items]`, style: S_TRUNC }] });
+            return;
+        }
+        if (seen.has(value)) {
+            out.push({ indent, tokens: [{ text: "[Circular]", style: S_TRUNC }] });
+            return;
+        }
+        seen.add(value);
+        out.push({ indent, tokens: [{ text: "[", style: S_PUNCT }] });
+        for (let i = 0; i < value.length; i++) {
+            emitValueAsItem(out, value[i], indent + 2, depth + 1, seen, i < value.length - 1);
+        }
+        out.push({ indent, tokens: [{ text: "]", style: S_PUNCT }] });
+        seen.delete(value);
+        return;
+    }
+    if (typeof value === "object") {
+        const entries = Object.entries(value);
+        if (entries.length === 0) {
+            out.push({ indent, tokens: [{ text: "{}", style: S_PUNCT }] });
+            return;
+        }
+        if (depth >= MAX_DEPTH) {
+            out.push({ indent, tokens: [{ text: "{…}", style: S_TRUNC }] });
+            return;
+        }
+        if (seen.has(value)) {
+            out.push({ indent, tokens: [{ text: "[Circular]", style: S_TRUNC }] });
+            return;
+        }
+        seen.add(value);
+        out.push({ indent, tokens: [{ text: "{", style: S_PUNCT }] });
+        for (let i = 0; i < entries.length; i++) {
+            const [k, v] = entries[i];
+            emitObjectEntry(out, k, v, indent + 2, depth + 1, seen, i < entries.length - 1);
+        }
+        out.push({ indent, tokens: [{ text: "}", style: S_PUNCT }] });
+        seen.delete(value);
+        return;
+    }
+    out.push({ indent, tokens: [{ text: String(value), style: S_TRUNC }] });
+}
+function emitValueAsItem(out, value, indent, depth, seen, trailingComma) {
+    const before = out.length;
+    emitValue(out, value, indent, depth, seen);
+    if (trailingComma && out.length > before) {
+        const last = out[out.length - 1];
+        last.tokens.push({ text: ",", style: S_PUNCT });
+    }
+}
+function emitObjectEntry(out, key, value, indent, depth, seen, trailingComma) {
+    const keyTok = { text: JSON.stringify(key), style: S_KEY };
+    const colonTok = { text: ": ", style: S_PUNCT };
+    // Inline primitives onto the same line as the key.
+    if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        const valStyle = typeof value === "string" ? S_STRING : S_NUMBER;
+        const valText = typeof value === "string" ? JSON.stringify(value) : String(value);
+        const tokens = [keyTok, colonTok, { text: valText, style: valStyle }];
+        if (trailingComma)
+            tokens.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens });
+        return;
+    }
+    // Empty container inlines too: "key": {} / "key": []
+    if (Array.isArray(value) && value.length === 0) {
+        const tokens = [keyTok, colonTok, { text: "[]", style: S_PUNCT }];
+        if (trailingComma)
+            tokens.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens });
+        return;
+    }
+    if (value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) {
+        const tokens = [keyTok, colonTok, { text: "{}", style: S_PUNCT }];
+        if (trailingComma)
+            tokens.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens });
+        return;
+    }
+    // Depth-collapsed container also inlines.
+    if (depth >= MAX_DEPTH) {
+        const collapsed = Array.isArray(value) ? `[${value.length} items]` : "{…}";
+        out.push({ indent, tokens: [keyTok, colonTok, { text: collapsed, style: S_TRUNC }] });
+        return;
+    }
+    // Circular reference: render inline, no descent.
+    if (seen.has(value)) {
+        const circ = [keyTok, colonTok, { text: "[Circular]", style: S_TRUNC }];
+        if (trailingComma)
+            circ.push({ text: ",", style: S_PUNCT });
+        out.push({ indent, tokens: circ });
+        return;
+    }
+    // Non-empty container: open bracket on key line, body indented, close bracket on its own line.
+    const opener = Array.isArray(value) ? "[" : "{";
+    const closer = Array.isArray(value) ? "]" : "}";
+    out.push({ indent, tokens: [keyTok, colonTok, { text: opener, style: S_PUNCT }] });
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+            emitValueAsItem(out, value[i], indent + 2, depth + 1, seen, i < value.length - 1);
+        }
+    }
+    else {
+        const entries = Object.entries(value);
+        for (let i = 0; i < entries.length; i++) {
+            const [ck, cv] = entries[i];
+            emitObjectEntry(out, ck, cv, indent + 2, depth + 1, seen, i < entries.length - 1);
+        }
+    }
+    seen.delete(value);
+    const closerTokens = [{ text: closer, style: S_PUNCT }];
+    if (trailingComma)
+        closerTokens.push({ text: ",", style: S_PUNCT });
+    out.push({ indent, tokens: closerTokens });
+}
+//# sourceMappingURL=json-tree.js.map

package/dist/renderer/layout-sections.js

@@ -4,7 +4,7 @@
  */
 import { getTheme } from "../utils/theme-data.js";
 import { renderDiff } from "./diff.js";
-import { isImageOutput, renderImageInline } from "./image.js";
+import { renderToolOutput } from "./output-renderer.js";
 import { deriveSpinnerLabel } from "./spinner-label.js";
 import { toolColor } from "./tool-color.js";
 // ── Style constants ──
@@ -195,26 +195,12 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
             }
         }
         if (tc.output && tc.status !== "running" && isExpanded && r < limit) {
-            if (isImageOutput(tc.output)) {
-                const label = renderImageInline(tc.output);
-                grid.writeText(r, 6, label.slice(0, w - 8), S_DIM);
-                r++;
-                continue;
-            }
-            const outLines = tc.output.split("\n");
-            const maxOut = 20;
-            const showLines = outLines.slice(0, maxOut);
-            for (const line of showLines) {
-                if (r >= limit)
-                    break;
-                const lineStyle = tc.status === "error" ? S_ERROR : S_DIM;
-                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), lineStyle, w - 2);
-                r++;
-            }
-            if (outLines.length > maxOut && r < limit) {
-                grid.writeText(r, 6, `… (${outLines.length} lines total)`, S_DIM);
-                r++;
-            }
+            const consumed = renderToolOutput(grid, r, 6, tc.output, tc.outputType, w - 8, {
+                status: tc.status,
+                maxLines: 20,
+                limit,
+            });
+            r += consumed;
         }
     }
     return r;

package/dist/renderer/layout.d.ts

@@ -12,6 +12,7 @@ export type ToolCallInfo = {
     toolName: string;
     status: "running" | "done" | "error";
     output?: string;
+    outputType?: "json" | "markdown" | "image" | "plain";
     args?: string;
     isAgent?: boolean;
     agentDescription?: string;

package/dist/renderer/output-renderer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Tool output dispatcher.
+ *
+ * Detection chain (stops at first hit):
+ *   1. __IMAGE__: sentinel  -> renderImageInline
+ *   2. outputType="json"    -> renderJsonTree (fallback to plain on parse fail)
+ *   3. outputType="markdown" -> renderMarkdown
+ *   4. outputType="plain"|"image" -> renderPlain (image without sentinel is malformed)
+ *   5. heuristic JSON parse -> renderJsonTree
+ *   6. heuristic markdown   -> renderMarkdown
+ *   7. fallback             -> renderPlain
+ */
+import type { CellGrid } from "./cells.js";
+export type OutputType = "json" | "markdown" | "image" | "plain";
+export declare function renderToolOutput(grid: CellGrid, row: number, col: number, output: string, outputType: OutputType | undefined, width: number, opts: {
+    status: "running" | "done" | "error";
+    maxLines: number;
+    limit: number;
+}): number;
+export declare function tryParseJson(s: string): {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+};
+export declare function looksLikeMarkdown(s: string): boolean;
+//# sourceMappingURL=output-renderer.d.ts.map

package/dist/renderer/output-renderer.js

@@ -0,0 +1,89 @@
+/**
+ * Tool output dispatcher.
+ *
+ * Detection chain (stops at first hit):
+ *   1. __IMAGE__: sentinel  -> renderImageInline
+ *   2. outputType="json"    -> renderJsonTree (fallback to plain on parse fail)
+ *   3. outputType="markdown" -> renderMarkdown
+ *   4. outputType="plain"|"image" -> renderPlain (image without sentinel is malformed)
+ *   5. heuristic JSON parse -> renderJsonTree
+ *   6. heuristic markdown   -> renderMarkdown
+ *   7. fallback             -> renderPlain
+ */
+import { isImageOutput, renderImageInline } from "./image.js";
+import { renderJsonTree } from "./json-tree.js";
+import { renderMarkdown } from "./markdown.js";
+const S_DIM = { fg: null, bg: null, bold: false, dim: true, underline: false };
+const S_ERROR = { fg: "red", bg: null, bold: false, dim: false, underline: false };
+export function renderToolOutput(grid, row, col, output, outputType, width, opts) {
+    // 1. Image sentinel always wins.
+    if (isImageOutput(output)) {
+        if (row >= opts.limit)
+            return 0;
+        const label = renderImageInline(output);
+        grid.writeText(row, col, label.slice(0, width), S_DIM);
+        return 1;
+    }
+    // 2-4. Typed dispatch.
+    if (outputType === "json") {
+        const parsed = tryParseJson(output);
+        if (parsed.ok)
+            return renderJsonTree(grid, row, col, parsed.value, width, { maxLines: opts.maxLines, limit: opts.limit });
+        return renderPlain(grid, row, col, output, width, opts);
+    }
+    if (outputType === "markdown") {
+        return renderMarkdown(grid, row, col, output, width, false, opts.limit);
+    }
+    if (outputType === "plain" || outputType === "image") {
+        return renderPlain(grid, row, col, output, width, opts);
+    }
+    // 5-7. Heuristic fallback (outputType undefined).
+    const json = tryParseJson(output);
+    if (json.ok)
+        return renderJsonTree(grid, row, col, json.value, width, { maxLines: opts.maxLines, limit: opts.limit });
+    if (looksLikeMarkdown(output))
+        return renderMarkdown(grid, row, col, output, width, false, opts.limit);
+    return renderPlain(grid, row, col, output, width, opts);
+}
+export function tryParseJson(s) {
+    const t = s.trimStart();
+    if (t[0] !== "{" && t[0] !== "[")
+        return { ok: false };
+    try {
+        return { ok: true, value: JSON.parse(t) };
+    }
+    catch {
+        return { ok: false };
+    }
+}
+const FENCED_RE = /```[\w]*\r?\n/;
+const TABLE_RE = /^\|.+\|\s*\n\|[\s:|-]+\|/m;
+const HEADING_RE = /^#{1,6}\s+\S/gm;
+export function looksLikeMarkdown(s) {
+    if (FENCED_RE.test(s))
+        return true;
+    if (TABLE_RE.test(s))
+        return true;
+    const headings = s.match(HEADING_RE);
+    if (headings && headings.length >= 2)
+        return true;
+    return false;
+}
+function renderPlain(grid, row, col, output, width, opts) {
+    const outLines = output.split("\n");
+    const showLines = outLines.slice(0, opts.maxLines);
+    const lineStyle = opts.status === "error" ? S_ERROR : S_DIM;
+    let r = row;
+    for (const line of showLines) {
+        if (r >= opts.limit)
+            break;
+        grid.writeTextWithLinks(r, col, line.slice(0, width), lineStyle, col + width);
+        r++;
+    }
+    if (outLines.length > opts.maxLines && r < opts.limit) {
+        grid.writeText(r, col, `… (${outLines.length} lines total)`.slice(0, width), S_DIM);
+        r++;
+    }
+    return r - row;
+}
+//# sourceMappingURL=output-renderer.js.map

package/dist/repl.js

@@ -21,6 +21,7 @@ import { isTrusted, trustSystemActive } from "./harness/trust.js";
 import { query } from "./query/index.js";
 import { resetDiffStyleCache } from "./renderer/diff.js";
 import { TerminalRenderer } from "./renderer/index.js";
+import { resetJsonStyleCache } from "./renderer/json-tree.js";
 import { resetStyleCache } from "./renderer/layout.js";
 import { resetMdStyleCache } from "./renderer/markdown.js";
 import { createAssistantMessage, createInfoMessage, createMessage } from "./types/message.js";
@@ -28,6 +29,8 @@ import { formatTokenCount } from "./utils/format.js";
 import { fuzzyFilter } from "./utils/fuzzy.js";
 import { setActiveTheme } from "./utils/theme-data.js";
 import { formatToolArgs, summarizeToolOutput } from "./utils/tool-summary.js";
+/** Per-call cap on rendered tool output in renderer state. Sized to fit typical JSON/markdown files (16 KiB) so JSON.parse / markdown detection works on real content; larger outputs render truncated. */
+const TOOL_OUTPUT_RENDER_CAP = 16384;
 export async function startREPL(config) {
     if (config.theme)
         setActiveTheme(config.theme);
@@ -814,6 +817,7 @@ export async function startREPL(config) {
             resetStyleCache();
             resetMdStyleCache();
             resetDiffStyleCache();
+            resetJsonStyleCache();
             // Persist theme to config
             try {
                 const cfg = cachedConfig ?? {
@@ -980,7 +984,8 @@ export async function startREPL(config) {
                         renderer.setToolCall(event.callId, {
                             toolName,
                             status: event.isError ? "error" : "done",
-                            output: event.output?.slice(0, 500),
+                            output: event.output?.slice(0, TOOL_OUTPUT_RENDER_CAP),
+                            outputType: event.outputType,
                             args: prevTc?.args,
                             resultSummary: event.output ? summarizeToolOutput(event.output) : undefined,
                             startedAt: prevTc?.startedAt,

package/dist/tools/FileReadTool/index.js

@@ -10,6 +10,15 @@ const inputSchema = z.object({
 const DEFAULT_LIMIT = 2000;
 const IMAGE_EXTENSIONS = new Set([".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp", ".svg"]);
 const NOTEBOOK_EXTENSION = ".ipynb";
+const MARKDOWN_EXTENSIONS = new Set([".md", ".markdown"]);
+const JSON_EXTENSIONS = new Set([".json"]);
+function outputTypeFromExt(ext) {
+    if (JSON_EXTENSIONS.has(ext))
+        return "json";
+    if (MARKDOWN_EXTENSIONS.has(ext))
+        return "markdown";
+    return "plain";
+}
 function parsePageRange(pages) {
     const result = [];
     for (const part of pages.split(",")) {
@@ -101,7 +110,7 @@ export const FileReadTool = {
                     }
                 }
                 if (pageTexts.length > 0) {
-                    return { output: pageTexts.join("\n\n"), isError: false };
+                    return { output: pageTexts.join("\n\n"), isError: false, outputType: "plain" };
                 }
                 // Fallback: return as base64 for multimodal analysis
                 const base64 = buffer.toString("base64");
@@ -128,7 +137,7 @@ export const FileReadTool = {
                         }
                     }
                 }
-                return { output: parts.join("\n\n"), isError: false };
+                return { output: parts.join("\n\n"), isError: false, outputType: "plain" };
             }
             // Default: text file
             const content = await fs.readFile(filePath, "utf-8");
@@ -143,7 +152,7 @@ export const FileReadTool = {
             if (shown < total) {
                 result += `\n\n(Showing lines ${offset + 1}-${offset + shown} of ${total})`;
             }
-            return { output: result, isError: false };
+            return { output: result, isError: false, outputType: outputTypeFromExt(ext) };
         }
         catch (err) {
             if (err.code === "ENOENT") {

package/dist/tools/WebFetchTool/index.js

@@ -70,7 +70,7 @@ export const WebFetchTool = {
                 signal: AbortSignal.timeout(30_000),
             });
             // Re-check host after redirect to prevent SSRF via open redirects
-            const finalUrl = new URL(response.url);
+            const finalUrl = new URL(response.url || input.url);
             if (isBlockedHost(finalUrl.hostname)) {
                 return { output: "Error: Redirect to private/internal host blocked.", isError: true };
             }
@@ -88,7 +88,10 @@ export const WebFetchTool = {
             if (text.length > MAX_OUTPUT) {
                 text = `${text.slice(0, MAX_OUTPUT)}\n... [truncated]`;
             }
-            return { output: text, isError: false };
+            const ct = contentType.toLowerCase();
+            const isJson = /^application\/(?:[a-z0-9.+-]+\+)?json\b/.test(ct);
+            const outputType = isJson ? "json" : ct.includes("text/markdown") ? "markdown" : "plain";
+            return { output: text, isError: false, outputType };
         }
         catch (err) {
             return { output: `Error fetching URL: ${err.message}`, isError: true };

package/dist/types/events.d.ts

@@ -20,6 +20,7 @@ export type ToolCallEnd = {
     readonly type: "tool_call_end";
     readonly callId: string;
     readonly output: string;
+    readonly outputType?: "json" | "markdown" | "image" | "plain";
     readonly isError: boolean;
 };
 export type PermissionRequest = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhijiewang/openharness",
-  "version": "2.25.0",
+  "version": "2.26.0",
   "description": "Open-source terminal coding agent. Works with any LLM.",
   "type": "module",
   "bin": {