pi-deepseek-tariff 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Valderan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,129 @@
-# Temporary Holding Version
+# pi-deepseek-tariff
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm](https://img.shields.io/npm/v/pi-deepseek-tariff?color=blue)](https://www.npmjs.com/package/pi-deepseek-tariff)
+[![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![pi-package](https://img.shields.io/badge/pi-package-8a2be2)](https://pi.dev/packages)
+
+A [pi](https://pi.dev) extension that shows the current **DeepSeek API tariff window** — peak or off-peak — with a countdown, and a panel with live prices parsed from the official DeepSeek pricing page.
+
+DeepSeek charges double during peak hours, so knowing the current window is worth real money.
+
+```
+Now OFF-PEAK
+Computer: 14:43:52 26-10-2026(MSK) | UTC: 2026-10-26 11:43
+Next window: 04:00 - 07:00 27-10-2026(MSK) in 13h 16m
+DeepSeek prices: $ per 1M tokens, active: OFF-PEAK
+  deepseek:deepseek-flash  ← active
+      PEAK      hit   0.0060  miss   0.3000  out   1.2000
+    ▸ OFF-PEAK  hit   0.0030  miss   0.1500  out   0.6000
+  deepseek:deepseek-v4-pro
+      PEAK      hit   0.0440  miss   1.3200  out   3.9600
+    ▸ OFF-PEAK  hit   0.0220  miss   0.6600  out   1.9800
+  Search & Fetch: $0.75 per 1,000 successful requests
+────────────────────────────────────────────────────────────
+Peak windows (MSK): 04:00-07:00 and 09:00-13:00, Mon-Fri
+Off-peak = night, weekends and Chinese holidays
+Price source: api-docs.deepseek.com, updated 11:20 26-10 (next in 5h 59m)
+────────────────────────────────────────────────────────────
+Commands: /deepseek-peak on|off|refresh|en|ru
+```
+
+## Install
+
+```bash
+# from git (tags are pinned)
+pi install git:github.com/valderan/pi-deepseek-tariff@v0.1.0
+
+# from npm
+pi install npm:pi-deepseek-tariff
+
+# local checkout, for development
+git clone git@github.com:valderan/pi-deepseek-tariff.git
+pi install ./pi-deepseek-tariff
+
+# try it for one run without touching settings
+pi -e ./pi-deepseek-tariff
+```
+
+Then run `/deepseek-peak`. Afterwards `pi list`, `pi update --extensions`, `pi remove …` manage it like any other package.
+
+## Commands
+
+| Command | Effect |
+|---|---|
+| `/deepseek-peak` | toggle the panel |
+| `/deepseek-peak on` / `off` | show or hide it |
+| `/deepseek-peak refresh` | re-parse prices from the docs page now |
+| `/deepseek-peak en` / `ru` | switch the panel language (persisted) |
+
+## What it does
+
+- **Footer line** — `deepseek: PEAK → off-peak 13:00 (1h 40m)`. Shown only while a DeepSeek model is active; red for peak, green for off-peak.
+- **Peak rules** — DeepSeek defines peak as `01:00-04:00` and `06:00-10:00` **UTC, Monday to Friday**; weekends and Chinese public holidays are off-peak all day.
+- **Local time everywhere** — the UTC clock comes from the machine clock, so peak windows, weekday labels and countdowns are rendered in *your* zone (`(MSK)`, `(UTC-04:00)`, …). Weekday labels shift with the zone: at UTC−4 the windows land on Sun–Thu.
+- **Prices** — parsed from `api-docs.deepseek.com/quick_start/pricing/`: cache hit, cache miss and output per model, plus the Search & Fetch request rates. The tariff in effect is highlighted.
+- **Caching** — the page is parsed at most once per `pricingTtlHours` (default 6), and the result is cached on disk, so restarts stay offline. `PI_OFFLINE` disables network access entirely and the panel falls back to built-in values.
+
+## Configuration
+
+`<agent-dir>/deepseek-peak.json` — `PI_CODING_AGENT_DIR`, default `~/.pi/agent`. The file is created only when you switch the language.
+
+```json
+{
+  "language": "ru",
+  "intervalMs": 30000,
+  "pricingTtlHours": 6,
+  "alwaysShow": false,
+  "models": ["deepseek"],
+  "providerPrefix": "deepseek:",
+  "holidays": ["2026-10-01", "2026-10-02"]
+}
+```
+
+| Key | Default | Meaning |
+|---|---|---|
+| `language` | pi's `settings.json` language, else `en` | `"en"` or `"ru"` |
+| `intervalMs` | `30000` | minimum refresh cadence (clamped to ≥ 5000) |
+| `pricingTtlHours` | `6` | how long parsed prices stay valid |
+| `alwaysShow` | `false` | show the footer line for non-DeepSeek models too |
+| `models` | `["deepseek"]` | id substrings that count as DeepSeek |
+| `providerPrefix` | `"deepseek:"` | prefix used when printing model ids |
+| `holidays` | `[]` | Chinese public holidays as Beijing dates (`YYYY-MM-DD`), off-peak all day |
+
+Chinese holidays are announced yearly and are not computed, so keep the list current. Prices are parsed automatically; if DeepSeek changes the page markup the parser returns nothing and the extension keeps the last good values.
+
+## Development
+
+```bash
+git clone git@github.com:valderan/pi-deepseek-tariff.git
+cd pi-deepseek-tariff
+npm test            # node:test, no dependencies required
+npm run typecheck   # needs `npm install` for the pi type packages
+```
+
+Layout:
+
+```
+extensions/deepseek-peak.ts   pi entry point (UI, events, commands)
+src/rules.ts                  peak rules, local time formatting (pure)
+src/pricing.ts                page parsing + TTL/disk cache (pure, injectable fetch)
+src/view.ts                   footer line and panel rendering
+src/config.ts                 config file, agent-dir paths
+src/i18n.ts                   English and Russian strings
+test/                         node:test suites + captured page fixture
+```
+
+The rules and parsing modules are pure and take injectable inputs, so tests never touch the network or a TUI. `test/fixtures/pricing.html` is a captured copy of the pricing tables; refresh it when DeepSeek changes the page.
+
+## Release
+
+```bash
+git tag -a v0.1.0 -m "v0.1.0"
+git push origin main --tags
+```
+
+Tags are pinnable with `pi install git:…@v0.1.0`. Publishing to npm (`.github/workflows/ci.yml` runs it on a `v*` tag) puts the package into the [pi package gallery](https://pi.dev/packages).
+
+## License
+
+MIT

package/extensions/deepseek-peak.ts

@@ -0,0 +1,157 @@
+/**
+ * DeepSeek Peak / Off-Peak tariff panel for pi.
+ *
+ * Footer status line: current tariff window and countdown to the next switch.
+ * `/deepseek-peak` opens a panel with the local/UTC clock, the next window,
+ * per-model prices and Search & Fetch request pricing parsed from the official
+ * DeepSeek pricing page, plus reference notes.
+ *
+ * https://api-docs.deepseek.com/quick_start/pricing/
+ */
+
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { loadConfig, PRICING_CACHE, saveConfig, type Config } from "../src/config.ts";
+import { STRINGS, type Lang } from "../src/i18n.ts";
+import { createPricingStore, isOffline, type Pricing } from "../src/pricing.ts";
+import { SEPARATOR, panelLines, statusText } from "../src/view.ts";
+
+const STATUS_KEY = "deepseek-peak";
+const WIDGET_KEY = "deepseek-peak";
+
+export default function deepseekPeak(pi: ExtensionAPI) {
+	let config = loadConfig();
+	let lang: Lang = config.language ?? "en";
+	let timer: ReturnType<typeof setInterval> | undefined;
+	let panelVisible = false;
+
+	const pricing = createPricingStore({
+		cachePath: PRICING_CACHE,
+		ttlMs: config.pricingTtlHours * 60 * 60 * 1000,
+		offline: isOffline(),
+	});
+
+	const ttlMs = () => config.pricingTtlHours * 60 * 60 * 1000;
+
+	const isDeepSeekModel = (ctx: ExtensionContext | ExtensionCommandContext) => {
+		const id = ctx.model?.id.toLowerCase();
+		if (!id) return false;
+		return config.models.some((needle) => id.includes(needle));
+	};
+
+	const renderFooter = (ctx: ExtensionContext | ExtensionCommandContext, current: Pricing = pricing.get()) => {
+		if (!config.alwaysShow && !isDeepSeekModel(ctx)) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			return;
+		}
+		const theme: Theme | undefined = (ctx.ui as { theme?: Theme }).theme;
+		if (!theme) return;
+		ctx.ui.setStatus(STATUS_KEY, statusText(theme, config, lang, current));
+	};
+
+	const renderPanel = (ctx: ExtensionContext | ExtensionCommandContext, current: Pricing = pricing.get()) => {
+		if (!panelVisible) return;
+		const currentModel = ctx.model?.id;
+		ctx.ui.setWidget(
+			WIDGET_KEY,
+			(_tui, theme) => {
+				const lines = panelLines(theme, {
+					config,
+					lang,
+					currentModel,
+					pricing: current,
+					ttlMs: ttlMs(),
+				});
+				return {
+					invalidate() {},
+					render(width: number) {
+						const rule = theme.fg("dim", "─".repeat(Math.max(0, width)));
+						return lines.map((line) => (line === SEPARATOR ? rule : truncateToWidth(line, width)));
+					},
+				};
+			},
+			{ placement: "belowEditor" },
+		);
+	};
+
+	const render = (ctx: ExtensionContext | ExtensionCommandContext, current: Pricing = pricing.get()) => {
+		renderFooter(ctx, current);
+		renderPanel(ctx, current);
+	};
+
+	const stop = () => {
+		if (timer !== undefined) clearInterval(timer);
+		timer = undefined;
+	};
+
+	const start = (ctx: ExtensionContext) => {
+		stop();
+		render(ctx);
+		timer = setInterval(() => {
+			// Only hits the network when the TTL expired.
+			if (!pricing.expired()) {
+				render(ctx);
+				return;
+			}
+			void pricing.refresh().then((value) => render(ctx, value));
+		}, config.intervalMs);
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		config = loadConfig();
+		lang = config.language ?? "en";
+		pricing.setTtl(ttlMs());
+		pricing.loadCache();
+		start(ctx);
+		void pricing.refresh().then((value) => render(ctx, value));
+	});
+
+	pi.on("session_shutdown", async (_event, ctx) => {
+		stop();
+		panelVisible = false;
+		ctx.ui.setWidget(WIDGET_KEY, undefined);
+		ctx.ui.setStatus(STATUS_KEY, undefined);
+	});
+
+	// The model can change mid-session, so refresh on the cheap lifecycle hooks too.
+	pi.on("agent_start", async (_event, ctx) => render(ctx));
+	pi.on("turn_start", async (_event, ctx) => render(ctx));
+
+	pi.registerCommand("deepseek-peak", {
+		description: "DeepSeek peak/off-peak panel · Панель DeepSeek peak/off-peak",
+		handler: async (args, ctx) => {
+			config = loadConfig();
+			lang = config.language ?? "en";
+			pricing.setTtl(ttlMs());
+			const arg = args.trim().toLowerCase();
+
+			if (arg === "ru" || arg === "en") {
+				lang = arg;
+				config.language = arg;
+				saveConfig({ language: arg });
+				panelVisible = true;
+				render(ctx);
+				return;
+			}
+
+			if (arg === "off" || (arg === "" && panelVisible)) {
+				panelVisible = false;
+				ctx.ui.setWidget(WIDGET_KEY, undefined);
+				renderFooter(ctx);
+				return;
+			}
+
+			if (arg === "refresh") {
+				const value = await pricing.refresh(true);
+				panelVisible = true;
+				render(ctx, value);
+				return;
+			}
+
+			panelVisible = true;
+			render(ctx);
+		},
+	});
+}
+
+export { STRINGS };

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "pi-deepseek-tariff",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "DeepSeek peak/off-peak tariff panel for pi: local clock, next window, live per-model prices and Search & Fetch rates",
+  "keywords": [
+    "pi-package",
+    "pi-extension",
+    "deepseek",
+    "pricing",
+    "tariff",
+    "statusline"
+  ],
+  "license": "MIT",
+  "author": "Valderan",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/valderan/pi-deepseek-tariff.git"
+  },
+  "homepage": "https://github.com/valderan/pi-deepseek-tariff#readme",
+  "bugs": {
+    "url": "https://github.com/valderan/pi-deepseek-tariff/issues"
+  },
+  "type": "module",
+  "files": [
+    "extensions",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/deepseek-peak.ts"
+    ]
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "^1.4.0",
+    "@earendil-works/pi-tui": "^1.4.0",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=22.6.0"
+  },
+  "scripts": {
+    "test": "node --test",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/config.ts

@@ -0,0 +1,92 @@
+/**
+ * Configuration and well-known paths.
+ *
+ * Paths honour PI_CODING_AGENT_DIR so non-default Pi installations keep their
+ * own config and cache instead of writing into ~/.pi/agent.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { normalizeLang, type Lang } from "./i18n.ts";
+import { DEFAULT_TTL_HOURS } from "./pricing.ts";
+
+export const AGENT_DIR = process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent");
+export const CONFIG_PATH = join(AGENT_DIR, "deepseek-peak.json");
+export const SETTINGS_PATH = join(AGENT_DIR, "settings.json");
+export const PRICING_CACHE = join(AGENT_DIR, "cache", "deepseek-peak-pricing.json");
+
+export type Config = {
+	language?: Lang;
+	intervalMs: number;
+	pricingTtlHours: number;
+	alwaysShow: boolean;
+	models: string[];
+	providerPrefix: string;
+	holidays: Set<string>;
+};
+
+/** Language from the pi settings, so the panel follows the interface language. */
+export function settingsLanguage(): Lang {
+	try {
+		const raw = JSON.parse(readFileSync(SETTINGS_PATH, "utf8")) as { language?: unknown };
+		return normalizeLang(raw.language) ?? "en";
+	} catch {
+		return "en";
+	}
+}
+
+export function loadConfig(): Config {
+	const config: Config = {
+		intervalMs: 30_000,
+		pricingTtlHours: DEFAULT_TTL_HOURS,
+		alwaysShow: false,
+		models: ["deepseek"],
+		providerPrefix: "deepseek:",
+		holidays: new Set<string>(),
+	};
+
+	try {
+		const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8")) as Record<string, unknown>;
+		config.language = normalizeLang(raw.language);
+		if (typeof raw.intervalMs === "number" && raw.intervalMs >= 5_000) config.intervalMs = raw.intervalMs;
+		if (typeof raw.pricingTtlHours === "number" && raw.pricingTtlHours > 0) {
+			config.pricingTtlHours = raw.pricingTtlHours;
+		}
+		if (typeof raw.alwaysShow === "boolean") config.alwaysShow = raw.alwaysShow;
+		if (typeof raw.providerPrefix === "string" && raw.providerPrefix.length > 0) {
+			config.providerPrefix = raw.providerPrefix;
+		}
+		if (Array.isArray(raw.models)) {
+			const models = raw.models.filter((m): m is string => typeof m === "string" && m.length > 0);
+			if (models.length > 0) config.models = models.map((m) => m.toLowerCase());
+		}
+		if (Array.isArray(raw.holidays)) {
+			for (const day of raw.holidays) {
+				if (typeof day === "string" && /^\d{4}-\d{2}-\d{2}$/.test(day)) config.holidays.add(day);
+			}
+		}
+	} catch {
+		// A missing or malformed config keeps the defaults.
+	}
+
+	config.language ??= settingsLanguage();
+	return config;
+}
+
+/** Persist a single config key without dropping user-authored ones. */
+export function saveConfig(patch: Record<string, unknown>) {
+	try {
+		let current: Record<string, unknown> = {};
+		try {
+			current = JSON.parse(readFileSync(CONFIG_PATH, "utf8")) as Record<string, unknown>;
+		} catch {
+			current = {};
+		}
+		const next = { ...current, ...patch };
+		mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+		writeFileSync(CONFIG_PATH, `${JSON.stringify(next, null, 2)}\n`);
+	} catch {
+		// Persisting is best effort; the session keeps the in-memory value.
+	}
+}

package/src/i18n.ts

@@ -0,0 +1,106 @@
+/**
+ * Localization for the DeepSeek tariff panel.
+ *
+ * Add a language by extending `Lang`, `STRINGS` and `DAY_NAMES`.
+ */
+
+export type Lang = "en" | "ru";
+
+export function normalizeLang(value: unknown): Lang | undefined {
+	if (typeof value !== "string") return undefined;
+	const lower = value.trim().toLowerCase();
+	if (lower.startsWith("ru")) return "ru";
+	if (lower.startsWith("en")) return "en";
+	return undefined;
+}
+
+type Strings = {
+	peakTitle: string;
+	offPeakTitle: string;
+	holiday: string;
+	computer: string;
+	nextWindow: string;
+	nextIn: (duration: string) => string;
+	and: string;
+	prices: string;
+	pricesState: (state: string) => string;
+	activeModel: string;
+	peakWindows: (zone: string) => string;
+	peakDays: string;
+	offPeak: string;
+	offPeakNote: string;
+	priceSource: string;
+	sourceLive: (when: string, next: string) => string;
+	sourceBuiltin: string;
+	requestPricing: string;
+	commands: string;
+	locale: string;
+	hourUnit: string;
+	minuteUnit: string;
+};
+
+export const STRINGS: Record<Lang, Strings> = {
+	en: {
+		peakTitle: "Warning: Now PEAK",
+		offPeakTitle: "Now OFF-PEAK",
+		holiday: " (Chinese holiday)",
+		computer: "Computer:",
+		nextWindow: "Next window:",
+		nextIn: (duration) => `in ${duration}`,
+		and: "and",
+		prices: "DeepSeek prices:",
+		pricesState: (state) => `$ per 1M tokens, active: ${state}`,
+		activeModel: "← active",
+		peakWindows: (zone) => `Peak windows (${zone}):`,
+		peakDays: "Mon-Fri",
+		offPeak: "Off-peak",
+		offPeakNote: "= night, weekends and Chinese holidays",
+		priceSource: "Price source:",
+		sourceLive: (when, next) => `api-docs.deepseek.com, updated ${when} (next in ${next})`,
+		sourceBuiltin: "built-in values (page unavailable)",
+		requestPricing: "Search & Fetch:",
+		commands: "Commands:",
+		locale: "en-GB",
+		hourUnit: "h",
+		minuteUnit: "m",
+	},
+	ru: {
+		peakTitle: "Warning: Сейчас: PEAK",
+		offPeakTitle: "Сейчас: OFF-PEAK",
+		holiday: " (праздник Китая)",
+		computer: "Компьютер:",
+		nextWindow: "Следующее окно:",
+		nextIn: (duration) => `через ${duration}`,
+		and: "и",
+		prices: "Цены DeepSeek:",
+		pricesState: (state) => `$ за 1M токенов, активен ${state}`,
+		activeModel: "← активна",
+		peakWindows: (zone) => `Окна peak (${zone}):`,
+		peakDays: "пн-пт",
+		offPeak: "Off-peak",
+		offPeakNote: "= ночь, выходные и праздники Китая",
+		priceSource: "Источник цен:",
+		sourceLive: (when, next) => `api-docs.deepseek.com, обновлено ${when} (следующее через ${next})`,
+		sourceBuiltin: "встроенные значения (страница недоступна)",
+		requestPricing: "Search & Fetch:",
+		commands: "Команды:",
+		locale: "ru-RU",
+		hourUnit: "ч",
+		minuteUnit: "м",
+	},
+};
+
+export const DAY_NAMES: Record<Lang, string[]> = {
+	en: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+	ru: ["вс", "пн", "вт", "ср", "чт", "пт", "сб"],
+};
+
+/** Translate the docs unit cell ("Per 1,000 successful requests") for display. */
+export function localizeUnit(unit: string, lang: Lang): string {
+	if (lang === "ru") {
+		if (/1,?000/.test(unit) && /request/i.test(unit)) return "за 1,000 успешных запросов";
+		return unit;
+	}
+	// The page capitalizes the cell; inline text reads better lower-case.
+	return unit.length > 0 ? unit.charAt(0).toLowerCase() + unit.slice(1) : unit;
+}

package/src/pricing.ts

@@ -0,0 +1,289 @@
+/**
+ * DeepSeek pricing: parsing of the official docs page plus a small TTL cache.
+ *
+ * The page is parsed at most once per TTL (default 6 hours). Parsed values are
+ * cached on disk so a restart does not hit the network either.
+ */
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export type Tariff = { cacheHit: number; cacheMiss: number; output: number };
+export type ModelPricing = { peak: Tariff; offPeak: Tariff };
+export type RequestPricing = { api: string; unit: string; price: number };
+export type Pricing = {
+	models: Record<string, ModelPricing>;
+	requests: RequestPricing[];
+	fetchedAt: number;
+	source: "live" | "cache" | "builtin";
+};
+
+export const PRICING_URL = "https://api-docs.deepseek.com/quick_start/pricing/";
+export const DEFAULT_TTL_HOURS = 6;
+
+/** Values from the docs page at the time this package was written. */
+export const BUILTIN_PRICING: Record<string, ModelPricing> = {
+	"deepseek-flash": {
+		peak: { cacheHit: 0.006, cacheMiss: 0.3, output: 1.2 },
+		offPeak: { cacheHit: 0.003, cacheMiss: 0.15, output: 0.6 },
+	},
+	"deepseek-v4-pro": {
+		peak: { cacheHit: 0.044, cacheMiss: 1.32, output: 3.96 },
+		offPeak: { cacheHit: 0.022, cacheMiss: 0.66, output: 1.98 },
+	},
+};
+
+export const BUILTIN_REQUESTS: RequestPricing[] = [
+	{ api: "Search", unit: "per 1,000 successful requests", price: 0.75 },
+	{ api: "Fetch", unit: "per 1,000 successful requests", price: 0.75 },
+];
+
+// ------------------------------------------------------------------- parsing
+
+function textOf(html: string): string {
+	return html
+		.replace(/<[^>]*>/g, " ")
+		.replace(/&nbsp;/gi, " ")
+		.replace(/&amp;/gi, "&")
+		.replace(/&lt;/gi, "<")
+		.replace(/&gt;/gi, ">")
+		.replace(/&quot;/gi, '"')
+		.replace(/&#(\d+);/g, (_match, code: string) => String.fromCodePoint(Number(code)))
+		.replace(/\s+/g, " ")
+		.trim();
+}
+
+function money(text: string): number | undefined {
+	if (/free/i.test(text)) return 0;
+	const value = Number(text.replace(/[^0-9.]/g, ""));
+	return Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function tableRows(table: string): string[][] {
+	return [...table.matchAll(/<tr[\s\S]*?<\/tr>/gi)].map((row) =>
+		[...row[0].matchAll(/<t[hd][\s\S]*?<\/t[hd]>/gi)].map((cell) => textOf(cell[0])),
+	);
+}
+
+function tables(html: string): string[] {
+	return [...html.matchAll(/<table[\s\S]*?<\/table>/gi)].map((match) => match[0]);
+}
+
+const PRICE_FIELDS: ReadonlyArray<readonly [RegExp, keyof Tariff]> = [
+	[/input tokens \(cache hit\)/i, "cacheHit"],
+	[/input tokens \(cache miss\)/i, "cacheMiss"],
+	[/output tokens/i, "output"],
+];
+
+/** Parse the per-model pricing table. Returns undefined when the table is absent. */
+export function parsePricing(html: string): Record<string, ModelPricing> | undefined {
+	for (const table of tables(html)) {
+		const rows = tableRows(table);
+		const header = rows.find((cells) => cells.some((cell) => /^model$/i.test(cell)));
+		if (!header) continue;
+
+		const headerStart = header.findIndex((cell) => /^model$/i.test(cell)) + 1;
+		const names = header
+			.slice(headerStart)
+			.map((cell) => cell.replace(/\s*\(\d+\)\s*$/, "").trim())
+			.filter((name) => name.length > 0);
+		if (names.length === 0) continue;
+
+		const empty = (): Tariff => ({ cacheHit: Number.NaN, cacheMiss: Number.NaN, output: Number.NaN });
+		const parsed: Record<string, ModelPricing> = {};
+		for (const name of names) parsed[name] = { peak: empty(), offPeak: empty() };
+
+		let field: keyof Tariff | undefined;
+		for (const cells of rows) {
+			for (const cell of cells) {
+				const match = PRICE_FIELDS.find(([pattern]) => pattern.test(cell));
+				if (match) field = match[1];
+			}
+			const tariffIndex = cells.findIndex((cell) => /^(off[\s-]?peak|peak)$/i.test(cell));
+			if (!field || tariffIndex < 0) continue;
+
+			const currentField = field;
+			const tariff: keyof ModelPricing = /^off/i.test(cells[tariffIndex]) ? "offPeak" : "peak";
+			const values = cells.slice(tariffIndex + 1).map(money);
+			names.forEach((name, index) => {
+				const value = values[index];
+				if (value !== undefined) parsed[name][tariff][currentField] = value;
+			});
+		}
+
+		const complete = Object.entries(parsed).filter(([, model]) =>
+			[model.peak, model.offPeak].every(
+				(tariff) =>
+					Number.isFinite(tariff.cacheHit) &&
+					Number.isFinite(tariff.cacheMiss) &&
+					Number.isFinite(tariff.output),
+			),
+		);
+		if (complete.length > 0) return Object.fromEntries(complete);
+	}
+	return undefined;
+}
+
+/** Parse the Search / Fetch request pricing table. */
+export function parseRequestPricing(html: string): RequestPricing[] {
+	for (const table of tables(html)) {
+		const rows = tableRows(table);
+		const header = rows.find((cells) => cells.some((cell) => /^api$/i.test(cell)));
+		if (!header) continue;
+		const apiIndex = header.findIndex((cell) => /^api$/i.test(cell));
+		const unitIndex = header.findIndex((cell) => /^unit$/i.test(cell));
+		const priceIndex = header.findIndex((cell) => /^price$/i.test(cell));
+		if (unitIndex < 0 || priceIndex < 0) continue;
+
+		const entries: RequestPricing[] = [];
+		for (const cells of rows) {
+			const api = cells[apiIndex] ?? "";
+			if (!/^[A-Za-z][A-Za-z &/-]{1,30}$/.test(api) || /^api$/i.test(api)) continue;
+			const price = money(cells[priceIndex] ?? "");
+			if (price === undefined) continue;
+			entries.push({ api: api.trim(), unit: (cells[unitIndex] ?? "").trim(), price });
+		}
+		if (entries.length > 0) return entries;
+	}
+	return [];
+}
+
+// --------------------------------------------------------------------- cache
+
+export type PricingStoreOptions = {
+	cachePath: string;
+	ttlMs?: number;
+	/** PI_OFFLINE and friends: never touch the network. */
+	offline?: boolean;
+	fetchImpl?: typeof fetch;
+};
+
+export type PricingStore = {
+	get(): Pricing;
+	/** True when the parsed values are missing or older than the TTL. */
+	expired(): boolean;
+	/** Load the on-disk cache once, so a restart does not need the network. */
+	loadCache(): Pricing;
+	/** Parse the page when the TTL expired, or always with `force`. */
+	refresh(force?: boolean): Promise<Pricing>;
+	setTtl(ms: number): void;
+};
+
+export function createPricingStore(options: PricingStoreOptions): PricingStore {
+	const { cachePath } = options;
+	const fetchImpl = options.fetchImpl ?? fetch;
+	const offline = options.offline ?? false;
+	let ttlMs = options.ttlMs ?? DEFAULT_TTL_HOURS * 60 * 60 * 1000;
+	let loading = false;
+	let pricing: Pricing = {
+		models: BUILTIN_PRICING,
+		requests: BUILTIN_REQUESTS,
+		fetchedAt: 0,
+		source: "builtin",
+	};
+
+	const readCache = (): Pricing | undefined => {
+		try {
+			const raw = JSON.parse(readFileSync(cachePath, "utf8")) as {
+				models?: unknown;
+				requests?: unknown;
+				fetchedAt?: unknown;
+			};
+			if (!raw.models || typeof raw.models !== "object") return undefined;
+			const models = raw.models as Record<string, ModelPricing>;
+			const valid = Object.values(models).every(
+				(model) =>
+					typeof model?.peak?.cacheMiss === "number" &&
+					typeof model?.offPeak?.cacheMiss === "number" &&
+					typeof model?.peak?.output === "number" &&
+					typeof model?.offPeak?.output === "number",
+			);
+			if (!valid) return undefined;
+			const requests = Array.isArray(raw.requests)
+				? (raw.requests as RequestPricing[]).filter(
+						(entry) => typeof entry?.api === "string" && typeof entry?.price === "number",
+					)
+				: [];
+			return {
+				models,
+				requests: requests.length > 0 ? requests : BUILTIN_REQUESTS,
+				fetchedAt: typeof raw.fetchedAt === "number" ? raw.fetchedAt : 0,
+				source: "cache",
+			};
+		} catch {
+			return undefined;
+		}
+	};
+
+	const writeCache = (value: Pricing) => {
+		try {
+			mkdirSync(dirname(cachePath), { recursive: true });
+			writeFileSync(
+				cachePath,
+				`${JSON.stringify({ models: value.models, requests: value.requests, fetchedAt: value.fetchedAt }, null, 2)}\n`,
+			);
+		} catch {
+			// The cache is an optimization only.
+		}
+	};
+
+	const expired = () => pricing.source === "builtin" || Date.now() - pricing.fetchedAt >= ttlMs;
+
+	const refresh = async (force = false): Promise<Pricing> => {
+		const fresh = pricing.source !== "builtin" && Date.now() - pricing.fetchedAt < ttlMs;
+		if (!force && fresh) return pricing;
+		if (loading) return pricing;
+		if (offline) return pricing;
+
+		loading = true;
+		try {
+			const response = await fetchImpl(PRICING_URL, {
+				headers: { accept: "text/html", "user-agent": "pi-deepseek-tariff" },
+				signal: AbortSignal.timeout(15_000),
+			});
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			const html = await response.text();
+			const models = parsePricing(html);
+			if (!models) throw new Error("pricing table not found");
+			const requests = parseRequestPricing(html);
+			pricing = {
+				models,
+				requests: requests.length > 0 ? requests : BUILTIN_REQUESTS,
+				fetchedAt: Date.now(),
+				source: "live",
+			};
+			writeCache(pricing);
+		} catch {
+			if (pricing.source === "builtin") {
+				const cached = readCache();
+				if (cached) pricing = cached;
+			}
+		} finally {
+			loading = false;
+		}
+		return pricing;
+	};
+
+	return {
+		get: () => pricing,
+		expired,
+		loadCache: () => {
+			if (pricing.source === "builtin") {
+				const cached = readCache();
+				if (cached) pricing = cached;
+			}
+			return pricing;
+		},
+		refresh,
+		setTtl: (ms: number) => {
+			if (Number.isFinite(ms) && ms > 0) ttlMs = ms;
+		},
+	};
+}
+
+/** PI_OFFLINE disables automatic network activity; treat 0/false/no as "online". */
+export function isOffline(env: NodeJS.ProcessEnv = process.env): boolean {
+	const raw = (env.PI_OFFLINE ?? "").trim().toLowerCase();
+	if (raw === "") return false;
+	return !["0", "false", "no", "off"].includes(raw);
+}

package/src/rules.ts

@@ -0,0 +1,150 @@
+/**
+ * DeepSeek tariff clock rules and local-time formatting.
+ *
+ * https://api-docs.deepseek.com/quick_start/pricing/
+ *   - Peak: 01:00-04:00 and 06:00-10:00 UTC, Monday-Friday
+ *   - Off-peak: all other hours, weekends and Chinese public holidays
+ *
+ * Everything here is pure: pass a `Date`, get numbers or strings back. That
+ * keeps the rules testable without a TUI and without the network.
+ */
+
+import { DAY_NAMES, type Lang } from "./i18n.ts";
+
+/** Peak windows in UTC hours, [start, end). */
+export const PEAK_WINDOWS_UTC: ReadonlyArray<readonly [number, number]> = [
+	[1, 4],
+	[6, 10],
+];
+
+const MAX_SCAN_MINUTES = 8 * 24 * 60;
+
+/** Short zone names, because ICU reports "GMT+3" for most of them. */
+const TZ_ABBREV: Record<string, string> = {
+	"Europe/Moscow": "MSK",
+	"Europe/Minsk": "MSK",
+	"Europe/Kaliningrad": "KGD",
+	"Europe/Samara": "SAMT",
+	"Asia/Yekaterinburg": "YEKT",
+	"Asia/Omsk": "OMST",
+	"Asia/Novosibirsk": "NOVT",
+	"Asia/Krasnoyarsk": "KRAT",
+	"Asia/Irkutsk": "IRKT",
+	"Asia/Yakutsk": "YAKT",
+	"Asia/Vladivostok": "VLAT",
+	"Asia/Magadan": "MAGT",
+	"Asia/Sakhalin": "SAKT",
+	"Asia/Kamchatka": "PETT",
+	"Europe/Kyiv": "EET",
+	"Europe/Kiev": "EET",
+	UTC: "UTC",
+	"Etc/UTC": "UTC",
+};
+
+export const pad2 = (value: number) => String(value).padStart(2, "0");
+
+/** Beijing calendar date (UTC+8) as YYYY-MM-DD. */
+export function beijingDateKey(date: Date): string {
+	const shifted = new Date(date.getTime() + 8 * 60 * 60 * 1000);
+	return shifted.toISOString().slice(0, 10);
+}
+
+export function isHoliday(date: Date, holidays: ReadonlySet<string>): boolean {
+	return holidays.size > 0 && holidays.has(beijingDateKey(date));
+}
+
+export function isPeak(date: Date, holidays: ReadonlySet<string>): boolean {
+	if (isHoliday(date, holidays)) return false;
+	const weekday = date.getUTCDay();
+	if (weekday === 0 || weekday === 6) return false;
+	const hour = date.getUTCHours() + date.getUTCMinutes() / 60;
+	return PEAK_WINDOWS_UTC.some(([start, end]) => hour >= start && hour < end);
+}
+
+/** First minute boundary at which the peak state differs from the state at `from`. */
+export function nextTransition(from: Date, holidays: ReadonlySet<string>): Date {
+	const current = isPeak(from, holidays);
+	const probe = new Date(from.getTime());
+	probe.setUTCSeconds(0, 0);
+	probe.setUTCMinutes(probe.getUTCMinutes() + 1);
+	for (let i = 0; i < MAX_SCAN_MINUTES; i++) {
+		if (isPeak(probe, holidays) !== current) return new Date(probe.getTime());
+		probe.setUTCMinutes(probe.getUTCMinutes() + 1);
+	}
+	return probe;
+}
+
+export type LocalParts = { time: string; hm: string; date: string; short: string };
+
+export function localParts(date: Date): LocalParts {
+	return {
+		time: `${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}`,
+		hm: `${pad2(date.getHours())}:${pad2(date.getMinutes())}`,
+		date: `${pad2(date.getDate())}-${pad2(date.getMonth() + 1)}-${date.getFullYear()}`,
+		short: `${pad2(date.getDate())}-${pad2(date.getMonth() + 1)}`,
+	};
+}
+
+export function utcStamp(date: Date): string {
+	const day = `${date.getUTCFullYear()}-${pad2(date.getUTCMonth() + 1)}-${pad2(date.getUTCDate())}`;
+	return `${day} ${pad2(date.getUTCHours())}:${pad2(date.getUTCMinutes())}`;
+}
+
+export function tzLabel(date: Date): string {
+	const zone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+	const known = TZ_ABBREV[zone];
+	if (known) return known;
+	const part =
+		new Intl.DateTimeFormat("en-GB", { timeZoneName: "short" })
+			.formatToParts(date)
+			.find((item) => item.type === "timeZoneName")?.value ?? "";
+	const offset = part.match(/GMT([+-]\d{1,2})(?::(\d{2}))?/i);
+	if (offset) {
+		const sign = offset[1].startsWith("-") ? "-" : "+";
+		return `UTC${sign}${pad2(Math.abs(Number(offset[1])))}:${offset[2] ?? "00"}`;
+	}
+	return part || "LOCAL";
+}
+
+export function clockTime(date: Date, lang: Lang): string {
+	const locale = lang === "ru" ? "ru-RU" : "en-GB";
+	return date.toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" });
+}
+
+export function humanize(ms: number, lang: Lang = "en"): string {
+	const minutes = Math.max(0, Math.round(ms / 60_000));
+	const hourUnit = lang === "ru" ? "ч" : "h";
+	const minuteUnit = lang === "ru" ? "м" : "m";
+	if (minutes < 60) return `${minutes}${minuteUnit}`;
+	const hours = Math.floor(minutes / 60);
+	const rest = minutes % 60;
+	return rest === 0 ? `${hours}${hourUnit}` : `${hours}${hourUnit} ${rest}${minuteUnit}`;
+}
+
+/** Local wall-clock time of a UTC hour on the machine's current date. */
+export function localClock(date: Date, utcHour: number): string {
+	const instant = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), utcHour, 0, 0));
+	return `${pad2(instant.getHours())}:${pad2(instant.getMinutes())}`;
+}
+
+/** How many calendar days the local clock is ahead of UTC at that hour. */
+export function localDayShift(date: Date, utcHour: number): number {
+	const instant = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), utcHour, 0, 0));
+	const utcDay = Date.UTC(instant.getUTCFullYear(), instant.getUTCMonth(), instant.getUTCDate());
+	const localDay = Date.UTC(instant.getFullYear(), instant.getMonth(), instant.getDate());
+	return Math.round((localDay - utcDay) / 86_400_000);
+}
+
+/** "Mon-Fri" shifted by `shift` days, so the label matches local weekdays. */
+export function dayRangeLabel(shift: number, lang: Lang): string {
+	const names = DAY_NAMES[lang];
+	const start = (1 + shift + 7) % 7;
+	const end = (5 + shift + 7) % 7;
+	return `${names[start]}-${names[end]}`;
+}
+
+/** "04:00-07:00 and 09:00-13:00" for the machine's time zone. */
+export function localPeakWindows(date: Date, lang: Lang): string {
+	const joiner = lang === "ru" ? " и " : " and ";
+	return PEAK_WINDOWS_UTC.map(([from, to]) => `${localClock(date, from)}-${localClock(date, to)}`).join(joiner);
+}

package/src/view.ts

@@ -0,0 +1,159 @@
+/**
+ * Presentation: the footer status line and the panel body.
+ *
+ * Colors follow the pi theme: labels in the warning token, values in the text
+ * token, active rows bold, inactive rows dim.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import type { Config } from "./config.ts";
+import { localizeUnit, STRINGS, type Lang } from "./i18n.ts";
+import type { Pricing, RequestPricing } from "./pricing.ts";
+import {
+	clockTime,
+	dayRangeLabel,
+	humanize,
+	isHoliday,
+	isPeak,
+	localDayShift,
+	localParts,
+	localPeakWindows,
+	nextTransition,
+	PEAK_WINDOWS_UTC,
+	tzLabel,
+	utcStamp,
+} from "./rules.ts";
+
+/** Placeholder for a full-width rule; the renderer expands it to the panel width. */
+export const SEPARATOR = "\u0000rule";
+
+/** "Search & Fetch" value: a shared price is printed once. */
+export function requestPricingText(entries: RequestPricing[], lang: Lang): string | undefined {
+	if (entries.length === 0) return undefined;
+
+	const groups = new Map<string, { price: number; unit: string; apis: string[] }>();
+	for (const entry of entries) {
+		const key = `${entry.price}|${entry.unit}`;
+		const group = groups.get(key) ?? { price: entry.price, unit: entry.unit, apis: [] };
+		group.apis.push(entry.api);
+		groups.set(key, group);
+	}
+
+	const localized = (unit: string) => localizeUnit(unit, lang);
+	const grouped = [...groups.values()];
+
+	if (grouped.length === 1) {
+		const group = grouped[0];
+		return `$${group.price.toFixed(2)} ${localized(group.unit)}`.trim();
+	}
+
+	const sharedUnit = grouped.every((group) => group.unit === grouped[0].unit) ? grouped[0].unit : undefined;
+	const parts = grouped.map(
+		(group) => `${group.apis.join(" / ")} $${group.price.toFixed(2)}${sharedUnit ? "" : ` ${localized(group.unit)}`}`,
+	);
+	return `${parts.join(" · ")}${sharedUnit ? ` ${localized(sharedUnit)}` : ""}`.trim();
+}
+
+export function statusText(theme: Theme, config: Config, lang: Lang, pricing: Pricing): string {
+	void pricing;
+	const now = new Date();
+	const peak = isPeak(now, config.holidays);
+	const next = nextTransition(now, config.holidays);
+	const label = peak ? "PEAK" : "off-peak";
+	const color = theme.fg(peak ? "error" : "success", label);
+	const hint = peak ? "→ off-peak" : "→ peak";
+	const when = `${clockTime(next, lang)} (${humanize(next.getTime() - now.getTime(), lang)})`;
+	return `${theme.fg("dim", "deepseek:")} ${color} ${theme.fg("dim", `${hint} ${when}`)}`;
+}
+
+export function panelLines(
+	theme: Theme,
+	options: { config: Config; lang: Lang; currentModel?: string; pricing: Pricing; ttlMs: number },
+): string[] {
+	const { config, lang, currentModel, pricing, ttlMs } = options;
+	const text = STRINGS[lang];
+	const now = new Date();
+	const peak = isPeak(now, config.holidays);
+	const holiday = isHoliday(now, config.holidays);
+	const next = nextTransition(now, config.holidays);
+	const after = nextTransition(next, config.holidays);
+	const zone = tzLabel(now);
+	const local = localParts(now);
+	const yellow = (value: string) => theme.fg("warning", value);
+	const white = (value: string) => theme.fg("text", value);
+	const state = peak ? "PEAK" : "OFF-PEAK";
+
+	const lines: string[] = [];
+
+	// 1. Current tariff.
+	lines.push(
+		peak
+			? theme.fg("error", text.peakTitle)
+			: theme.fg("success", text.offPeakTitle) + (holiday ? theme.fg("dim", text.holiday) : ""),
+	);
+
+	// 2. Machine clock and UTC.
+	lines.push(`${yellow(text.computer)} ${white(`${local.time} ${local.date}(${zone}) | UTC: ${utcStamp(now)}`)}`);
+
+	// 3. Next window: start - end date(zone) in duration.
+	const start = localParts(next);
+	const end = localParts(after);
+	const windowRange =
+		start.date === end.date
+			? `${start.hm} - ${end.hm} ${end.date}(${zone})`
+			: `${start.hm} ${start.date} - ${end.hm} ${end.date}(${zone})`;
+	lines.push(
+		`${yellow(text.nextWindow)} ${white(`${windowRange} ${text.nextIn(humanize(next.getTime() - now.getTime(), lang))}`)}`,
+	);
+
+	// 4. Model prices with the active tariff highlighted.
+	lines.push(`${yellow(text.prices)} ${white(text.pricesState(state))}`);
+	const value = (amount: number) => amount.toFixed(4).padStart(8);
+	for (const [name, model] of Object.entries(pricing.models)) {
+		const id = `${config.providerPrefix}${name}`;
+		const isCurrent = currentModel === id ? theme.fg("accent", `  ${text.activeModel}`) : "";
+		lines.push(`  ${theme.fg("muted", id)}${isCurrent}`);
+		for (const tariff of ["peak", "offPeak"] as const) {
+			const row = model[tariff];
+			const label = tariff === "peak" ? "PEAK    " : "OFF-PEAK";
+			const body = `${label}  hit ${value(row.cacheHit)}  miss ${value(row.cacheMiss)}  out ${value(row.output)}`;
+			const active = tariff === (peak ? "peak" : "offPeak");
+			lines.push(
+				active
+					? theme.bold(theme.fg(peak ? "error" : "success", `    ▸ ${body}`))
+					: theme.fg("dim", `      ${body}`),
+			);
+		}
+	}
+
+	// 5. Search & Fetch request pricing.
+	const requests = requestPricingText(pricing.requests, lang);
+	if (requests) lines.push(`  ${yellow(text.requestPricing)} ${white(requests)}`);
+
+	// 6. Reference notes, framed by rules.
+	lines.push(SEPARATOR);
+	lines.push(
+		`${theme.fg("dim", text.peakWindows(zone))} ${white(
+			`${localPeakWindows(now, lang)}, ${dayRangeLabel(localDayShift(now, PEAK_WINDOWS_UTC[0][0]), lang)}`,
+		)}`,
+	);
+	lines.push(`${theme.fg("dim", text.offPeak)} ${white(text.offPeakNote)}`);
+
+	// 7. Price source and freshness.
+	let source: string;
+	if (pricing.fetchedAt === 0) {
+		source = text.sourceBuiltin;
+	} else {
+		const when = new Date(pricing.fetchedAt);
+		const stamp = `${localParts(when).hm} ${localParts(when).short}`;
+		const remaining = humanize(Math.max(0, pricing.fetchedAt + ttlMs - Date.now()), lang);
+		source = text.sourceLive(stamp, remaining);
+	}
+	lines.push(`${theme.fg("dim", text.priceSource)} ${white(source)}`);
+	lines.push(SEPARATOR);
+
+	// 8. Command hints.
+	lines.push(`${theme.fg("dim", text.commands)} ${white("/deepseek-peak on|off|refresh|en|ru")}`);
+
+	return lines;
+}