@reedchan/statusline 1.4.0 → 1.6.0

package/README.md

@@ -8,7 +8,7 @@ Replaces pi's footer with a labelled two-row one. Every value carries a word, so
 decoded from a symbol or remembered from a legend.
 
 ```
-Context  █████████▍░░░░░░░░░░  47.1%   471k / 1.0M                   Input 194k  ·  Output 89k  ·  Cache hit 99.9%  ·  Cost $0.229
+Context  █████████▍░░░░░░░░░░  47%   471k / 1.0M     Input 194k  ·  Output 89k  ·  Cache hit 99.9%  ·  Cost $0.229  ·  Today $1.63
 ~/.pi (master)                                                               deepseek-flash · Effort high · TTFT 482ms · 729 tok/s
 LSP Active: typescript
 ```
@@ -19,17 +19,18 @@ columns only the meter is left. Every step is a whole value — a number is neve
 
 ## What each part is
 
-| Part                        | Meaning                                                                                                                                                                                      |
-| --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `Context` + meter + `47.1%` | Share of the model's context window in use. The fill turns `warning` above 70% and `error` above 90%, the same thresholds pi's shipped footer uses, and the percentage changes color with it |
-| `471k / 1.0M`               | Absolute context tokens over the window size. The first thing dropped when the terminal is narrow                                                                                            |
-| `Input` / `Output`          | Session prompt and completion tokens. `Input` counts the prompt tokens that were neither read from nor written to cache, because pi reports those two separately in the same `usage` object  |
-| `Cache hit`                 | The latest turn's cache hit rate, `cacheRead / (input + cacheRead + cacheWrite)`                                                                                                             |
-| `Cost`                      | Session cost, in USD unless a config file names another currency (see below)                                                                                                                 |
-| Effort                      | The active thinking level                                                                                                                                                                    |
-| `TTFT`                      | Time from request dispatch to the first streamed token                                                                                                                                       |
-| `tok/s`                     | Decode throughput, i.e. output tokens per second of decode time                                                                                                                              |
-| Last line                   | Other extensions' `ctx.ui.setStatus()` entries, so they do not silently disappear                                                                                                            |
+| Part                      | Meaning                                                                                                                                                                                      |
+| ------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Context` + meter + `47%` | Share of the model's context window in use. The fill turns `warning` above 70% and `error` above 90%, the same thresholds pi's shipped footer uses, and the percentage changes color with it |
+| `471k / 1.0M`             | Absolute context tokens over the window size. The first thing dropped when the terminal is narrow                                                                                            |
+| `Input` / `Output`        | Session prompt and completion tokens. `Input` counts the prompt tokens that were neither read from nor written to cache, because pi reports those two separately in the same `usage` object  |
+| `Cache hit`               | The latest turn's cache hit rate, `cacheRead / (input + cacheRead + cacheWrite)`                                                                                                             |
+| `Cost`                    | Session cost, in USD unless a config file names another currency (see below)                                                                                                                 |
+| `Today`                   | Today's running cost across every project, session and model on this machine                                                                                                                 |
+| Effort                    | The active thinking level                                                                                                                                                                    |
+| `TTFT`                    | Time from request dispatch to the first streamed token                                                                                                                                       |
+| `tok/s`                   | Decode throughput, i.e. output tokens per second of decode time                                                                                                                              |
+| Last line                 | Other extensions' `ctx.ui.setStatus()` entries, so they do not silently disappear                                                                                                            |
 
 ## The meter
 
@@ -53,29 +54,34 @@ Configuration lives at the top of [`render.ts`](render.ts):
 ## Currency
 
 pi prices every model in USD and its `cost` field carries no unit at all, so the footer cannot know
-what you were actually billed. What a session cost in RMB is set by whoever sold you the credit, not
-by a market feed, which is why the rate is configured rather than fetched.
-
-Create `~/.pi/agent/statusline.json`:
+what you were actually billed. The currency and the rate live in `~/.pi/agent/statusline.json`:
 
 ```json
 {
   "currency": {
-    "code": "CNY",
-    "perUsd": 7.12
+    "code": "CNY"
   }
 }
 ```
 
-- `code` picks the symbol (`CNY` and `RMB` give `¥`; the table also knows `USD`, `EUR`, `GBP`, `JPY`,
-  `HKD`, `TWD`, `SGD`, `KRW` and `INR`). A code the table does not know is printed as it is.
-- `symbol` overrides the table, for a currency it does not list or a different separator.
-- `perUsd` is how many units of that currency one dollar buys — the rate you were actually charged.
-  It has to be a positive number; anything else is refused and the footer stays in USD.
+Two ways to set the rate:
+
+- **Follow the market.** A `code` with no rate fetches the day's table from open.er-api.com on the
+  first session of each day and caches the whole table in the file (`rates` + `fetchedAt`), so the
+  next session starts warm and switching codes is instant and offline.
+- **Pin it.** Add `"perUsd": 7.12` and the footer always uses that rate, never touching the network
+  — the right choice when your platform bills in RMB directly, because a domestic price list is not
+  the dollar list times a market rate.
+
+`code` picks the symbol: `¥` for `CNY` and `RMB`, `JP¥` for `JPY` so the two never trade places, and
+the table also knows `USD`, `EUR`, `GBP`, `HKD`, `TWD`, `SGD`, `KRW`, `INR`, `AUD`, `CAD`, `NZD` and
+`CHF`; an unknown code is printed as it is. `symbol` overrides all of that.
 
-With the file above, the same session reads `Cost ¥1.63` instead of `Cost $0.229`. The file is read
-once per session, so edit it and `/reload`. A file that is there but unusable says so in a
-notification, rather than silently showing dollars with nothing to explain why.
+Switching is editing `code`, or `make currency CODE=JPY` from a checkout. The file is read once per
+session, so finish with `/reload`. A file that is there but unusable says so in a notification,
+rather than silently showing dollars with nothing to explain why.
+
+## Metrics
 
 ## Metrics
 

package/README_CN.md

@@ -7,7 +7,7 @@
 替换 pi 的 footer，改成带文字标签的两行。每个值都带一个词，不需要靠符号猜、也不需要记图例。
 
 ```
-Context  █████████▍░░░░░░░░░░  47.1%   471k / 1.0M                   Input 194k  ·  Output 89k  ·  Cache hit 99.9%  ·  Cost $0.229
+Context  █████████▍░░░░░░░░░░  47%   471k / 1.0M     Input 194k  ·  Output 89k  ·  Cache hit 99.9%  ·  Cost $0.229  ·  Today $1.63
 ~/.pi (master)                                                               deepseek-flash · Effort high · TTFT 482ms · 729 tok/s
 LSP Active: typescript
 ```
@@ -25,6 +25,7 @@ LSP Active: typescript
 | `Input` / `Output`         | 会话的输入与输出 token 量。`Input` 指既没命中缓存、也没写入缓存的那部分 prompt token，因为 pi 把这两种情况在同一个 `usage` 对象里分开报 |
 | `Cache hit`                | 最近一轮的缓存命中率，`cacheRead / (input + cacheRead + cacheWrite)`                                                                    |
 | `Cost`                     | 会话花费，默认美元；配置了其他币种则换算显示（见下）                                                                                    |
+| `Today`                    | 当天跨项目、跨会话、跨模型的累计花费                                                                                                    |
 | Effort                     | 当前思考等级                                                                                                                            |
 | `TTFT`                     | 从发出请求到第一个流式 token 的耗时                                                                                                     |
 | `tok/s`                    | 解码吞吐，即每秒解码时间产出的输出 token 数                                                                                             |
@@ -51,27 +52,31 @@ LSP Active: typescript
 ## 币种
 
 pi 里所有模型价格都是美元，而且它的 `cost` 字段**不带任何单位**，所以 footer 无从知道你实际是按什么币种付的。
-这次会话折合多少人民币，取决于卖你额度那家给的汇率，而不是市场汇率——所以汇率是**配置**出来的，不是联网抓的。
-
-创建 `~/.pi/agent/statusline.json`：
+币种与汇率放在 `~/.pi/agent/statusline.json`：
 
 ```json
 {
   "currency": {
-    "code": "CNY",
-    "perUsd": 7.12
+    "code": "CNY"
   }
 }
 ```
 
-- `code` 决定符号（`CNY` 与 `RMB` 得到 `¥`；符号表还认 `USD`、`EUR`、`GBP`、`JPY`、`HKD`、`TWD`、
-  `SGD`、`KRW`、`INR`）。表里没有的代码就原样打印。
-- `symbol` 可覆盖符号表，用于表里没列的币种，或想换分隔方式。
-- `perUsd` 是一美元等于多少该币种，也就是**你实际被收的汇率**。必须是正数；
-  否则整块被拒绝，footer 继续显示美元。
+汇率有两种设法：
+
+- **跟随市场。** 只写 `code` 不写汇率时，每天第一个会话会从 open.er-api.com 拉取当日汇率表，
+  并把整张表缓存进文件（`rates` + `fetchedAt`），下个会话热启动；切换币种即时生效、离线也能切。
+- **钉死。** 加上 `"perUsd": 7.12`，footer 永远用这个汇率、绝不联网——如果你的平台直接按人民币计费，
+  这是正确选择：国内价目表不是美元价目表乘以市场汇率。
+
+`code` 决定符号：`CNY` 和 `RMB` 得到 `¥`，`JPY` 得到 `JP¥`（两者永不混用），符号表还认 `USD`、
+`EUR`、`GBP`、`HKD`、`TWD`、`SGD`、`KRW`、`INR`、`AUD`、`CAD`、`NZD`、`CHF`；表里没有的代码原样打印。
+`symbol` 可覆盖这一切。
 
-配置成上面这样，同一个会话就从 `Cost $0.229` 变成 `Cost ¥1.63`。该文件每个会话只读一次，
-改完需 `/reload`。文件存在但不可用时会给出通知，而不是静默继续显示美元。
+切换就是改 `code`，或者在检出里执行 `make currency CODE=JPY`。该文件每个会话只读一次，改完需 `/reload`。
+文件存在但不可用时会给出通知，而不是静默继续显示美元。
+
+## 指标口径
 
 ## 指标口径
 

package/extensions/statusline/index.ts

@@ -18,7 +18,8 @@
  * stepStartTime; decodeMs = completedTime - firstTokenTime; tok/s = usage.output / (decodeMs / 1000)
  */
 
-import { readFile, writeFile } from 'node:fs/promises'
+import { readFile, readdir, writeFile } from 'node:fs/promises'
+import { stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import { join } from 'node:path'
 
@@ -62,6 +63,8 @@ const FALLBACK_TOKENS_PER_CHAR = 0.25
 const CONFIG_PATH = join(homedir(), '.pi', 'agent', 'statusline.json')
 /** Free, keyless, and one request returns every currency — so the cache serves instant switching. */
 const RATES_URL = 'https://open.er-api.com/v6/latest/USD'
+/** Every session on this machine, for the day-cost total that spans projects and models. */
+const SESSIONS_DIR = join(homedir(), '.pi', 'agent', 'sessions')
 const FETCH_TIMEOUT_MS = 5000
 
 function today(): string {
@@ -97,6 +100,78 @@ async function fetchRates(): Promise<Record<string, number> | null> {
  * Called once per session on purpose: a footer that stat'ed a file on every frame would be its own
  * bug. Editing the file therefore takes effect on `/reload`.
  */
+function startOfToday(): number {
+  const start = new Date()
+  start.setHours(0, 0, 0, 0)
+  return start.getTime()
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+/** Today's provider cost of one session-file line, or null when the line bills nothing today. */
+function entryCost(line: string, since: number): number | null {
+  if (!line.includes('"usage"')) return null
+  let entry: unknown
+  try {
+    entry = JSON.parse(line)
+  } catch {
+    return null
+  }
+  if (!isRecord(entry) || typeof entry.timestamp !== 'string') return null
+  if (Date.parse(entry.timestamp) < since) return null
+  if (!isRecord(entry.usage) || !isRecord(entry.usage.cost)) return null
+  const total = entry.usage.cost.total
+  return typeof total === 'number' && Number.isFinite(total) ? total : null
+}
+
+/**
+ * Today's cost across every other session on this machine.
+ *
+ * Files not touched today are skipped unread, and this session's own file is skipped because its
+ * cost is already live in totals.cost — counting both would double a resumed session.
+ */
+async function sumOtherTodaysCost(currentFile: string | null, since: number): Promise<number> {
+  let dirs: string[] = []
+  try {
+    dirs = await readdir(SESSIONS_DIR)
+  } catch {
+    return 0
+  }
+  const lists = await Promise.all(
+    dirs.map(async (dir) => {
+      const dirPath = join(SESSIONS_DIR, dir)
+      let names: string[] = []
+      try {
+        names = await readdir(dirPath)
+      } catch {
+        return []
+      }
+      return names
+        .map((name) => join(dirPath, name))
+        .filter((path) => path.endsWith('.jsonl') && path !== currentFile)
+    }),
+  )
+  const costs = await Promise.all(
+    lists.flat().map(async (path) => {
+      try {
+        if ((await stat(path)).mtimeMs < since) return 0
+      } catch {
+        return 0
+      }
+      const text = await readFile(path, 'utf8').catch(() => '')
+      let total = 0
+      for (const line of text.split('\n')) {
+        const cost = entryCost(line, since)
+        if (cost !== null) total += cost
+      }
+      return total
+    }),
+  )
+  return costs.reduce((sum, value) => sum + value, 0)
+}
+
 async function loadCurrency(notify: (message: string) => void): Promise<Currency> {
   let text: string | null = null
   try {
@@ -167,6 +242,7 @@ interface Totals {
   cacheWrite: number
   cost: number
   cacheHitRate: number | null
+  todayCost: number
 }
 
 /** The usage fields this footer totals, read structurally so no cast is needed. */
@@ -178,7 +254,7 @@ type UsageTotals = {
   cost: { total: number }
 }
 
-function collectTotals(ctx: ExtensionContext): Totals {
+function collectTotals(ctx: ExtensionContext, since: number): Totals {
   const totals: Totals = {
     input: 0,
     output: 0,
@@ -186,29 +262,38 @@ function collectTotals(ctx: ExtensionContext): Totals {
     cacheWrite: 0,
     cost: 0,
     cacheHitRate: null,
+    todayCost: 0,
   }
   // `usage` stays optional here even though an assistant message always carries it:
   // a truncated or hand-edited session file is the case this guard is for.
-  const add = (usage: UsageTotals | undefined, assistant: boolean): void => {
+  const add = (usage: UsageTotals | undefined, assistant: boolean, isToday: boolean): void => {
     if (!usage) return
     totals.input += usage.input
     totals.output += usage.output
     totals.cacheRead += usage.cacheRead
     totals.cacheWrite += usage.cacheWrite
     totals.cost += usage.cost.total
+    if (isToday) totals.todayCost += usage.cost.total
     if (!assistant) return
     const prompt = usage.input + usage.cacheRead + usage.cacheWrite
     if (prompt > 0) totals.cacheHitRate = (usage.cacheRead / prompt) * 100
   }
   for (const entry of ctx.sessionManager.getEntries()) {
+    const stamp =
+      'timestamp' in entry && typeof entry.timestamp === 'string'
+        ? Date.parse(entry.timestamp)
+        : Number.NaN
+    const isToday = Number.isFinite(stamp) && stamp >= since
     if (entry.type === 'message') {
       const { message } = entry
-      if (message.role === 'assistant') add(message.usage, true)
-      else if (message.role === 'toolResult') add(message.usage, false)
+      if (message.role === 'assistant') add(message.usage, true, isToday)
+      else if (message.role === 'toolResult') add(message.usage, false, isToday)
       continue
     }
     // Compaction and branch summaries bill a model call of their own.
-    if (entry.type === 'compaction' || entry.type === 'branch_summary') add(entry.usage, false)
+    if (entry.type === 'compaction' || entry.type === 'branch_summary') {
+      add(entry.usage, false, isToday)
+    }
   }
   return totals
 }
@@ -240,6 +325,8 @@ export default function (pi: ExtensionAPI) {
   let requestAt: number | null = null
   let firstTokenAt: number | null = null
   let totalDecodeMs = 0
+  let totalMeasuredOutput = 0
+  let todayBase = 0
   let ticker: ReturnType<typeof setInterval> | null = null
   let windowAt = 0
   let windowTokens = 0
@@ -289,8 +376,8 @@ export default function (pi: ExtensionAPI) {
         },
         render(width: number): string[] {
           const usage = ctx.getContextUsage()
-          const totals = collectTotals(ctx)
-          const avg = avgTokPerSec(totals.output, totalDecodeMs)
+          const totals = collectTotals(ctx, startOfToday())
+          const avg = avgTokPerSec(totalMeasuredOutput, totalDecodeMs)
           const row1 = contextRow(
             theme,
             width,
@@ -302,6 +389,7 @@ export default function (pi: ExtensionAPI) {
               output: totals.output,
               cacheHitRate: totals.cacheHitRate,
               cost: totals.cost,
+              todayCost: todayBase + totals.todayCost,
             },
             currency,
           )
@@ -388,9 +476,12 @@ export default function (pi: ExtensionAPI) {
     reading = null
     requestAt = null
     totalDecodeMs = 0
+    totalMeasuredOutput = 0
     stopTicker()
     resetStream()
     currency = await loadCurrency((message) => ctx.ui.notify(message, 'warning'))
+    const file = ctx.sessionManager.getSessionFile()
+    todayBase = await sumOtherTodaysCost(file ?? null, startOfToday())
     installFooter(ctx)
   })
 
@@ -470,8 +561,11 @@ export default function (pi: ExtensionAPI) {
     const measured = ttftMs(requestAt, firstTokenAt)
     const tokens = output > 0 ? output : totalChars * (ratio ?? FALLBACK_TOKENS_PER_CHAR)
     if (measured !== null && decodeMs >= MIN_SAMPLE_MS) {
-      // Session-average numerator lives in collectTotals; this is its denominator.
+      // The average's numerator and denominator must cover the same messages: totals.output spans
+      // the whole session (a reload replays none of it), so pairing it with the partial denominator
+      // below once produced an Avg of 4324 tok/s.
       totalDecodeMs += decodeMs
+      if (output > 0) totalMeasuredOutput += output
       publish((tokens / decodeMs) * 1000, output > 0, measured)
     }
     // Null it with the stream: a request that has produced its message is no longer in flight, and

package/extensions/statusline/render.ts

@@ -143,13 +143,18 @@ export const USD: Currency = { symbol: '$', perUsd: 1 }
 
 /** Currencies the config can name by `code` alone. Anything else needs an explicit `symbol`. */
 const CURRENCY_SYMBOLS: Record<string, string> = {
+  AUD: 'A$',
+  CAD: 'CA$',
+  CHF: 'CHF',
   CNY: '¥',
   EUR: '€',
   GBP: '£',
   HKD: 'HK$',
   INR: '₹',
-  JPY: '¥',
+  // ¥ is CNY's by default; JPY wears the prefixed form so the two never trade places.
+  JPY: 'JP¥',
   KRW: '₩',
+  NZD: 'NZ$',
   RMB: '¥',
   SGD: 'S$',
   TWD: 'NT$',
@@ -392,6 +397,8 @@ export interface ContextRowParts {
   output: number
   cacheHitRate: number | null
   cost: number
+  /** Today's spend across every session on this machine, or 0 to hide the slot. */
+  todayCost: number
 }
 
 /**
@@ -416,7 +423,8 @@ export function contextRow(
   const fraction = parts.percent === null ? 0 : parts.percent / 100
   const percent = theme.fg(
     percentColor(parts.percent),
-    parts.percent === null ? '?' : `${parts.percent.toFixed(1)}%`,
+    // Whole percents: the meter carries the precision, and a decimal here is noise.
+    parts.percent === null ? '?' : `${Math.round(parts.percent)}%`,
   )
   const meter = `${theme.fg('dim', 'Context')}  ${bar(theme, BAR_CELLS, fraction)}  ${percent}`
   const detail =
@@ -432,6 +440,9 @@ export function contextRow(
     outcomes.push(pair(theme, 'Cache hit', `${parts.cacheHitRate.toFixed(1)}%`))
   }
   if (parts.cost > 0) outcomes.push(pair(theme, 'Cost', formatCost(parts.cost, currency)))
+  if (parts.todayCost > 0) {
+    outcomes.push(pair(theme, 'Today', formatCost(parts.todayCost, currency)))
+  }
 
   const separator = theme.fg('dim', '  ·  ')
   const full = [...volumes, ...outcomes].join(separator)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reedchan/statusline",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "description": "Replaces pi's footer with a labelled two-row status line: context pressure as a fixed-size meter, cache and cost, the model and effort level, and the latest turn's TTFT and decode throughput in tokens/second.",
   "keywords": [
     "bun",