@qthinker/opencode-deepseek-search 0.3.0 → 0.3.2

package/src/status-view.ts

@@ -1,7 +1,7 @@
 // Pure view model for the sidebar card. No renderer, no runtime dependency:
 // the card and the tests both derive their text from here.
 import { format, pack, t } from "./i18n/index.ts"
-import type { SearchStatus, UsageCounts, Language } from "./rpc.ts"
+import type { BalanceStatus, SearchStatus, UsageCounts, Language } from "./rpc.ts"
 
 export interface SidebarInput {
   readonly status: SearchStatus | undefined
@@ -41,7 +41,12 @@ export interface SidebarRows {
   readonly hint: string | undefined
   /** Whether a click on `action` really performs it (some states have no action). */
   readonly clickable: boolean
-  /** Body rows: the three usage rows, or the short error reason. */
+  /**
+   * Body rows: the three usage rows (or the single collapsed usage row when
+   * not even the shortest fits), or the short error reason, then the optional
+   * balance row last. A row starting with `!` is an unavailable balance; the
+   * marker is a color directive for the renderer and never part of the copy.
+   */
   readonly lines: readonly string[]
   /** Drives the state color in card.ts. */
   readonly tone: "on" | "off" | "warn" | "error" | "idle"
@@ -150,10 +155,12 @@ function usageLayout(counts: Counts): UsageLayout {
 
 /**
  * One usage row, e.g. `今日  Search 0  Fetch 3  ¥0.015` when the surface is
- * wide, otherwise shorter forms down to `今日`. The ladder is per language:
- * each locale owns the shapes that read well at its widths, so no language is
- * squeezed into another one's budget. Counts are right-aligned in their shared
- * width and every row picks the same form, so the three rows read as a table.
+ * wide, otherwise shorter forms down to the amount or the search count alone.
+ * The ladder is per language: each locale owns the shapes that read well at its
+ * widths, so no language is squeezed into another one's budget. Counts are
+ * right-aligned in their shared width and every row picks the same form, so the
+ * three rows read as a table. `undefined` means not even the shortest rung fits;
+ * the caller then collapses the three rows instead of emitting blanks.
  */
 function compactUsageRow(
   period: Period,
@@ -161,42 +168,54 @@ function compactUsageRow(
   layout: UsageLayout,
   maxColumns: number,
   language: Language,
-): string {
+): string | undefined {
   const label = t(language, LABEL_KEY[period])
   const search = String(counts.search).padStart(layout.search, " ")
   const fetch = String(counts.fetch).padStart(layout.fetch, " ")
   const cost = money(counts.costMicro).padStart(layout.cost, " ")
   const params = { label, search, fetch, cost }
+  const forms = pack(language).usageForms
   // Each candidate is a complete row, so nothing is ever left dangling and no
   // number is ever cut from its unit.
-  for (const form of pack(language).usageForms) {
+  for (const form of forms.slice(0, -1)) {
     const row = format(form, params)
     if (textColumns(row) <= maxColumns) return row
   }
-  return textColumns(label) <= maxColumns ? label : clip(label, maxColumns)
+  // The amount alone outranks the ladder's last rung, a lone search count: money
+  // is what this card is for, and a single counter is not. The row is composed
+  // here because it carries no count, so it is not a locale ladder entry — the
+  // label still comes from the locale table.
+  const amountRow = `${label} ${cost}`
+  if (textColumns(amountRow) <= maxColumns) return amountRow
+  const narrowest = forms[forms.length - 1]
+  if (narrowest !== undefined) {
+    const row = format(narrowest, params)
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return undefined
 }
 
 /**
- * An older server only sends pre-formatted strings, and those are always the
- * Chinese ones this plugin used to send: the filter below is deliberately
- * Chinese-only and stays correct while the UI language changes. Keep the full
- * string when it fits, otherwise drop its trailing segments whole: the amount
- * and the diagnostic counters go first, then the fetch count.
+ * Below the shortest rung no usage row can carry a number, so the three rows
+ * become one that still does: the total cost first (the number this card is
+ * opened for), then the total search count, then the bare amount, which fits
+ * the card floor on its own. A label with no number behind it is a row of noise
+ * and is never emitted.
  */
-function legacyUsageRow(period: Period, text: string, maxColumns: number, language: Language): string {
-  const label = t(language, LABEL_KEY[period])
-  const full = `${label} ${text}`
-  if (textColumns(full) <= maxColumns) return full
-  const stats = text.split(" · ").filter((part) => !part.startsWith("¥") && !part.startsWith("空/失"))
+function collapseUsageRow(counts: UsageCounts, layout: UsageLayout, maxColumns: number, language: Language): string {
+  const label = t(language, LABEL_KEY.total)
+  const cost = money(counts.costMicro)
   const candidates = [
-    `${label} ${stats.join("  ")}`.trimEnd(),
-    `${label} ${stats[0] ?? ""}`.trimEnd(),
-    label,
+    `${label} ${cost.padStart(layout.cost, " ")}`,
+    `${label} ${String(counts.search).padStart(layout.search, " ")}S`,
+    cost,
   ]
   for (const row of candidates) {
     if (textColumns(row) <= maxColumns) return row
   }
-  return clip(label, maxColumns)
+  // Nothing unclipped fits: only a clipped amount is left, and it still shows a
+  // digit as far as the columns allow.
+  return clip(cost, maxColumns)
 }
 
 function usageLines(status: SearchStatus, maxColumns: number, language: Language): readonly string[] {
@@ -212,11 +231,67 @@ function usageLines(status: SearchStatus, maxColumns: number, language: Language
   const counts = status.counts
   if (counts) {
     const layout = usageLayout(counts)
-    return PERIODS.map((period) => compactUsageRow(period, counts[period], layout, maxColumns, language))
+    const rows: string[] = []
+    for (const period of PERIODS) {
+      const row = compactUsageRow(period, counts[period], layout, maxColumns, language)
+      // All three rows share their padded widths, so they either all fit or none
+      // does; the first miss is enough to collapse rather than half a table.
+      if (row === undefined) return [collapseUsageRow(counts.total, layout, maxColumns, language)]
+      rows.push(row)
+    }
+    return rows
   }
   return PERIODS.map((period) => legacyUsageRow(period, status[period], maxColumns, language))
 }
 
+// The server normalizes `currency` to one of these codes, so the symbol is a
+// lookup rather than a formatting library. An unknown code contributes nothing
+// instead of a wrong symbol. The desktop panel reuses it for its account block.
+export const CURRENCY_SYMBOL: Readonly<Record<string, string>> = { CNY: "¥", USD: "$" }
+
+/**
+ * The account-balance row, or `undefined` when it does not fit. The amount is
+ * the server's string verbatim (`110.00`), never re-rounded: DeepSeek's account
+ * balance is authoritative and this row only mirrors it.
+ *
+ * `!` marks an unavailable balance and costs one column; it is the only marker,
+ * so the renderer can turn it into a color and every other consumer keeps a
+ * plain string. The row is never compressed into another one: below its width it
+ * is dropped, because half an amount is worse than no amount.
+ */
+function balanceRow(balance: BalanceStatus, maxColumns: number, language: Language): string | undefined {
+  const marker = balance.isAvailable ? "" : "!"
+  const amount = `${CURRENCY_SYMBOL[balance.currency] ?? ""}${balance.totalBalance}`
+  for (const form of pack(language).balanceForms) {
+    const row = `${marker}${format(form, { amount })}`
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return undefined
+}
+
+/**
+ * An older server only sends pre-formatted strings, and those are always the
+ * Chinese ones this plugin used to send: the filter below is deliberately
+ * Chinese-only and stays correct while the UI language changes. Keep the full
+ * string when it fits, otherwise drop its trailing segments whole: the amount
+ * and the diagnostic counters go first, then the fetch count.
+ */
+function legacyUsageRow(period: Period, text: string, maxColumns: number, language: Language): string {
+  const label = t(language, LABEL_KEY[period])
+  const full = `${label} ${text}`
+  if (textColumns(full) <= maxColumns) return full
+  const stats = text.split(" · ").filter((part) => !part.startsWith("¥") && !part.startsWith("空/失"))
+  const candidates = [
+    `${label} ${stats.join("  ")}`.trimEnd(),
+    `${label} ${stats[0] ?? ""}`.trimEnd(),
+    label,
+  ]
+  for (const row of candidates) {
+    if (textColumns(row) <= maxColumns) return row
+  }
+  return clip(label, maxColumns)
+}
+
 /**
  * The clickable label, always bracketed: a bare two-character verb is an easy
  * target to miss. At pathological widths the verb is clipped but the brackets
@@ -243,12 +318,17 @@ interface TitleFit {
  * and the title keeps the full width, and only then do the product name and the
  * wordy state shrink. Within one wording the glyph is the first thing to go,
  * because it costs two columns and the state word is right beside it.
+ *
+ * `allowActionBelow` is false on a card whose body is already full: giving the
+ * action its own row would push the card past its height budget, so the title
+ * shrinks instead — the action row always wins, because it is the only control.
  */
 function fitTitle(
   state: string,
   shortState: string,
   maxColumns: number,
   actionColumns: number | undefined,
+  allowActionBelow = true,
 ): TitleFit {
   const budget = (glyph: boolean, actionBelow: boolean): number => {
     if (maxColumns === Number.POSITIVE_INFINITY) return Number.POSITIVE_INFINITY
@@ -265,7 +345,7 @@ function fitTitle(
   ]
   // Inline first, then the action below it; a wording is never traded for a
   // shorter one that happens to fit inline, because the wording is the point.
-  const placements = actionColumns === undefined ? [false] : [false, true]
+  const placements = actionColumns === undefined || !allowActionBelow ? [false] : [false, true]
   for (const candidate of candidates) {
     for (const actionBelow of placements) {
       for (const glyph of [true, false]) {
@@ -276,8 +356,9 @@ function fitTitle(
     }
   }
   // Nothing fits whole at a pathological width: clip the state and give the
-  // action its own row so the hit area never disappears.
-  const actionBelow = actionColumns !== undefined
+  // action its own row so the hit area never disappears — unless the body has
+  // already spent that row, in which case the clipped title shares the width.
+  const actionBelow = allowActionBelow && actionColumns !== undefined
   return { title: clip(shortState, budget(false, actionBelow)), glyph: false, actionBelow }
 }
 
@@ -296,15 +377,36 @@ interface ActionRows extends TitleFit {
 }
 
 /** Fit the action first: the title can only use the columns it leaves over. */
-function actionRows(state: string, shortState: string, verb: string, maxColumns: number): ActionRows {
+function actionRows(
+  state: string,
+  shortState: string,
+  verb: string,
+  maxColumns: number,
+  allowActionBelow = true,
+): ActionRows {
   const action = fitAction(verb, maxColumns)
-  return { ...fitTitle(state, shortState, maxColumns, textColumns(action)), action }
+  return { ...fitTitle(state, shortState, maxColumns, textColumns(action), allowActionBelow), action }
 }
 
 export function sidebarRows(input: SidebarInput): SidebarRows {
   const { status, error, language } = input
   const maxColumns = input.maxColumns ?? DEFAULT_COLUMNS
-  const lines = status === undefined ? [] : usageLines(status, maxColumns, language)
+  const usage = status === undefined ? [] : usageLines(status, maxColumns, language)
+  // Only the two states that really point at the account show it: an enabled
+  // takeover or an explicit native mode. A state where nothing is taken over, a
+  // missing key, or a failed read leaves the body to usage and the error reason.
+  const balance =
+    status !== undefined &&
+    ((status.patched && status.hasKey) || status.mode === "native") &&
+    status.balance !== undefined
+      ? balanceRow(status.balance, maxColumns, language)
+      : undefined
+  // The balance row closes the body: the three usage rows read as the receipt
+  // (what this machine spent) and the account truth lands under them (what is
+  // left to spend). It still costs one body row, so the header must keep the
+  // action inline to stay within five rows.
+  const lines = balance === undefined ? usage : [...usage, balance]
+  const allowActionBelow = balance === undefined
 
   // No status yet: the body has no numbers to show, only the reason (or that
   // the first read is still in flight).
@@ -329,7 +431,13 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
 
   if (status.patched && status.hasKey) {
     return {
-      ...actionRows(t(language, "state.enabled"), t(language, "state.enabledShort"), t(language, "action.disable"), maxColumns),
+      ...actionRows(
+        t(language, "state.enabled"),
+        t(language, "state.enabledShort"),
+        t(language, "action.disable"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,
@@ -345,6 +453,7 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
         t(language, "state.unpatchedShort"),
         t(language, "action.release"),
         maxColumns,
+        allowActionBelow,
       ),
       hint: undefined,
       clickable: true,
@@ -354,7 +463,13 @@ export function sidebarRows(input: SidebarInput): SidebarRows {
   }
   if (status.mode === "native") {
     return {
-      ...actionRows(t(language, "state.disabled"), t(language, "state.disabledShort"), t(language, "action.enable"), maxColumns),
+      ...actionRows(
+        t(language, "state.disabled"),
+        t(language, "state.disabledShort"),
+        t(language, "action.enable"),
+        maxColumns,
+        allowActionBelow,
+      ),
       hint: undefined,
       clickable: true,
       lines,

package/src/tui/card.ts

@@ -9,6 +9,10 @@ import type { SidebarRows } from "../status-view.ts"
 
 /** A measured width under this cannot show even the usage label; treat it as unmeasured. */
 const MIN_CARD_COLUMNS = 8
+/** Body rows are inset this far from the title, so the card reads as one block. */
+const INDENT = "  "
+/** Under this many columns the indent costs more than it explains. */
+const INDENT_MIN_COLUMNS = 16
 
 /**
  * Columns the card may use. Before the first layout pass the host reports 0 (or
@@ -69,6 +73,40 @@ function element(tag: string, props: Props | undefined, children: readonly Child
   return node
 }
 
+/** The amount at the end of a row, e.g. `¥0.015` / `$6.17`; it gets its own color. */
+const MONEY_TAIL = /([¥$][\d.,]+)$/u
+
+/**
+ * One body row split into the three tiers the card colors. The view model emits
+ * plain strings — one row per line, deliberately not structured — so the row is
+ * split here: the leading label reads faint, the counters in the middle muted,
+ * and the amount at the end is the number the user came for, so it gets full
+ * contrast.
+ */
+interface BodyParts {
+  readonly label: string
+  readonly middle: string
+  readonly amount: string
+  /** The row starts with `!`: the balance could not be read. */
+  readonly unavailable: boolean
+}
+
+function bodyParts(line: string): BodyParts {
+  // `!` is the only unavailable marker in the row text and is consumed here as a
+  // color directive: it is never drawn. The label and the amount still are.
+  const unavailable = line.startsWith("!")
+  const text = unavailable ? line.slice(1) : line
+  const amount = MONEY_TAIL.exec(text)?.[1] ?? ""
+  const head = amount === "" ? text : text.slice(0, text.length - amount.length)
+  const gap = head.indexOf(" ")
+  return {
+    label: gap < 0 ? head : head.slice(0, gap),
+    middle: gap < 0 ? "" : head.slice(gap),
+    amount,
+    unavailable,
+  }
+}
+
 export function sidebarCard(input: {
   readonly status: SearchStatus | undefined
   readonly error: string | undefined
@@ -85,10 +123,14 @@ export function sidebarCard(input: {
 }): JSX.Element {
   // The terminal sidebar is the surface this ladder is tuned for: the measured
   // width, not a guessed constant, decides whether the words fit.
+  const columns = cardColumns(input.maxColumns)
+  // The indent is part of the drawn row, so it is subtracted from the budget the
+  // model composes against: every row still ends inside the measured width.
+  const indent = columns >= INDENT_MIN_COLUMNS ? INDENT : ""
   const rows = sidebarRows({
     status: input.status,
     error: input.error,
-    maxColumns: cardColumns(input.maxColumns),
+    maxColumns: columns - indent.length,
     language: input.language,
   })
   const theme = input.theme
@@ -108,14 +150,18 @@ export function sidebarCard(input: {
   //
   // The state word carries the tone color, so a narrow sidebar that has to drop
   // the glyph still shows the state at a glance (the desktop panel does the same).
+  // When the glyph is gone the word also goes bold — the emphasis has to live
+  // somewhere. Bold rides in `style`, because the reconciler ignores an
+  // `attributes` prop on text nodes and only maps `style` (fg/bg/attributes).
+  const stateStyle = rows.glyph ? { fg: state } : { fg: state, bold: true }
   const separator = rows.title.indexOf(" · ")
   const titleSpans: Child[] =
     separator < 0
-      ? [element("span", { style: { fg: state } }, [rows.title])]
+      ? [element("span", { style: stateStyle }, [rows.title])]
       : [
           element("span", { style: { fg: theme.text.base } }, [rows.title.slice(0, separator)]),
           element("span", { style: { fg: theme.text.faint } }, [" · "]),
-          element("span", { style: { fg: state } }, [rows.title.slice(separator + 3)]),
+          element("span", { style: stateStyle }, [rows.title.slice(separator + 3)]),
         ]
   if (rows.glyph) {
     titleSpans.unshift(element("span", { style: { fg: state } }, [`${GLYPH[rows.tone]} `]))
@@ -157,11 +203,28 @@ export function sidebarCard(input: {
           [action],
         )
 
-  // The model already composed every row to fit the sidebar, so each body row
-  // is one text node: the host must never get the chance to wrap it.
-  const body = rows.lines.map((line) =>
-    element("text", { content: line, fg: theme.text.muted, wrapMode: "none", width: "100%" }),
-  )
+  // The model already composed every row to fit the sidebar, so each body row is
+  // one text node: the host must never get the chance to wrap it. The row's own
+  // text is split into colored spans, so the label, the counters and the amount
+  // each read at their own weight without a second row or a box per line.
+  const body = rows.lines.map((line) => {
+    const parts = bodyParts(line)
+    const spans: Child[] = []
+    if (indent !== "") spans.push(element("span", { style: { fg: theme.text.faint } }, [indent]))
+    if (parts.label !== "") {
+      spans.push(element("span", { style: { fg: theme.text.faint } }, [parts.label]))
+    }
+    if (parts.middle !== "") {
+      spans.push(element("span", { style: { fg: theme.text.muted } }, [parts.middle]))
+    }
+    if (parts.amount !== "") {
+      // An unavailable balance is the one thing on the card that must not look
+      // like an ordinary amount: it is the reason the next call will fail.
+      const fg = parts.unavailable ? theme.text.feedback.warning.base : theme.text.base
+      spans.push(element("span", { style: { fg } }, [parts.amount]))
+    }
+    return element("text", { selectable: false, wrapMode: "none", width: "100%" }, spans)
+  })
   // A missing key has no action, so the fix hint gets the row right under the
   // title. It is plain text: there is nothing to click.
   const hint =

package/src/tui/main.ts

@@ -35,9 +35,14 @@ export default Plugin.define({
     // `status` takes a required first argument: plain JSON Schema degrades the
     // input type to `unknown`, and the host validates the payload against the
     // method's object schema, so an omitted input is rejected as invalid.
-    async function refresh() {
+    //
+    // `force` asks the server to re-probe the account balance instead of serving
+    // the cache; only a user action may spend that request. The timer and the
+    // `changed` event therefore send `{}` exactly — an older server rejects
+    // unknown input properties, so a stray `force: false` would break it.
+    async function refresh(force = false) {
       try {
-        const next = readStatus(await rpc.status({}))
+        const next = readStatus(await rpc.status(force ? { force: true } : {}))
         if (next) {
           setStatus(next)
           setError(undefined)
@@ -65,11 +70,12 @@ export default Plugin.define({
     }
 
     // The card labels the action it can really perform: switching the takeover
-    // when a status is known, retrying the read when it is not.
+    // when a status is known, retrying the read when it is not. A retry is a user
+    // action, so it refreshes the cached balance snapshot as well.
     function toggle() {
       const current = status()
       if (!current || error()) {
-        void refresh()
+        void refresh(true)
         return
       }
       void applyMode(current.mode === "deepseek" ? "native" : "deepseek")
@@ -88,7 +94,9 @@ export default Plugin.define({
         current: status()?.mode,
       })
       if (choice === undefined) return
-      if (choice === "refresh") await refresh()
+      // The dialog's refresh is an explicit "show me now", so it bypasses the
+      // server's balance cache; enabling/disabling refreshes through applyMode.
+      if (choice === "refresh") await refresh(true)
       else await applyMode(choice)
     }