@zhijiewang/openharness 2.22.1 → 2.24.0

package/dist/renderer/index.js

@@ -3,6 +3,7 @@
  * Flushed messages flow to scrollback; live area is rewritten in-place
  * right after the scrollback content each frame (no absolute positioning gap).
  */
+import { recordApproval } from "../harness/approvals.js";
 import { getTheme } from "../utils/theme-data.js";
 import { summarizeToolArgs } from "../utils/tool-summary.js";
 import { CellGrid } from "./cells.js";
@@ -62,6 +63,7 @@ export class TerminalRenderer {
             questionPrompt: null,
             autocomplete: [],
             autocompleteDescriptions: [],
+            autocompleteCategories: [],
             autocompleteIndex: -1,
             manualScroll: 0,
             codeBlocksExpanded: false,
@@ -195,9 +197,10 @@ export class TerminalRenderer {
         this.state.bannerLines = lines;
         this.scheduleRender();
     }
-    setAutocomplete(suggestions, index, descriptions) {
+    setAutocomplete(suggestions, index, descriptions, categories) {
         this.state.autocomplete = suggestions;
         this.state.autocompleteDescriptions = descriptions ?? [];
+        this.state.autocompleteCategories = categories ?? [];
         this.state.autocompleteIndex = index;
         this.scheduleRender();
     }
@@ -366,20 +369,48 @@ export class TerminalRenderer {
         this.animationCallback = handler;
     }
     // ── Input routing ──
-    /** Handle permission prompt keys (Y/N/D). Returns true if key was consumed. */
+    /**
+     * Handle permission prompt keys (Y/N/A/D).
+     * - Y / N: approve or deny this single call.
+     * - A: approve AND persist a `toolPermissions: { tool, action: "allow" }`
+     *   rule to `.oh/config.yaml` so future calls to this tool skip the prompt
+     *   entirely (audit U-A2). Mirrors Claude Code's "yes, don't ask again".
+     * - D: toggle inline diff (when available).
+     *
+     * Returns true if key was consumed.
+     */
     handlePermissionKey(key) {
         if (!this.permissionResolve)
             return false;
         const k = key.char.toLowerCase();
-        if (k === "y" || k === "n") {
+        if (k === "y" || k === "n" || k === "a") {
             const resolve = this.permissionResolve;
+            const toolName = this.state.permissionBox?.toolName;
             this.permissionResolve = null;
             this.permissionPrompt = null;
             this.state.permissionBox = null;
             this.state.permissionDiffVisible = false;
             this.state.permissionDiffInfo = null;
+            // Persist before resolving — any error in the write should not block
+            // the resolution. The persist call itself is no-op when no .oh/config.yaml
+            // exists (we don't auto-create on first interaction).
+            if (k === "a" && toolName) {
+                try {
+                    // Lazy import to avoid pulling config into the renderer bundle
+                    // for callers that don't trip the permission path.
+                    const { appendToolPermission } = require("../harness/config.js");
+                    appendToolPermission(toolName);
+                }
+                catch {
+                    /* persistence failure must not block the agent */
+                }
+                // Audit U-B5: log the "always allow this tool" rule promotion as a
+                // supplementary record so /permissions log shows the user upgraded
+                // from a one-shot allow to a persistent rule.
+                recordApproval({ tool: toolName, decision: "always", source: "user", cwd: process.cwd() });
+            }
             this.scheduleRender();
-            resolve(k === "y");
+            resolve(k === "y" || k === "a");
         }
         else if (k === "d" && this.state.permissionDiffInfo) {
             this.state.permissionDiffVisible = !this.state.permissionDiffVisible;
@@ -626,6 +657,8 @@ export class TerminalRenderer {
         if (this.state.statusLine)
             rows += 1;
         rows += this.state.autocomplete.length;
+        // Audit U-A3: one row per distinct category header.
+        rows += new Set((this.state.autocompleteCategories ?? []).filter((c) => c && c.length > 0)).size;
         if (this.state.permissionBox) {
             rows += 3;
             if (this.state.permissionDiffVisible && this.state.permissionDiffInfo)

package/dist/renderer/input.js

@@ -84,6 +84,13 @@ export function parseKey(data, offset) {
             return { event: key("", "pageup", seq.slice(0, 4)), consumed: 4 };
         if (seq.startsWith("\x1b[6~"))
             return { event: key("", "pagedown", seq.slice(0, 4)), consumed: 4 };
+        // Shift+Tab (xterm "backtab"): ESC [ Z. Used as a quick-toggle for
+        // permission mode (mirrors Claude Code's Shift+Tab cycler).
+        if (seq.startsWith("\x1b[Z"))
+            return {
+                event: { char: "", name: "tab", ctrl: false, meta: false, shift: true, sequence: seq.slice(0, 3) },
+                consumed: 3,
+            };
         // Shift+Arrow: ESC [ 1 ; 2 A/B/C/D
         if (seq.startsWith("\x1b[1;2A"))
             return {

package/dist/renderer/layout-sections.js

@@ -187,7 +187,7 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
             for (const line of visible) {
                 if (r >= limit)
                     break;
-                grid.writeText(r, 6, line.slice(0, w - 8), S_DIM);
+                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), S_DIM, w - 2);
                 r++;
             }
         }
@@ -205,7 +205,7 @@ export function renderToolCallsSection(state, grid, r, limit, opts) {
                 if (r >= limit)
                     break;
                 const lineStyle = tc.status === "error" ? S_ERROR : S_DIM;
-                grid.writeText(r, 6, line.slice(0, w - 8), lineStyle);
+                grid.writeTextWithLinks(r, 6, line.slice(0, w - 8), lineStyle, w - 2);
                 r++;
             }
             if (outLines.length > maxOut && r < limit) {
@@ -280,6 +280,13 @@ export function renderPermissionBoxSection(state, grid, nextRow, h, opts) {
         kc += 1;
         grid.writeText(nextRow, kc, "o", S_DIM);
         kc += 1;
+        grid.writeText(nextRow, kc, "  ", S_DIM);
+        kc += 2;
+        // Audit U-A2: "always allow this tool" — persists toolPermissions rule.
+        grid.writeText(nextRow, kc, "A", S_KEY_GREEN);
+        kc += 1;
+        grid.writeText(nextRow, kc, "lways", S_DIM);
+        kc += 5;
         if (state.permissionDiffInfo) {
             grid.writeText(nextRow, kc, "  ", S_DIM);
             kc += 2;
@@ -300,10 +307,12 @@ export function renderPermissionBoxSection(state, grid, nextRow, h, opts) {
         grid.writeText(nextRow, 1, "Y", S_KEY_GREEN);
         grid.writeText(nextRow, 2, "es  ", S_DIM);
         grid.writeText(nextRow, 6, "N", S_KEY_RED);
-        grid.writeText(nextRow, 7, "o", S_DIM);
+        grid.writeText(nextRow, 7, "o  ", S_DIM);
+        grid.writeText(nextRow, 10, "A", S_KEY_GREEN);
+        grid.writeText(nextRow, 11, "lways", S_DIM);
         if (state.permissionDiffInfo) {
-            grid.writeText(nextRow, 10, "D", S_KEY_CYAN);
-            grid.writeText(nextRow, 11, "iff", S_DIM);
+            grid.writeText(nextRow, 18, "D", S_KEY_CYAN);
+            grid.writeText(nextRow, 19, "iff", S_DIM);
         }
         nextRow++;
         if (state.permissionDiffVisible && state.permissionDiffInfo && nextRow + 3 < h) {
@@ -375,7 +384,20 @@ export function renderAutocompleteSection(state, grid, nextRow, limit, promptWid
     if (state.autocomplete.length === 0)
         return nextRow;
     const w = grid.width;
+    let lastCategory = "";
     for (let ai = 0; ai < state.autocomplete.length; ai++) {
+        if (nextRow >= limit)
+            break;
+        // Category header — draw whenever the category changes between entries.
+        // First-entry header is drawn when the category is non-empty (audit U-A3).
+        const cat = state.autocompleteCategories?.[ai] ?? "";
+        if (cat && cat !== lastCategory) {
+            if (nextRow >= limit)
+                break;
+            grid.writeText(nextRow, promptWidth, `── ${cat} ──`, S_DIM);
+            nextRow++;
+            lastCategory = cat;
+        }
         if (nextRow >= limit)
             break;
         const cmd = state.autocomplete[ai];

package/dist/renderer/layout.d.ts

@@ -57,6 +57,14 @@ export type LayoutState = {
     } | null;
     autocomplete: string[];
     autocompleteDescriptions: string[];
+    /**
+     * Optional category label per autocomplete entry (audit U-A3). When two
+     * adjacent entries differ in category, the renderer draws a header line
+     * before the second. Empty / missing category strings render flat (the
+     * pre-A3 behavior). Optional so older test fixtures + non-REPL callers
+     * don't need to thread an empty array.
+     */
+    autocompleteCategories?: string[];
     autocompleteIndex: number;
     manualScroll: number;
     codeBlocksExpanded: boolean;

package/dist/renderer/layout.js

@@ -28,7 +28,11 @@ export function rasterize(state, grid) {
     const questionHeight = state.questionPrompt ? 4 + (state.questionPrompt.options?.length ?? 0) : 0;
     const statusLineHeight = state.statusLine ? 1 : 0;
     const contextWarningHeight = state.contextWarning ? 1 : 0;
-    const autocompleteHeight = state.autocomplete.length;
+    // Autocomplete height — each entry is one row, plus one extra row per
+    // distinct category (audit U-A3 header lines). Distinct-category count
+    // is bounded by entry count so this stays cheap.
+    const distinctCategories = new Set((state.autocompleteCategories ?? []).filter((c) => c && c.length > 0));
+    const autocompleteHeight = state.autocomplete.length + distinctCategories.size;
     const inputLineCount = Math.min(5, (state.inputText.match(/\n/g)?.length ?? 0) + 1);
     const rawFooterHeight = Math.max(2 + inputLineCount + statusLineHeight + autocompleteHeight, companionHeight + 1) +
         permissionHeight +

package/dist/renderer/markdown.js

@@ -241,7 +241,10 @@ function parseInline(text, baseStyle) {
         // Link: [text](url)
         const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)]+)\)/);
         if (linkMatch) {
-            segments.push({ text: linkMatch[1], style: { ...baseStyle, underline: true, fg: "cyan" } });
+            segments.push({
+                text: linkMatch[1],
+                style: { ...baseStyle, underline: true, fg: "cyan", hyperlink: linkMatch[2] },
+            });
             segments.push({ text: ` (${linkMatch[2]})`, style: { ...baseStyle, dim: true } });
             remaining = remaining.slice(linkMatch[0].length);
             continue;

package/dist/repl.js

@@ -14,8 +14,10 @@ import { readOhConfig, writeOhConfig } from "./harness/config.js";
 import { estimateMessageTokens, getContextWarning } from "./harness/context-warning.js";
 import { CostTracker, estimateCost, getContextWindow } from "./harness/cost.js";
 import { createSession, loadSession, saveSession } from "./harness/session.js";
+import { runStatusLineScript } from "./harness/status-line-script.js";
 import { createStore } from "./harness/store.js";
 import { handleUserInput } from "./harness/submit-handler.js";
+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";
@@ -23,6 +25,7 @@ import { resetStyleCache } from "./renderer/layout.js";
 import { resetMdStyleCache } from "./renderer/markdown.js";
 import { createAssistantMessage, createInfoMessage, createMessage } from "./types/message.js";
 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";
 export async function startREPL(config) {
@@ -105,6 +108,9 @@ export async function startREPL(config) {
     let fastMode = s().fastMode;
     let acSuggestions = s().acSuggestions;
     let acDescriptions = s().acDescriptions;
+    // Audit U-A3: parallel category array for the picker. Local-only — no
+    // need to round-trip through `store` since no other consumer reads it.
+    let acCategories = [];
     let acIndex = s().acIndex;
     let acTokenStart = s().acTokenStart;
     let acIsPath = s().acIsPath;
@@ -128,13 +134,15 @@ export async function startREPL(config) {
     function updateAutocomplete() {
         acIsPath = false;
         if (inputText.startsWith("/") && inputText.length > 1 && !inputText.includes(" ")) {
-            // Slash command autocomplete
-            const prefix = inputText.slice(1).toLowerCase();
-            const entries = getCommandEntries()
-                .filter((e) => e.name.startsWith(prefix))
-                .slice(0, 5);
-            acSuggestions = entries.map((e) => e.name);
-            acDescriptions = entries.map((e) => e.description);
+            // Slash command autocomplete (audit U-B3): subsequence-match scoring,
+            // not a startsWith filter. Prefix matches still rank first via the
+            // bonus in `fuzzyScore`, but the user can type "gst" to surface
+            // "/git-status" or "perm" to surface "/permissions".
+            const query = inputText.slice(1);
+            const ranked = fuzzyFilter(query, getCommandEntries()).slice(0, 8);
+            acSuggestions = ranked.map((r) => r.entry.name);
+            acDescriptions = ranked.map((r) => r.entry.description);
+            acCategories = ranked.map((r) => r.entry.category);
             acTokenStart = 0;
             acIndex = -1;
         }
@@ -176,26 +184,30 @@ export async function startREPL(config) {
                             return "";
                         }
                     });
+                    acCategories = [];
                     acIsPath = acSuggestions.length > 0;
                 }
                 catch {
                     acSuggestions = [];
                     acDescriptions = [];
+                    acCategories = [];
                 }
                 acIndex = -1;
             }
             else {
                 acSuggestions = [];
                 acDescriptions = [];
+                acCategories = [];
                 acIndex = -1;
             }
         }
         else {
             acSuggestions = [];
             acDescriptions = [];
+            acCategories = [];
             acIndex = -1;
         }
-        renderer.setAutocomplete(acSuggestions, acIndex, acDescriptions);
+        renderer.setAutocomplete(acSuggestions, acIndex, acDescriptions, acCategories);
     }
     // Companion
     let companionVisible = true;
@@ -263,8 +275,38 @@ export async function startREPL(config) {
             const pct = Math.max(1, Math.ceil(usage * 100));
             ctxStr = `ctx [${bar}] ${pct}%`;
         }
-        // Use template if configured, otherwise default format
-        if (cachedConfig?.statusLineFormat) {
+        // Resolution priority: script (audit U-B1) → template → default.
+        //
+        // Script path: spawn user-configured shell with a JSON envelope on
+        // stdin; gated through the workspace-trust system from audit U-A4 so
+        // a hostile project can't auto-execute on first launch. Cached for
+        // `refreshMs` (default 1s) inside `status-line-script.ts` so the
+        // script doesn't run on every keypress. Failure → fall through to
+        // the template / default below.
+        let scriptLine = null;
+        const sl = cachedConfig?.statusLine;
+        if (sl?.command) {
+            const cwd = process.cwd();
+            if (trustSystemActive() && !isTrusted(cwd)) {
+                scriptLine = null; // untrusted — silently skip; user can /trust
+            }
+            else {
+                const ctxPct = ctxWindow > 0 && estimatedTokenCount > 0 ? estimatedTokenCount / ctxWindow : 0;
+                scriptLine = runStatusLineScript({
+                    model: currentModel || "",
+                    tokens: { input: inTok, output: outTok },
+                    cost: totalCostVal,
+                    contextPercent: ctxPct,
+                    sessionId: session.id,
+                    cwd,
+                    gitBranch: session.gitBranch,
+                }, sl);
+            }
+        }
+        if (scriptLine !== null) {
+            renderer.setStatusLine(scriptLine);
+        }
+        else if (cachedConfig?.statusLineFormat) {
             const line = cachedConfig.statusLineFormat
                 .replace("{model}", currentModel || "")
                 .replace("{tokens}", tokensStr)
@@ -516,6 +558,14 @@ export async function startREPL(config) {
         }
         if (key.name === "pageup" || key.name === "pagedown" || key.name === "mouse")
             return;
+        // Shift+Tab: cycle permission mode (audit U-A1). Mirrors Claude Code's
+        // quick-toggle. Cycles ask → acceptEdits → plan → trust → ask. The
+        // session-level mode is mutated on `config` so all downstream callers
+        // (`query()`, `cronExecutor`, status line) read the new value.
+        if (key.name === "tab" && key.shift) {
+            cyclePermissionMode();
+            return;
+        }
         // Tab: autocomplete slash commands or file paths, or cycle tool call expansion
         if (key.name === "tab" && !loading) {
             if (acSuggestions.length > 0) {
@@ -533,7 +583,7 @@ export async function startREPL(config) {
                 }
                 renderer.setInputText(inputText);
                 renderer.setInputCursor(inputCursor);
-                renderer.setAutocomplete(acSuggestions, acIndex, acDescriptions);
+                renderer.setAutocomplete(acSuggestions, acIndex, acDescriptions, acCategories);
                 return;
             }
             renderer.cycleToolCallExpansion();
@@ -621,6 +671,26 @@ export async function startREPL(config) {
             acIsPath,
         });
     });
+    /**
+     * Cycle the session permission mode (audit U-A1, Shift+Tab). The cycle
+     * intentionally covers the four interactive modes a user is likely to
+     * toggle between — `ask`, `acceptEdits`, `plan`, `trust`. The other modes
+     * (`deny`, `auto`, `bypassPermissions`) stay reachable via `/permissions
+     * <mode>` but aren't on the quick-cycle path because they're either
+     * destructive (`bypassPermissions`) or seldom-used.
+     *
+     * Mutates `config.permissionMode` directly so every existing read site
+     * (the `query()` call sites, `cronExecutor`, status hints) sees the new
+     * value without extra plumbing.
+     */
+    function cyclePermissionMode() {
+        const cycle = ["ask", "acceptEdits", "plan", "trust"];
+        const idx = cycle.indexOf(config.permissionMode);
+        const next = cycle[(idx === -1 ? 0 : idx + 1) % cycle.length];
+        config.permissionMode = next;
+        messages.push(createInfoMessage(`Permission mode → ${next}`));
+        syncRenderer();
+    }
     function navigateHistory(dir) {
         if (dir < 0 && historyIndex < inputHistory.length - 1) {
             historyIndex++;
@@ -1063,5 +1133,39 @@ export async function startREPL(config) {
     renderer.start();
     // Banner is already printed to stdout by main.tsx (visible in terminal scrollback)
     syncRenderer();
+    // Workspace-trust prompt (audit U-A4). Fires once per session when:
+    //   - the cwd isn't already on the trust list, AND
+    //   - `.oh/config.yaml` defines at least one shell-executing hook
+    //     (command/http) — `prompt` hooks don't trip the gate.
+    // Untrusted cwd silently skips command/http hooks via the gate in
+    // `harness/hooks.ts`. The prompt is non-blocking: we fire-and-forget
+    // the askQuestion so the REPL stays responsive while the question is
+    // displayed.
+    void (async () => {
+        try {
+            const { isTrusted, trust } = await import("./harness/trust.js");
+            if (isTrusted(process.cwd()))
+                return;
+            const cfgWithHooks = readOhConfig();
+            const hooks = cfgWithHooks?.hooks;
+            if (!hooks)
+                return;
+            const hasShellHook = Object.values(hooks).some((defs) => Array.isArray(defs) && defs.some((d) => d.command || d.http));
+            if (!hasShellHook)
+                return;
+            const answer = await renderer.askQuestion(`Trust this workspace? Shell hooks are configured in ${process.cwd()}. (yes/no)`);
+            if (answer.toLowerCase().startsWith("y")) {
+                trust(process.cwd());
+                messages.push(createInfoMessage(`Trusted ${process.cwd()} — shell hooks will now execute.`));
+            }
+            else {
+                messages.push(createInfoMessage(`Workspace not trusted — shell hooks are silently skipped. Run /trust to grant.`));
+            }
+            syncRenderer();
+        }
+        catch {
+            /* trust prompt is best-effort; never block the REPL */
+        }
+    })();
 }
 //# sourceMappingURL=repl.js.map

package/dist/tools/ExaSearchTool/index.d.ts

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import type { Tool } from "../../Tool.js";
+declare const SEARCH_TYPES: readonly ["auto", "neural", "fast", "keyword"];
+declare const CATEGORIES: readonly ["company", "research paper", "news", "personal site", "financial report", "people"];
+declare const inputSchema: z.ZodObject<{
+    query: z.ZodString;
+    num_results: z.ZodOptional<z.ZodNumber>;
+    type: z.ZodOptional<z.ZodEnum<["auto", "neural", "fast", "keyword"]>>;
+    category: z.ZodOptional<z.ZodEnum<["company", "research paper", "news", "personal site", "financial report", "people"]>>;
+    include_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude_domains: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    include_text: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    exclude_text: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    start_published_date: z.ZodOptional<z.ZodString>;
+    end_published_date: z.ZodOptional<z.ZodString>;
+    user_location: z.ZodOptional<z.ZodString>;
+    text: z.ZodOptional<z.ZodBoolean>;
+    highlights: z.ZodOptional<z.ZodBoolean>;
+    summary: z.ZodOptional<z.ZodBoolean>;
+    summary_query: z.ZodOptional<z.ZodString>;
+    max_text_chars: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    type?: "auto" | "fast" | "neural" | "keyword" | undefined;
+    text?: boolean | undefined;
+    summary?: boolean | undefined;
+    num_results?: number | undefined;
+    category?: "company" | "research paper" | "news" | "personal site" | "financial report" | "people" | undefined;
+    include_domains?: string[] | undefined;
+    exclude_domains?: string[] | undefined;
+    include_text?: string[] | undefined;
+    exclude_text?: string[] | undefined;
+    start_published_date?: string | undefined;
+    end_published_date?: string | undefined;
+    user_location?: string | undefined;
+    highlights?: boolean | undefined;
+    summary_query?: string | undefined;
+    max_text_chars?: number | undefined;
+}, {
+    query: string;
+    type?: "auto" | "fast" | "neural" | "keyword" | undefined;
+    text?: boolean | undefined;
+    summary?: boolean | undefined;
+    num_results?: number | undefined;
+    category?: "company" | "research paper" | "news" | "personal site" | "financial report" | "people" | undefined;
+    include_domains?: string[] | undefined;
+    exclude_domains?: string[] | undefined;
+    include_text?: string[] | undefined;
+    exclude_text?: string[] | undefined;
+    start_published_date?: string | undefined;
+    end_published_date?: string | undefined;
+    user_location?: string | undefined;
+    highlights?: boolean | undefined;
+    summary_query?: string | undefined;
+    max_text_chars?: number | undefined;
+}>;
+type ExaContents = {
+    text?: boolean | {
+        maxCharacters?: number;
+    };
+    highlights?: boolean | {
+        maxCharacters?: number;
+    };
+    summary?: boolean | {
+        query?: string;
+    };
+};
+type ExaRequest = {
+    query: string;
+    numResults: number;
+    type?: (typeof SEARCH_TYPES)[number];
+    category?: (typeof CATEGORIES)[number];
+    includeDomains?: string[];
+    excludeDomains?: string[];
+    includeText?: string[];
+    excludeText?: string[];
+    startPublishedDate?: string;
+    endPublishedDate?: string;
+    userLocation?: string;
+    contents?: ExaContents;
+};
+type ExaResultItem = {
+    id?: string;
+    url: string;
+    title?: string | null;
+    publishedDate?: string;
+    author?: string | null;
+    text?: string;
+    highlights?: string[];
+    summary?: string;
+};
+type ExaResponse = {
+    results: ExaResultItem[];
+    requestId?: string;
+};
+export declare function buildRequestBody(input: z.infer<typeof inputSchema>): ExaRequest;
+export declare function extractSnippet(item: ExaResultItem): string;
+export declare function formatResults(response: ExaResponse): string;
+export declare const ExaSearchTool: Tool<typeof inputSchema>;
+export {};
+//# sourceMappingURL=index.d.ts.map