@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/clipboard-paths.test.mjs

@@ -0,0 +1,140 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  fileUriToPath,
+  extractPathsFromClipboardData,
+  formatPathsForInput,
+} = await jiti.import("./clipboard-paths.ts");
+
+test("fileUriToPath parses Unix file URIs", () => {
+  assert.equal(fileUriToPath("file:///home/user/project/file.txt"), "/home/user/project/file.txt");
+  assert.equal(fileUriToPath("file:///Users/john/Documents"), "/Users/john/Documents");
+  assert.equal(fileUriToPath("file://localhost/Users/john/Documents"), "/Users/john/Documents");
+});
+
+test("fileUriToPath parses Windows file URIs", () => {
+  assert.equal(fileUriToPath("file:///C:/Users/user/project/file.txt"), "C:/Users/user/project/file.txt");
+  assert.equal(fileUriToPath("file:///d:/repo/subfolder"), "d:/repo/subfolder");
+  assert.equal(fileUriToPath("file://server/share/file.txt"), "//server/share/file.txt");
+});
+
+test("fileUriToPath decodes percent-encoded characters and spaces", () => {
+  assert.equal(
+    fileUriToPath("file:///home/user/my%20folder/%E6%96%87%E4%BB%B6.txt"),
+    "/home/user/my folder/文件.txt"
+  );
+  assert.equal(
+    fileUriToPath("file:///C:/Program%20Files/App/test%20file.json"),
+    "C:/Program Files/App/test file.json"
+  );
+});
+
+test("fileUriToPath returns non-file URIs as trimmed strings", () => {
+  assert.equal(fileUriToPath("  /home/user/file.txt  "), "/home/user/file.txt");
+  assert.equal(fileUriToPath("C:\\Users\\user\\file.txt"), "C:\\Users\\user\\file.txt");
+});
+
+test("extractPathsFromClipboardData extracts paths from File.path (Electron / Desktop)", () => {
+  const fakeClipboard = {
+    files: [
+      { path: "/home/user/project/a.txt", name: "a.txt" },
+      { path: "/home/user/project/b.txt", name: "b.txt" },
+    ],
+    items: [],
+    getData: () => "",
+  };
+
+  const paths = extractPathsFromClipboardData(fakeClipboard);
+  assert.deepEqual(paths, ["/home/user/project/a.txt", "/home/user/project/b.txt"]);
+});
+
+test("extractPathsFromClipboardData extracts paths from text/uri-list", () => {
+  const uriList = [
+    "# Comment line",
+    "file:///home/user/code/index.ts",
+    "file:///home/user/code/package.json",
+  ].join("\r\n");
+
+  const fakeClipboard = {
+    files: [],
+    items: [],
+    getData: (type) => (type === "text/uri-list" ? uriList : ""),
+  };
+
+  const paths = extractPathsFromClipboardData(fakeClipboard);
+  assert.deepEqual(paths, ["/home/user/code/index.ts", "/home/user/code/package.json"]);
+});
+
+test("extractPathsFromClipboardData extracts paths from Linux Nautilus/GNOME clipboard", () => {
+  const nautilusData = "copy\nfile:///home/user/photos/image.png\nfile:///home/user/photos/doc.pdf";
+
+  const fakeClipboard = {
+    files: [],
+    items: [],
+    getData: (type) => (type === "x-special/nautilus-clipboard" ? nautilusData : ""),
+  };
+
+  const paths = extractPathsFromClipboardData(fakeClipboard);
+  assert.deepEqual(paths, ["/home/user/photos/image.png", "/home/user/photos/doc.pdf"]);
+});
+
+test("extractPathsFromClipboardData extracts paths from macOS public.file-url", () => {
+  const fakeClipboard = {
+    files: [],
+    items: [],
+    getData: (type) => (type === "public.file-url" ? "file:///Users/name/Desktop/test.ts" : ""),
+  };
+
+  const paths = extractPathsFromClipboardData(fakeClipboard);
+  assert.deepEqual(paths, ["/Users/name/Desktop/test.ts"]);
+});
+
+test("extractPathsFromClipboardData extracts paths from text/plain with file:// URIs", () => {
+  const fakeClipboard = {
+    files: [],
+    items: [],
+    getData: (type) => (type === "text/plain" ? "file:///home/user/test.py" : ""),
+  };
+
+  const paths = extractPathsFromClipboardData(fakeClipboard);
+  assert.deepEqual(paths, ["/home/user/test.py"]);
+});
+
+test("extractPathsFromClipboardData handles null or empty clipboard data", () => {
+  assert.deepEqual(extractPathsFromClipboardData(null), []);
+  assert.deepEqual(
+    extractPathsFromClipboardData({
+      files: [],
+      items: [],
+      getData: () => "",
+    }),
+    []
+  );
+});
+
+test("extractPathsFromClipboardData supports fallbackToFileName", () => {
+  const fakeClipboard = {
+    files: [{ name: "myfile.zip" }],
+    items: [],
+    getData: () => "",
+  };
+
+  assert.deepEqual(extractPathsFromClipboardData(fakeClipboard, { fallbackToFileName: true }), ["myfile.zip"]);
+  assert.deepEqual(extractPathsFromClipboardData(fakeClipboard), []);
+});
+
+test("formatPathsForInput formats paths with quotes when containing spaces", () => {
+  assert.equal(formatPathsForInput([]), "");
+  assert.equal(formatPathsForInput(["/home/user/file.txt"]), "/home/user/file.txt");
+  assert.equal(
+    formatPathsForInput(["/home/user/my file.txt", "/home/user/other.txt"]),
+    '"/home/user/my file.txt" /home/user/other.txt'
+  );
+  assert.equal(
+    formatPathsForInput(['"already quoted"', "simple"]),
+    '"already quoted" simple'
+  );
+});

package/lib/clipboard-paths.ts

@@ -0,0 +1,192 @@
+/**
+ * Helpers for extracting and formatting file paths from clipboard / drag-drop data.
+ * Supports Windows Explorer (CF_HDROP / File.path), macOS Finder (file-url / uri-list),
+ * and Linux file managers (Nautilus, Dolphin, Thunar, etc.).
+ */
+
+/**
+ * Converts a file:// URI to a local file system path.
+ * Handles Windows drive letters, Unix paths, percent-encoding, and UNC network paths.
+ */
+export function fileUriToPath(uri: string): string {
+  const trimmed = uri.trim();
+  if (!trimmed.startsWith("file://")) {
+    return trimmed;
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    let pathname = decodeURIComponent(parsed.pathname);
+
+    // On Windows, URL pathname for file:///C:/path is "/C:/path" -> "C:/path"
+    if (/^\/[a-zA-Z]:[\\/]/.test(pathname)) {
+      pathname = pathname.slice(1);
+    } else if (parsed.host && parsed.host !== "localhost") {
+      // UNC path: file://server/share/file -> //server/share/file
+      pathname = `//${parsed.host}${pathname}`;
+    }
+
+    return pathname;
+  } catch {
+    let raw = trimmed.replace(/^file:\/\/(localhost)?/, "");
+    try {
+      raw = decodeURIComponent(raw);
+    } catch {
+      // Ignore URI decode errors and use raw string
+    }
+    if (/^\/[a-zA-Z]:[\\/]/.test(raw)) {
+      raw = raw.slice(1);
+    }
+    return raw;
+  }
+}
+
+export interface ExtractPathsOptions {
+  /**
+   * If true and no full paths or URIs could be found,
+   * fall back to returning the `name` property of clipboard File objects.
+   */
+  fallbackToFileName?: boolean;
+}
+
+const LINUX_CLIPBOARD_TYPES = [
+  "text/uri-list",
+  "x-special/nautilus-clipboard",
+  "x-special/gnome-copied-files",
+  "x-special/mate-copied-files",
+  "x-special/xfce4-copied-files",
+  "application/x-kde-cutselection",
+  "public.file-url",
+  "text/x-moz-url",
+  "application/x-moz-file",
+];
+
+function extractPathsFromText(text: string): string[] {
+  if (!text) return [];
+  const lines = text.split(/\r?\n/);
+  const paths: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#") || trimmed === "copy" || trimmed === "cut") {
+      continue;
+    }
+    if (trimmed.startsWith("file://")) {
+      paths.push(fileUriToPath(trimmed));
+    } else if (trimmed.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(trimmed)) {
+      paths.push(trimmed);
+    }
+  }
+
+  return paths;
+}
+
+/**
+ * Extracts file or directory paths from clipboard data or drag-and-drop DataTransfer.
+ */
+export function extractPathsFromClipboardData(
+  clipboardData: DataTransfer | null,
+  options?: ExtractPathsOptions
+): string[] {
+  if (!clipboardData) return [];
+
+  const foundPaths: string[] = [];
+
+  // 1. Check for Electron / desktop runtime `File.path` property on files
+  const files = Array.from(clipboardData.files ?? []);
+  for (const file of files) {
+    const filePath = (file as unknown as { path?: unknown }).path;
+    if (typeof filePath === "string" && filePath.trim()) {
+      foundPaths.push(filePath.trim());
+    }
+  }
+
+  if (foundPaths.length > 0) {
+    return Array.from(new Set(foundPaths));
+  }
+
+  // 2. Check DataTransferItem.getAsFile() if files didn't have path
+  const items = Array.from(clipboardData.items ?? []);
+  for (const item of items) {
+    if (item.kind === "file") {
+      const file = item.getAsFile();
+      const filePath = (file as unknown as { path?: unknown })?.path;
+      if (typeof filePath === "string" && filePath.trim()) {
+        foundPaths.push(filePath.trim());
+      }
+    }
+  }
+
+  if (foundPaths.length > 0) {
+    return Array.from(new Set(foundPaths));
+  }
+
+  // 3. Check specialized MIME types (text/uri-list, Linux file managers, macOS file-url)
+  for (const mimeType of LINUX_CLIPBOARD_TYPES) {
+    try {
+      const data = clipboardData.getData(mimeType);
+      if (data) {
+        const paths = extractPathsFromText(data);
+        if (paths.length > 0) {
+          foundPaths.push(...paths);
+        }
+      }
+    } catch {
+      // Some browsers throw when accessing unsupported custom MIME types
+    }
+  }
+
+  if (foundPaths.length > 0) {
+    return Array.from(new Set(foundPaths));
+  }
+
+  // 4. Check text/plain if it contains file:// URIs
+  try {
+    const textPlain = clipboardData.getData("text/plain") || clipboardData.getData("text");
+    if (textPlain) {
+      const lines = textPlain.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+      const fileUriLines = lines.filter((l) => l.startsWith("file://"));
+      if (fileUriLines.length > 0 && fileUriLines.length === lines.length) {
+        for (const uri of fileUriLines) {
+          foundPaths.push(fileUriToPath(uri));
+        }
+      }
+    }
+  } catch {
+    // Ignore data access error
+  }
+
+  if (foundPaths.length > 0) {
+    return Array.from(new Set(foundPaths));
+  }
+
+  // 5. Fallback to file names if enabled
+  if (options?.fallbackToFileName && files.length > 0) {
+    for (const file of files) {
+      if (file.name) {
+        foundPaths.push(file.name);
+      }
+    }
+  }
+
+  return Array.from(new Set(foundPaths));
+}
+
+/**
+ * Formats a list of paths into a string suitable for pasting into a text input or textarea.
+ * Quotes individual paths if they contain whitespace.
+ */
+export function formatPathsForInput(paths: string[], delimiter = " "): string {
+  if (!paths || paths.length === 0) return "";
+  if (paths.length === 1) return paths[0];
+
+  return paths
+    .map((p) => {
+      const trimmed = p.trim();
+      if (/\s/.test(trimmed) && !trimmed.startsWith('"') && !trimmed.startsWith("'")) {
+        return `"${trimmed}"`;
+      }
+      return trimmed;
+    })
+    .join(delimiter);
+}

package/lib/clipboard.ts

@@ -0,0 +1,18 @@
+export function copyText(text: string): Promise<void> {
+  if (navigator.clipboard?.writeText) {
+    return navigator.clipboard.writeText(text);
+  }
+  try {
+    const ta = document.createElement("textarea");
+    ta.value = text;
+    ta.style.position = "fixed";
+    ta.style.opacity = "0";
+    document.body.appendChild(ta);
+    ta.select();
+    document.execCommand("copy");
+    document.body.removeChild(ta);
+    return Promise.resolve();
+  } catch {
+    return Promise.reject();
+  }
+}

package/lib/compaction-summary.test.mjs

@@ -0,0 +1,44 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { parseCompactionSummary } from "./compaction-summary.ts";
+
+test("separates pi file metadata tags from the visible compaction summary", () => {
+  const parsed = parseCompactionSummary(`## Goal
+Keep the important user intent.
+
+<read-files>
+/tmp/a.ts
+/tmp/b.ts
+</read-files>
+
+<modified-files>
+/tmp/changed.ts
+</modified-files>`);
+
+  assert.equal(parsed.body, "## Goal\nKeep the important user intent.");
+  assert.deepEqual(parsed.readFiles, ["/tmp/a.ts", "/tmp/b.ts"]);
+  assert.deepEqual(parsed.modifiedFiles, ["/tmp/changed.ts"]);
+});
+
+test("leaves normal summaries unchanged", () => {
+  const summary = "## Goal\nNo file metadata here.";
+
+  assert.deepEqual(parseCompactionSummary(summary), {
+    body: summary,
+    readFiles: [],
+    modifiedFiles: [],
+  });
+});
+
+test("keeps file-like tags that are part of the summary body", () => {
+  const summary = `## Critical Context
+The user asked what this compact metadata means: <read-files>example</read-files>.
+
+More summary text after the mention.`;
+
+  assert.deepEqual(parseCompactionSummary(summary), {
+    body: summary,
+    readFiles: [],
+    modifiedFiles: [],
+  });
+});

package/lib/compaction-summary.ts

@@ -0,0 +1,34 @@
+export interface ParsedCompactionSummary {
+  body: string;
+  readFiles: string[];
+  modifiedFiles: string[];
+}
+
+const FILE_SECTION_RE = /<(read-files|modified-files)>\s*([\s\S]*?)\s*<\/\1>/g;
+const TRAILING_FILE_SECTIONS_RE = /(?:\r?\n){2,}((?:[ \t]*<(?:read-files|modified-files)>[ \t]*\r?\n[\s\S]*?\r?\n[ \t]*<\/(?:read-files|modified-files)>[ \t]*(?:\r?\n)?)+)\s*$/;
+
+export function parseCompactionSummary(summary: string): ParsedCompactionSummary {
+  const readFiles: string[] = [];
+  const modifiedFiles: string[] = [];
+  const metadataMatch = summary.match(TRAILING_FILE_SECTIONS_RE);
+  const metadataBlock = metadataMatch?.[1] ?? "";
+  const body = metadataMatch?.index === undefined ? summary : summary.slice(0, metadataMatch.index);
+
+  metadataBlock.replace(FILE_SECTION_RE, (_match, section: string, content: string) => {
+    const files = content
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean);
+
+    if (section === "read-files") readFiles.push(...files);
+    else modifiedFiles.push(...files);
+
+    return "";
+  });
+
+  return {
+    body: body.trim(),
+    readFiles,
+    modifiedFiles,
+  };
+}

package/lib/custom-ui-terminal.test.mjs

@@ -0,0 +1,32 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+async function loadSubject() {
+  return import("./custom-ui-terminal.ts");
+}
+
+test("headless custom UI exposes stable terminal dimensions", async () => {
+  const { createHeadlessCustomUiTui, DEFAULT_CUSTOM_UI_COLUMNS, DEFAULT_CUSTOM_UI_ROWS } = await loadSubject();
+  const tui = createHeadlessCustomUiTui(() => {});
+
+  assert.deepEqual(tui.terminal, {
+    columns: DEFAULT_CUSTOM_UI_COLUMNS,
+    rows: DEFAULT_CUSTOM_UI_ROWS,
+    kittyProtocolActive: false,
+  });
+  assert.equal(Object.isFrozen(tui), true);
+  assert.equal(Object.isFrozen(tui.terminal), true);
+});
+
+test("headless custom UI supports plugin rendering and render requests", async () => {
+  const { createHeadlessCustomUiTui } = await loadSubject();
+  let renders = 0;
+  const tui = createHeadlessCustomUiTui(() => { renders += 1; }, 80, 24);
+  const pluginComponent = {
+    render: (width) => [`${width}:${tui.terminal.columns}x${tui.terminal.rows}`],
+  };
+
+  assert.deepEqual(pluginComponent.render(80), ["80:80x24"]);
+  tui.requestRender();
+  assert.equal(renders, 1);
+});

package/lib/custom-ui-terminal.ts

@@ -0,0 +1,27 @@
+export const DEFAULT_CUSTOM_UI_COLUMNS = 92;
+export const DEFAULT_CUSTOM_UI_ROWS = 40;
+
+export interface HeadlessCustomUiTerminal {
+  readonly columns: number;
+  readonly rows: number;
+  readonly kittyProtocolActive: false;
+}
+
+export interface HeadlessCustomUiTui {
+  readonly terminal: HeadlessCustomUiTerminal;
+  requestRender(force?: boolean): void;
+}
+
+export function createHeadlessCustomUiTui(
+  requestRender: (force?: boolean) => void,
+  columns = DEFAULT_CUSTOM_UI_COLUMNS,
+  rows = DEFAULT_CUSTOM_UI_ROWS,
+): HeadlessCustomUiTui {
+  const terminal = Object.freeze({
+    columns,
+    rows,
+    kittyProtocolActive: false as const,
+  });
+
+  return Object.freeze({ terminal, requestRender });
+}

package/lib/deepseek-pricing.test.mjs

@@ -0,0 +1,120 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+});
+const { isDeepSeekPeak, nextDeepSeekSwitch, beijingTime } = await jiti.import("./deepseek-pricing.ts");
+
+/** 用北京时间构造 UTC 时刻：北京 2026-08-26 09:30 → 传对应 UTC 的 Date */
+function beijingDate(y, mo, d, h, mi = 0) {
+  const utc = Date.UTC(y, mo - 1, d, h, mi) - 8 * 3600_000;
+  return new Date(utc);
+}
+
+// 2026-08-24 是周一，08-30 是周日
+test("工作日高峰时段判峰", () => {
+  // 周一 09:00 边界：峰窗开始
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 9, 0)), true);
+  // 周一 10:00 峰
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 10, 0)), true);
+  // 周一 11:59 峰
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 11, 59)), true);
+  // 周一 12:00 边界：峰窗结束，转谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 12, 0)), false);
+  // 周一 14:00 第二峰窗开始
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 14, 0)), true);
+  // 周一 17:59 峰
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 17, 59)), true);
+  // 周一 18:00 转谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 18, 0)), false);
+  // 周一 00:00 谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 0, 0)), false);
+  // 周一 08:00 谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 8, 0)), false);
+  // 周一 23:00 谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 23, 0)), false);
+});
+
+test("周末全天谷价（含原本 UTC 峰窗时刻）", () => {
+  // 周六 10:00 —— 旧逻辑（UTC 02:00 峰窗内）会误判峰，现在必须为谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 29, 10, 0)), false);
+  // 周六 16:00 —— 旧逻辑（UTC 08:00 峰窗内）误判峰
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 29, 16, 0)), false);
+  // 周日 09:30 —— 旧逻辑（UTC 01:30 峰窗内）误判峰
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 30, 9, 30)), false);
+  // 周日 23:00 谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 30, 23, 0)), false);
+  // 周六 00:00 谷
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 29, 0, 0)), false);
+});
+
+test("UTC 周末边界不错位（北京时刻与 UTC 星期可能不一致）", () => {
+  // 北京周六 08:00，对应 UTC 周六 00:00（day 6）：必须判谷
+  const saturdayEarly = beijingDate(2026, 8, 29, 8, 0);
+  assert.equal(saturdayEarly.getUTCDay(), 6); // 确认 UTC 星期六
+  assert.equal(isDeepSeekPeak(saturdayEarly), false);
+  // 北京周六 00:00，对应 UTC 周五 16:00（day 5）：UTC 是周五傍晚，但北京已是周六，必须判谷
+  const utcFridayEvening = beijingDate(2026, 8, 29, 0, 0);
+  assert.equal(utcFridayEvening.getUTCDay(), 5); // 确认 UTC 星期五
+  assert.equal(isDeepSeekPeak(utcFridayEvening), false);
+  // 北京周一 01:00，对应 UTC 周日 17:00：必须判谷（UTC 周日，非工作日）
+  const mondayEarly = beijingDate(2026, 8, 24, 1, 0);
+  assert.equal(mondayEarly.getUTCDay(), 0); // UTC 周日
+  assert.equal(isDeepSeekPeak(mondayEarly), false);
+  // 北京周一 09:00 对应 UTC 周一 01:00：峰
+  assert.equal(isDeepSeekPeak(beijingDate(2026, 8, 24, 9, 0)), true);
+});
+
+test("工作日 nextSwitch：峰时 → 峰窗结束转谷", () => {
+  // 周一 10:00 峰 → 12:00 转谷
+  const s1 = nextDeepSeekSwitch(beijingDate(2026, 8, 24, 10, 0));
+  assert.equal(beijingTime(s1).getUTCDate(), 24);
+  assert.equal(beijingTime(s1).getUTCHours(), 12);
+  // 周一 13:00 谷 → 14:00 转峰
+  const s2 = nextDeepSeekSwitch(beijingDate(2026, 8, 24, 13, 0));
+  assert.equal(beijingTime(s2).getUTCHours(), 14);
+  // 周一 17:59 峰 → 18:00 转谷
+  const s3 = nextDeepSeekSwitch(beijingDate(2026, 8, 24, 17, 59));
+  assert.equal(beijingTime(s3).getUTCHours(), 18);
+  // 周一 23:00 谷 → 周二 09:00 转峰
+  const s4 = nextDeepSeekSwitch(beijingDate(2026, 8, 24, 23, 0));
+  assert.equal(beijingTime(s4).getUTCDate(), 25);
+  assert.equal(beijingTime(s4).getUTCHours(), 9);
+});
+
+test("跨周末 nextSwitch：周五晚起全程谷，跳到周一 09:00 转峰", () => {
+  // 周五 17:00 峰 → 当天 18:00 转谷
+  const fridayPeak = nextDeepSeekSwitch(beijingDate(2026, 8, 28, 17, 0));
+  assert.equal(beijingTime(fridayPeak).getUTCDate(), 28);
+  assert.equal(beijingTime(fridayPeak).getUTCHours(), 18);
+  // 周五 20:00 谷 → 跳过周六周日 → 周一(8/31) 09:00 转峰
+  const fridayNight = nextDeepSeekSwitch(beijingDate(2026, 8, 28, 20, 0));
+  assert.equal(beijingTime(fridayNight).getUTCDate(), 31);
+  assert.equal(beijingTime(fridayNight).getUTCDay(), 1); // 周一
+  assert.equal(beijingTime(fridayNight).getUTCHours(), 9);
+  // 周六 10:00 谷 → 周一 09:00 转峰（旧实现会错误返回周六 09:00 或 14:00 转峰）
+  const saturday = nextDeepSeekSwitch(beijingDate(2026, 8, 29, 10, 0));
+  assert.equal(beijingTime(saturday).getUTCDate(), 31);
+  assert.equal(beijingTime(saturday).getUTCHours(), 9);
+  // 周日 15:00 谷 → 周一 09:00 转峰
+  const sunday = nextDeepSeekSwitch(beijingDate(2026, 8, 30, 15, 0));
+  assert.equal(beijingTime(sunday).getUTCDate(), 31);
+  assert.equal(beijingTime(sunday).getUTCHours(), 9);
+  // 周日 23:00 谷 → 周一 09:00 转峰
+  const sundayLate = nextDeepSeekSwitch(beijingDate(2026, 8, 30, 23, 0));
+  assert.equal(beijingTime(sundayLate).getUTCDate(), 31);
+  assert.equal(beijingTime(sundayLate).getUTCHours(), 9);
+});
+
+test("周五晚上正是峰时与谷时边界（北京 18:00 整点翻转）", () => {
+  // 周五 17:59:59 → 18:00 转谷
+  const before = nextDeepSeekSwitch(beijingDate(2026, 8, 28, 17, 59));
+  assert.equal(beijingTime(before).getUTCHours(), 18);
+  // 周五 18:00:00 整 → 已转谷，下一个切换是周一 09:00
+  const onBoundary = nextDeepSeekSwitch(beijingDate(2026, 8, 28, 18, 0));
+  assert.equal(beijingTime(onBoundary).getUTCDate(), 31);
+  assert.equal(beijingTime(onBoundary).getUTCHours(), 9);
+});

package/lib/deepseek-pricing.ts

@@ -0,0 +1,71 @@
+/**
+ * DeepSeek 峰谷计价规则（服务端额度展示用）。
+ *
+ * 官方依据：
+ * - 定价页：https://api-docs.deepseek.com/zh-cn/quick_start/pricing/
+ * - 峰谷计费自 2026-08-17（北京时间 00:00）起生效；
+ *   2026-08-23 起周末（周六、周日）全天按低谷价计费（官方更新日志）。
+ *
+ * 规则（北京时间 UTC+8）：
+ * - 工作日（周一~周五）：高峰 09:00–12:00、14:00–18:00（左闭右开），其余时段谷（半价）
+ * - 周末（周六~周日）：全天谷价，无峰谷切换
+ *
+ * 注意：判定必须统一换算到北京时间再取星期与时刻，不能用 UTC 直接判——
+ * 例如北京周六 08:00 对应 UTC 周五 24:00，按 UTC 星期会被误判为工作日峰时。
+ * 规则如有变动，改这里一处即可（并同步设计文档 .agent/spec/2026-08-26-quota-display-design.md）。
+ */
+
+/** 北京时区相对 UTC 的毫秒偏移（无夏令时） */
+export const DS_BEIJING_OFFSET_MS = 8 * 60 * 60 * 1000;
+
+/** 工作日高峰时段（北京时间小时，左闭右开） */
+export const DS_PEAK_HOURS: readonly [number, number][] = [
+  [9, 12],
+  [14, 18],
+];
+
+/** 将 UTC 时刻平移为"北京时刻"：用它的 UTC getter 读取即得北京时间 */
+export function beijingTime(now: Date): Date {
+  return new Date(now.getTime() + DS_BEIJING_OFFSET_MS);
+}
+
+/** 北京时刻是否工作日（周一~周五）；周末返回 false（全天谷价） */
+function isBeijingWeekday(bj: Date): boolean {
+  const day = bj.getUTCDay(); // 0=周日 … 6=周六
+  return day >= 1 && day <= 5;
+}
+
+/** 当前是否为 DeepSeek 高峰时段（周末恒为谷，返回 false） */
+export function isDeepSeekPeak(now: Date): boolean {
+  const bj = beijingTime(now);
+  if (!isBeijingWeekday(bj)) return false;
+  const h = bj.getUTCHours();
+  return DS_PEAK_HOURS.some(([start, end]) => h >= start && h < end);
+}
+
+/**
+ * 下一次峰谷切换时刻（切换恒发生在北京时间整点）。
+ * 周末全天谷无边界：跨周末时直接跳到下一个工作日首个峰窗开始（周一 09:00）。
+ */
+export function nextDeepSeekSwitch(now: Date): Date {
+  const candidates: number[] = [];
+  // 北京视角向后看 8 天：连续两个周末最多 5 天无边界，8 天保证至少命中一个工作日
+  for (let dayOffset = 0; dayOffset < 8; dayOffset++) {
+    const bj = beijingTime(now);
+    bj.setUTCDate(bj.getUTCDate() + dayOffset);
+    if (!isBeijingWeekday(bj)) continue;
+    for (const [start, end] of DS_PEAK_HOURS) {
+      for (const hour of [start, end]) {
+        const bjBoundary = new Date(bj);
+        bjBoundary.setUTCHours(hour, 0, 0, 0);
+        const utcMs = bjBoundary.getTime() - DS_BEIJING_OFFSET_MS;
+        if (utcMs > now.getTime()) candidates.push(utcMs);
+      }
+    }
+  }
+  if (candidates.length === 0) {
+    // 兜底：8 天内必有工作日，正常走不到这里
+    return new Date(now.getTime() + 24 * 60 * 60 * 1000);
+  }
+  return new Date(Math.min(...candidates));
+}