opencode-context-indicator 1.7.0 → 1.8.0

package/lib/limits.js

@@ -10,17 +10,21 @@
 // Compaction ceiling (opencode calculateCeiling): opencode's core
 // calculateCeiling() in packages/core/src/session/compaction.ts derives the
 // auto-compaction trigger ceiling as window - reserve, where
-// window = limit.input || limit.context (null/zero falls through to the context
-// window) and
-//   reserve = max(floor(window * 0.10), window >= 2 * 16_000 ? 16_000 : 0)
-// The share was 15% up to v2.1.x and is 10% since v2.2.0 (PR #51271 "fit output
-// limits to the context window"); the `2 * RESERVE_MIN` gate is unchanged. A
-// wrong reserve makes every displayed percentage wrong, so this mirrors the
-// host exactly.
+//   window = input && context ? min(input, context) : input || context
+// (null/zero falls through; since opencode 2.2.5 (#60660) an input limit ABOVE
+// the context window is capped at the context window, because the context also
+// holds the reply) and
+//   reserve = max(floor(window * 0.15), window >= 2 * 16_000 ? 16_000 : 0)
+// `RESERVE_SHARE = 0.15` in every RELEASED host from 2.1.4 through 2.2.5
+// (verified tag by tag; the `2 * RESERVE_MIN` gate is older and unchanged). The
+// unreleased `v2` branch HEAD has an inline `0.1` instead - do NOT mirror a
+// branch head: a wrong reserve makes every displayed percentage wrong.
 // A compaction.buffer configured in opencode itself is NOT visible to the
 // plugin (the plugin cannot read opencode's internal compaction config); the
 // env var OPENCODE_CONTEXT_INDICATOR_COMPACT_BUFFER overrides the reserve for
 // testing and power users only (non-negative finite integer <= 1e9, ignore invalid).
+// opencode 2.2.5 also accepts a percentage there ("buffer": "20%"), which is
+// likewise invisible here, so a percentage buffer shows the default reserve.
 // Like core, a buffer that is NOT smaller than the window is ignored: a buffer
 // set for a larger model must never leave zero room.
 
@@ -85,11 +89,11 @@ function getModelLimit(providerID, modelID) {
 }
 
 // Compute the reserve for a given window, matching opencode's
-// packages/core/src/session/compaction.ts calculateCeiling() in 2.2.x (the
-// share became 10% in 2.2.0; the 2 * RESERVE_MIN gate is older and unchanged).
+// packages/core/src/session/compaction.ts calculateCeiling() as RELEASED
+// (RESERVE_SHARE = 0.15 in 2.1.4 .. 2.2.5; the branch head is not a release).
 // Returns null when
 // window is not a finite positive number.
-const RESERVE_SHARE = 0.1; // core: 10% of the window (15% before v2.2.0)
+const RESERVE_SHARE = 0.15; // core: RESERVE_SHARE in every released 2.x
 const RESERVE_MIN = 16_000; // core: RESERVE_MIN
 function reserveFor(window, bufferOverride) {
   if (
@@ -109,7 +113,7 @@ function reserveFor(window, bufferOverride) {
     return bufferOverride;
   }
   // Default reserve formula (mirror of opencode core):
-  //   max(floor(window * 0.10), window >= 2 * RESERVE_MIN ? RESERVE_MIN : 0)
+  //   max(floor(window * 0.15), window >= 2 * RESERVE_MIN ? RESERVE_MIN : 0)
   // The threshold is 2 * RESERVE_MIN (32_000), not RESERVE_MIN.
   return Math.max(
     Math.floor(window * RESERVE_SHARE),
@@ -117,8 +121,8 @@ function reserveFor(window, bufferOverride) {
   );
 }
 
-// Native opencode compaction ceiling (calculateCeiling, core v2.2.x):
-//   window = limit.input || limit.context  (zero/null falls through to context)
+// Native opencode compaction ceiling (calculateCeiling, released 2.x):
+//   window = input && context ? min(input, context) : input || context
 //   reserve = reserveFor(window)  [or bufferOverride when provided]
 //   usable  = window - reserve
 // Returns { usable, limit: window, maxOutput, reserved } or null when not
@@ -127,6 +131,11 @@ function reserveFor(window, bufferOverride) {
 // participate in this calculation; opencode's internal buffer is not visible.
 // The buffer override (env or argument) replaces the whole reserve only while
 // it is smaller than the window — a buffer >= window falls back to the share.
+//
+// The min() is opencode 2.2.5 (#60660): a provider that reports an input limit
+// ABOVE the context window cannot use it in full, because the context also holds
+// the reply. Using input alone would overstate the denominator (and show a
+// compact-at point the host never reaches).
 function getUsableContext(providerID, modelID, bufferOverride) {
   const rec = getModelLimitRecord(providerID, modelID);
   if (!rec) return null;
@@ -135,8 +144,11 @@ function getUsableContext(providerID, modelID, bufferOverride) {
   const input =
     typeof rec.input === "number" && rec.input > 0 ? rec.input : null;
   if (input == null && context == null) return null;
-  // Mirror core's limit.input || limit.context (zero/null falls through to context).
-  const window = input != null && input > 0 ? input : context;
+  // Mirror core's inputWindow(): min(input, context) when both are known.
+  // The `??` is core's `||` here: a non-positive input was normalized to null
+  // above, so there is no 0 to fall through.
+  const window =
+    input != null && context != null ? Math.min(input, context) : input ?? context;
   if (window == null || !(window > 0)) return null;
 
   // When bufferOverride is omitted, read it from the env var once per call.

package/lib/state.js

@@ -60,7 +60,7 @@ const LOG_FILE =
   process.env.OPENCODE_CONTEXT_INDICATOR_LOG_FILE ||
   join(tmpdir(), "context-breakdown.log");
 
-// Machine-readable snapshot consumed by the optional TUI sidebar (./tui.tsx,
+// Machine-readable snapshot consumed by the optional TUI sidebar (./tui.ts,
 // package entry "./tui"). Written next to each log update — same moment, same
 // data. See writeStateFile() below.
 // State file path — overridable via env for test isolation.
@@ -417,7 +417,7 @@ function renameWithRetry(from, to, attempts = 3, delayMs = 50) {
 // TUI state bridge (opencode-context-indicator)
 // ---------------------------------------------------------------------------
 // Persist a tiny machine-readable snapshot of the CURRENT breakdown for one
-// session so the optional TUI sidebar (./tui.tsx, package entry "./tui") can
+// session so the optional TUI sidebar (./tui.ts, package entry "./tui") can
 // render it without talking to the server. The file is one JSON object keyed by
 // sessionID, rewritten atomically (temp + rename) at every log write — same
 // moment, same data. Strictly additive: any failure is swallowed and must never
@@ -460,9 +460,10 @@ function writeStateFile(
     try {
       const bd = breakdownCache.get(sessionID) || null;
       const usableInfo = getUsableContext(providerID, modelID);
-      // Persist the EFFECTIVE window (limit.input || limit.context — the same
-      // window the ceiling was derived from), not the raw context window: on a
-      // cold instance hydrateModelLimitsFromState seeds context = limit, so a
+      // Persist the EFFECTIVE window (min(input, context) when both are known,
+      // else input || context: the same window the ceiling was derived from),
+      // not the raw context window: on a cold instance
+      // hydrateModelLimitsFromState seeds context = limit, so a
       // mismatched limit would re-derive a WRONG (too large) ceiling for models
       // where limit.input < limit.context.
       const limit =

package/lib/tui-data.d.ts

@@ -54,7 +54,6 @@ export interface StateEntry {
 
 export declare const STATE_FILE: string
 export declare const POLL_MS: number
-export declare function isNodeModulesInstall(): boolean
 export declare function readSnapshot(): Record<string, StateEntry>
 export declare function collectFamily(
   snapshot: Record<string, StateEntry>,

package/lib/tui-data.js

@@ -1,13 +1,13 @@
 // lib/tui-data.js
 //
-// Data layer for the TUI entry (tui.tsx): the state.json bridge (readSnapshot /
+// Data layer for the TUI entry (tui.ts): the state.json bridge (readSnapshot /
 // isEmptyEntry / collectFamily), the shared formatting helpers (fmt / num / fit
-// / updatedAt) and the npm-install detection. Plain JS with JSDoc — same shape
-// as lib/contributors.js — so tui.tsx stays a thin JSX/setup shell and the node
-// tooling (resolve gate, future unit tests) can import it without a transform.
+// / updatedAt) and the family walk. Plain JS with JSDoc — same shape as
+// lib/contributors.js — so tui.ts stays a thin setup shell and the node tooling
+// (resolve gate, unit tests) can import it without a transform.
 //
 // These helpers must stay free of solid-js / @opentui imports: the TUI host
-// bridges those modules only for the JSX entry, and keeping this file pure
+// bridges those modules only for the plugin bundle, and keeping this file pure
 // means it also loads anywhere node does.
 //
 // state.json shape (written by writeStateFile() in index.js, untrusted input):
@@ -20,7 +20,6 @@
 import { readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { fileURLToPath } from "node:url";
 import { isSafeSessionKey, sumCategories } from "./estimate.js";
 import { fmt, num } from "./format.js";
 
@@ -38,21 +37,6 @@ export const STATE_FILE =
 
 export const POLL_MS = 1000;
 
-// True when this package was loaded from an npm install, i.e. its own file
-// path contains a `node_modules` segment (OpenCode's TUI loader skips the host
-// Solid transform for such paths → slots mount once but never live-update; see
-// the Graceful mode note in tui.tsx). Normalised to forward slashes for
-// Windows paths. ANY file of the package yields the same answer, so checking
-// from lib/ is equivalent to checking from the tui.tsx entry.
-export function isNodeModulesInstall() {
-  try {
-    const selfPath = fileURLToPath(import.meta.url).replace(/\\/g, "/").toLowerCase()
-    return selfPath.includes("/node_modules/")
-  } catch {
-    return false
-  }
-}
-
 // Whole state.json snapshot ({ sessionID: entry }) or {} on any error. The
 // sidebar resolves one entry from it and the breakdown panel walks the
 // parentID family over it. Never throws — a missing / empty / corrupt

package/lib/tui-h.ts

@@ -0,0 +1,73 @@
+// lib/tui-h.ts
+//
+// The two tree builders every TUI surface in this package uses instead of JSX.
+//
+// WHY NO JSX (do not "simplify" this back):
+//   OpenCode installs npm plugins inside a `node_modules` tree
+//   (~/.cache/opencode/npm/<name>@<version>/<ts>/node_modules/<name>). For such
+//   paths the host deliberately skips its Solid/Babel JSX transform (sourceFilter
+//   in @opentui/solid/scripts/solid-plugin.js excludes node_modules, upstream
+//   anomalyco/opencode#33884). A JSX-compiled file in that position also needs
+//   `@opentui/solid` to be installed next to it just to resolve its emitted
+//   jsx-runtime import. Files WITHOUT JSX syntax are unaffected: their literal
+//   `@opentui/solid/jsx-runtime` import IS rewritten by the host to the
+//   in-process OpenTUI module (`nodeModulesRuntimeSpecifiers: true` in
+//   DEFAULT_RUNTIME_PLUGIN_REWRITE_OPTIONS of @opentui/core), so the tree stays
+//   reactive and the package needs no runtime dependency at all.
+//
+// Therefore: no JSX syntax anywhere in this package's TUI files, and no
+// `@jsxImportSource` pragma. Build the tree with jsx() and mark every DYNAMIC
+// prop as a getter — that is exactly what the Solid compiler emits for
+// `prop={expr}` in JSX, so the runtime semantics are identical:
+//
+//   <text fg={base()}>{line}</text>
+//     ->  h("text", { get fg() { return base() }, get children() { return line } })
+//
+// A plain (non-getter) value is read ONCE, like a literal attribute in JSX.
+// Children follow the same rule: an array of elements is fine (it is diffed by
+// the runtime), a function child is a reactive accessor.
+//
+// RELATIVE IMPORTS OF .ts FILES MUST CARRY THE EXTENSION (`./tui-h.ts`, not
+// `./tui-h`): the host decides which files get the runtime-specifier rewrite by
+// walking the import graph with `import.meta.resolve(specifier, importer)`,
+// which does not probe extensions. An extensionless import is simply not
+// followed, so that file keeps the literal `@opentui/solid/jsx-runtime` import
+// and the npm install dies with `Cannot find package '@opentui/solid'`.
+// test/prepublish.mjs gate (b) enforces this.
+//
+// This module is the only place that imports the jsx runtime, so the allowlist
+// in test/prepublish.mjs stays short.
+//
+// NEVER pass a `key` prop to h()/c(). The jsx runtime's normalizeProps() sees
+// `key`, strips it with `{ ...rest }`, and the spread turns every getter into a
+// plain value read ONCE — the whole subtree freezes with no error. (No list in
+// this package is keyed; if you ever need one, do not add `key` here.)
+
+import { jsx } from "@opentui/solid/jsx-runtime"
+import type { JSX } from "@opentui/solid/jsx-runtime"
+
+/** An intrinsic OpenTUI element: `h("text", { fg, children })`. */
+export function h<K extends string>(
+  tag: K,
+  props: K extends keyof JSX.IntrinsicElements ? JSX.IntrinsicElements[K] : never,
+): JSX.Element {
+  return jsx(tag, props as unknown as Record<string, unknown>)
+}
+
+/**
+ * A component: `c(Show, { get when() {...}, get fallback() {...} })`.
+ *
+ * The component's own prop type is intentionally not enforced here: host
+ * components (Show, and any OpenTUI component) are generic and their unions do
+ * not survive inference through a wrapper, while the shapes used in this
+ * package are small and covered by the e2e liveness check.
+ */
+export function c<C extends (props: any) => unknown, P extends object>(
+  component: C,
+  props: P,
+): JSX.Element {
+  return jsx(
+    component as unknown as (props: Record<string, unknown>) => unknown,
+    props as unknown as Record<string, unknown>,
+  )
+}