@zhijiewang/openharness 2.5.0 → 2.8.0

package/dist/components/InitWizard.js

@@ -92,6 +92,65 @@ export default function InitWizard({ onDone }) {
     const [selectedMcp, setSelectedMcp] = useState(new Set());
     const [mcpIdx, setMcpIdx] = useState(0);
     const provider = PROVIDERS[providerIdx];
+    // ── Connection test ──
+    const runTest = useCallback(async (prov, key, url) => {
+        setTestStatus("testing");
+        try {
+            const { createProviderInstance } = await import("../providers/index.js");
+            const p = createProviderInstance(prov.key, {
+                name: prov.key,
+                apiKey: key || process.env[`${prov.key.toUpperCase()}_API_KEY`],
+                baseUrl: url || prov.defaultBaseUrl,
+                defaultModel: prov.defaultModel,
+            });
+            const fetched = "fetchModels" in p && typeof p.fetchModels === "function"
+                ? await p.fetchModels()
+                : p.listModels();
+            const modelNames = fetched.map((m) => m.id);
+            setAvailableModels(modelNames.length > 0 ? modelNames : [prov.defaultModel]);
+            setTestStatus("ok");
+            setTimeout(() => setStep("model"), 600);
+        }
+        catch (err) {
+            setTestStatus("fail");
+            setTestError(err instanceof Error ? err.message : String(err));
+            setAvailableModels([prov.defaultModel]);
+            setTimeout(() => setStep("model"), 800);
+        }
+    }, []);
+    // ── Write final config ──
+    const writeFinal = useCallback(() => {
+        const selectedModel = availableModels.length > 0 ? (availableModels[modelIdx] ?? model) : model;
+        // Build MCP server configs from selected registry entries
+        let mcpServers;
+        if (selectedMcp.size > 0) {
+            try {
+                const { MCP_REGISTRY } = require("../mcp/registry.js");
+                mcpServers = [...selectedMcp]
+                    .map((name) => MCP_REGISTRY.find((e) => e.name === name))
+                    .filter(Boolean)
+                    .map((e) => ({
+                    name: e.name,
+                    command: "npx",
+                    args: ["-y", e.package, ...(e.args ?? [])],
+                    ...(e.envVars?.length ? { env: Object.fromEntries(e.envVars.map((v) => [v, `YOUR_${v}`])) } : {}),
+                }));
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        writeOhConfig({
+            provider: provider.key,
+            model: selectedModel || provider.defaultModel,
+            permissionMode: PERMISSION_MODES[permIdx].key,
+            ...(apiKey ? { apiKey } : {}),
+            ...(baseUrl ? { baseUrl } : {}),
+            ...(mcpServers?.length ? { mcpServers } : {}),
+        });
+        setStep("done");
+        setTimeout(() => onDone?.(), 1500);
+    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp, onDone]);
     // ── Keyboard navigation ──
     useInput(useCallback((input, key) => {
         if (step === "provider") {
@@ -175,68 +234,7 @@ export default function InitWizard({ onDone }) {
             if (input === "n" || input === "N")
                 writeFinal();
         }
-    }, 
-    // biome-ignore lint/correctness/useExhaustiveDependencies: runTest/writeFinal declared below, providerIdx intentionally omitted
-    [step, providerIdx, provider, modelIdx, availableModels, model, suggestedMcp, mcpIdx]));
-    // ── Connection test ──
-    const runTest = async (prov, key, url) => {
-        setTestStatus("testing");
-        try {
-            const { createProviderInstance } = await import("../providers/index.js");
-            const p = createProviderInstance(prov.key, {
-                name: prov.key,
-                apiKey: key || process.env[`${prov.key.toUpperCase()}_API_KEY`],
-                baseUrl: url || prov.defaultBaseUrl,
-                defaultModel: prov.defaultModel,
-            });
-            const fetched = "fetchModels" in p && typeof p.fetchModels === "function"
-                ? await p.fetchModels()
-                : p.listModels();
-            const modelNames = fetched.map((m) => m.id);
-            setAvailableModels(modelNames.length > 0 ? modelNames : [prov.defaultModel]);
-            setTestStatus("ok");
-            setTimeout(() => setStep("model"), 600);
-        }
-        catch (err) {
-            setTestStatus("fail");
-            setTestError(err instanceof Error ? err.message : String(err));
-            setAvailableModels([prov.defaultModel]);
-            setTimeout(() => setStep("model"), 800);
-        }
-    };
-    // ── Write final config ──
-    const writeFinal = useCallback(() => {
-        const selectedModel = availableModels.length > 0 ? (availableModels[modelIdx] ?? model) : model;
-        // Build MCP server configs from selected registry entries
-        let mcpServers;
-        if (selectedMcp.size > 0) {
-            try {
-                const { MCP_REGISTRY } = require("../mcp/registry.js");
-                mcpServers = [...selectedMcp]
-                    .map((name) => MCP_REGISTRY.find((e) => e.name === name))
-                    .filter(Boolean)
-                    .map((e) => ({
-                    name: e.name,
-                    command: "npx",
-                    args: ["-y", e.package, ...(e.args ?? [])],
-                    ...(e.envVars?.length ? { env: Object.fromEntries(e.envVars.map((v) => [v, `YOUR_${v}`])) } : {}),
-                }));
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        writeOhConfig({
-            provider: provider.key,
-            model: selectedModel || provider.defaultModel,
-            permissionMode: PERMISSION_MODES[permIdx].key,
-            ...(apiKey ? { apiKey } : {}),
-            ...(baseUrl ? { baseUrl } : {}),
-            ...(mcpServers?.length ? { mcpServers } : {}),
-        });
-        setStep("done");
-        setTimeout(() => onDone?.(), 1500);
-    }, [provider, model, availableModels, modelIdx, permIdx, apiKey, baseUrl, selectedMcp, onDone]);
+    }, [step, provider, modelIdx, availableModels, model, suggestedMcp, mcpIdx, runTest, writeFinal]));
     // ── Render ──
     if (showSetup) {
         return (_jsx(CybergotchiSetup, { onComplete: () => {

package/dist/harness/hooks.js

@@ -117,13 +117,16 @@ async function runHttpHook(url, event, ctx, timeoutMs = 10_000) {
         return false;
     }
 }
-/** Run a prompt hook. Uses LLM to make a yes/no decision. */
+/**
+ * Run a prompt hook. Uses LLM to make a yes/no decision.
+ *
+ * Currently a stub — prompt hooks always allow because the hook system
+ * runs outside the query loop and has no access to a Provider instance.
+ * Full implementation requires passing a Provider via HookContext so the
+ * hook can call provider.complete() with the prompt text.
+ */
 async function runPromptHook(_promptText, _ctx) {
-    // Prompt hooks require a provider — skip if not available
-    // This is a lightweight check; full LLM call would need provider injection
-    // For now, prompt hooks evaluate the prompt text as a simple template
-    // TODO: inject provider for full LLM-based prompt hooks
-    return true; // Default allow if no LLM available
+    return true;
 }
 // ── Hook Execution ──
 /** Execute a single hook definition. Returns true if allowed. */

package/dist/providers/anthropic.js

@@ -87,15 +87,18 @@ export class AnthropicProvider {
         // Prompt caching: send system prompt as content blocks with cache_control.
         // Anthropic caches matching prefixes — 90% cost reduction on repeat turns.
         const systemBlocks = [{ type: "text", text: systemPrompt, cache_control: { type: "ephemeral" } }];
+        // Scale max_tokens and thinking budget based on model
+        const isOpus = m.includes("opus");
+        const maxTokens = isOpus ? 16384 : 8192;
+        const thinkingBudget = isOpus ? 32000 : 10000;
         const body = {
             model: m,
-            max_tokens: 8192,
+            max_tokens: maxTokens,
             system: systemBlocks,
             messages: this.convertMessages(messages),
             stream: true,
+            thinking: { type: "enabled", budget_tokens: thinkingBudget },
         };
-        // Enable extended thinking for Claude models
-        body.thinking = { type: "enabled", budget_tokens: 10000 };
         const anthropicTools = this.convertTools(tools);
         if (anthropicTools) {
             // Mark last tool definition as cacheable (cache covers all tools before it)
@@ -131,7 +134,6 @@ export class AnthropicProvider {
         let currentToolId = "";
         let currentToolName = "";
         let currentToolArgs = "";
-        let _inThinkingBlock = false;
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -169,9 +171,7 @@ export class AnthropicProvider {
                                 callId: block.id,
                             };
                         }
-                        if (block?.type === "thinking") {
-                            _inThinkingBlock = true;
-                        }
+                        // thinking blocks are handled via thinking_delta in content_block_delta
                         break;
                     }
                     case "content_block_delta": {
@@ -188,7 +188,6 @@ export class AnthropicProvider {
                         break;
                     }
                     case "content_block_stop": {
-                        _inThinkingBlock = false;
                         if (currentToolId) {
                             let parsedArgs = {};
                             if (currentToolArgs) {

package/dist/providers/openai.js

@@ -75,8 +75,9 @@ export class OpenAIProvider {
         if (tools?.length)
             body.tools = tools;
         // Enable reasoning for o-series models
-        if (m.startsWith("o1") || m.startsWith("o3")) {
-            body.reasoning_effort = "medium";
+        const isReasoning = m.startsWith("o1") || m.startsWith("o3") || m.startsWith("o4");
+        if (isReasoning) {
+            body.reasoning_effort = m.includes("mini") ? "medium" : "high";
         }
         let res;
         try {

package/dist/renderer/layout-sections.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Layout section renderers — individual UI widgets rasterized into a CellGrid.
+ * Each function takes (state, grid, row, limit, ...options) and returns next row.
+ */
+import type { CellGrid, Style } from "./cells.js";
+import type { LayoutState } from "./layout.js";
+export declare const S_TEXT: Style;
+export declare const S_DIM: Style;
+export declare const S_BORDER: Style;
+export declare const S_BANNER: Style;
+export declare const S_BANNER_DIM: Style;
+export declare let S_USER: Style;
+export declare let S_ASSISTANT: Style;
+export declare let S_ERROR: Style;
+export declare let S_YELLOW: Style;
+export declare let S_GREEN: Style;
+/** Reset style cache — call after theme change */
+export declare function resetStyleCache(): void;
+export declare function ensureStyles(): void;
+export declare const SPINNER_CHARS: string[];
+export declare function renderBannerSection(state: LayoutState, grid: CellGrid, r: number, limit: number, opts: {
+    compact: boolean;
+}): number;
+export declare function renderThinkingSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderThinkingSummarySection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderSpinnerSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderErrorSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderToolCallsSection(state: LayoutState, grid: CellGrid, r: number, limit: number, opts: {
+    maxLiveLines: number;
+    showOverflow: boolean;
+}): number;
+export declare function renderContextWarningSection(state: LayoutState, grid: CellGrid, r: number, limit: number): number;
+export declare function renderPermissionBoxSection(state: LayoutState, grid: CellGrid, nextRow: number, h: number, opts: {
+    boxed: boolean;
+    maxDiffHeight: number;
+}): number;
+export declare function renderQuestionPromptSection(state: LayoutState, grid: CellGrid, nextRow: number, h: number, opts: {
+    boxed: boolean;
+}): {
+    nextRow: number;
+    questionInputRow: number;
+};
+export declare function renderStatusLineSection(state: LayoutState, grid: CellGrid, nextRow: number, limit: number): number;
+export declare function renderAutocompleteSection(state: LayoutState, grid: CellGrid, nextRow: number, limit: number, promptWidth: number): number;
+export declare function renderNotificationsSection(state: LayoutState, grid: CellGrid, nextRow: number, limit: number): number;
+export declare function renderInputSection(state: LayoutState, grid: CellGrid, inputRow: number, limit: number, promptText: string, promptWidth: number): number;
+export declare function renderCompanionSection(state: LayoutState, grid: CellGrid, anchorRow: number, limit: number, promptWidth: number): void;
+export declare function computeCursorPosition(state: LayoutState, inputRow: number, inputStart: number, questionInputRow: number): {
+    cursorRow: number;
+    cursorCol: number;
+};
+export declare function getPromptText(state: LayoutState): {
+    promptText: string;
+    promptWidth: number;
+};
+//# sourceMappingURL=layout-sections.d.ts.map