pi-firecode 0.8.0 → 1.0.0

package/session/presets.ts

@@ -1,7 +1,11 @@
 /**
  * 预设：一键切换模型、思考等级、工具集与附加指令。
- * 入口有 `--preset`、`/preset [名字]`、Option+1-9、Ctrl+Shift+U 循环。
+ * 入口有 `--preset`、`/preset [名字]` 与各预设的 key 快捷键。
  * 预设定义见 firecode/config.jsonc 的 presets 节。
+ *
+ * 模型、思考档与工具集的事实源是宿主：宿主把它们记在会话里，并在 session_start 之前（切分支时同样）恢复。
+ * 这里只持有宿主不知道的两样——预设名与附加指令，且只在“当前模型仍是预设的模型”时成立：手动切走或重开会话时
+ * 宿主恢复的不是它，预设即失效（名字与指令一并清掉并记入会话），不另存一份模型去覆盖宿主，也不动宿主的工具集。
  */
 import type { Api, Model } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -10,10 +14,11 @@ import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi
 import { type Preset, loadConfig } from "../config.js";
 
 const CLEAR_ITEM = "（无）";
+const STATE_ENTRY = "preset-state";
 const INSTRUCTIONS_PREVIEW_CHARS = 30;
 const SELECTOR_MAX_ROWS = 10;
 
-/** 会话可用的等级比预设可配置的多（含 max），快照要按前者存。 */
+/** 会话可用的等级比预设可配置的多（含 max），快照要按前者存。重开会话后预设之前的模型已不可知，model 为空表示不动模型。 */
 type OriginalState = {
 	model: Model<Api> | undefined;
 	thinkingLevel: ReturnType<ExtensionAPI["getThinkingLevel"]>;
@@ -23,10 +28,20 @@ type OriginalState = {
 const title = (text: string): string =>
 	text ? `${text[0].toUpperCase()}${text.slice(1)}` : text;
 
+/** 模型原子在配置层已校验为 provider/model；调 Pi 接口时才拆成两段。 */
+function splitModel(id: string): [provider: string, model: string] {
+	const slash = id.indexOf("/");
+	return [id.slice(0, slash), id.slice(slash + 1)];
+}
+
+/** 预设对模型的要求：当前模型就是预设的模型，或预设根本不管模型。 */
+function holds(preset: Preset, model: Model<Api> | undefined): boolean {
+	return !preset.model || (!!model && `${model.provider}/${model.id}` === preset.model.model);
+}
+
 function describe(preset: Preset): string {
 	const parts: string[] = [];
-	if (preset.provider && preset.model) parts.push(`${preset.provider}/${preset.model}`);
-	if (preset.thinkingLevel) parts.push(`thinking:${preset.thinkingLevel}`);
+	if (preset.model) parts.push(preset.model.model, `thinking:${preset.model.thinking}`);
 	if (preset.tools) parts.push(`tools:${preset.tools.join(",")}`);
 	if (preset.instructions) {
 		const preview =
@@ -43,79 +58,100 @@ export function registerPresets(pi: ExtensionAPI): void {
 	let activeName: string | undefined;
 	let activePreset: Preset | undefined;
 	let originalState: OriginalState | undefined;
+	/** 本模块自己切模型期间的 model_select 不算用户切走。 */
+	let applying = false;
 
 	pi.registerFlag("preset", {
 		description: "要启用的预设名",
 		type: "string",
 	});
 
+	/**
+	 * 预设名只在它带来边框看不见的改动（工具集、附加指令）时发布：模型与思考档已显示在输入框下边框，
+	 * 只改这两样的预设再报名字就是同一信息说两遍。
+	 */
 	const updateStatus = (ctx: ExtensionContext) =>
 		ctx.ui.setStatus(
 			"preset",
-			activeName ? ctx.ui.theme.fg("accent", `🧩 ${title(activeName)}`) : undefined,
+			activeName && (activePreset?.tools?.length || activePreset?.instructions)
+				? ctx.ui.theme.fg("accent", title(activeName))
+				: undefined,
 		);
 
 	const noPresetsHint = (ctx: ExtensionContext) =>
 		ctx.ui.notify("未定义任何预设。在 firecode/config.jsonc 的 presets 里添加。", "warning");
 
+	/** 预设状态写进当前分支（与宿主的模型记录同一棵树），null 表示没有预设；重开会话按它恢复。 */
+	function setActive(name: string | undefined, ctx: ExtensionContext): void {
+		activeName = name;
+		activePreset = name === undefined ? undefined : presets[name];
+		if (name === undefined) originalState = undefined;
+		pi.appendEntry(STATE_ENTRY, { name: name ?? null });
+		updateStatus(ctx);
+	}
+
+	function applyTools(name: string, preset: Preset, ctx: ExtensionContext): void {
+		if (!preset.tools?.length) return;
+		const known = new Set(pi.getAllTools().map((tool) => tool.name));
+		const valid = preset.tools.filter((tool) => known.has(tool));
+		const unknown = preset.tools.filter((tool) => !known.has(tool));
+		if (unknown.length)
+			ctx.ui.notify(`预设「${name}」含未知工具：${unknown.join("、")}`, "warning");
+		if (valid.length) pi.setActiveTools(valid);
+	}
+
+	/** 先套模型；模型套用失败就整套不套（不动工具、不设预设名），只提示原因。 */
 	async function applyPreset(name: string, preset: Preset, ctx: ExtensionContext): Promise<void> {
 		// 首次应用前留一份快照，用于恢复默认。
-		if (activeName === undefined) {
-			originalState = {
-				model: ctx.model,
-				thinkingLevel: pi.getThinkingLevel(),
-				tools: pi.getActiveTools(),
-			};
-		}
-
-		if (preset.provider && preset.model) {
-			const model = ctx.modelRegistry.find(preset.provider, preset.model);
-			if (!model) {
-				ctx.ui.notify(
-					`Preset "${name}": Model ${preset.provider}/${preset.model} not found`,
-					"warning",
-				);
-			} else if (!(await pi.setModel(model))) {
-				ctx.ui.notify(
-					`Preset "${name}": No API key for ${preset.provider}/${preset.model}`,
-					"warning",
-				);
-			}
+		const snapshot = activeName === undefined
+			? { model: ctx.model, thinkingLevel: pi.getThinkingLevel(), tools: pi.getActiveTools() }
+			: originalState;
+		applying = true;
+		const failure = await applyModel(preset, ctx).finally(() => { applying = false; });
+		if (failure) {
+			ctx.ui.notify(`预设「${name}」未切换：${failure}`, "warning");
+			return;
 		}
+		originalState = snapshot;
+		applyTools(name, preset, ctx);
+		setActive(name, ctx);
+		ctx.ui.notify(`已切换预设「${name}」`, "info");
+	}
 
-		if (preset.thinkingLevel) pi.setThinkingLevel(preset.thinkingLevel);
-
-		if (preset.tools?.length) {
-			const known = new Set(pi.getAllTools().map((tool) => tool.name));
-			const valid = preset.tools.filter((tool) => known.has(tool));
-			const unknown = preset.tools.filter((tool) => !known.has(tool));
-			if (unknown.length)
-				ctx.ui.notify(`预设「${name}」含未知工具：${unknown.join("、")}`, "warning");
-			if (valid.length) pi.setActiveTools(valid);
-		}
+	/** 返回失败原因；成功或预设不管模型时为 undefined。 */
+	async function applyModel(preset: Preset, ctx: ExtensionContext): Promise<string | undefined> {
+		if (!preset.model) return undefined;
+		const [provider, id] = splitModel(preset.model.model);
+		const model = ctx.modelRegistry.find(provider, id);
+		if (!model) return `找不到模型 ${preset.model.model}`;
+		if (!(await pi.setModel(model))) return `模型 ${preset.model.model} 没有可用凭据`;
+		pi.setThinkingLevel(preset.model.thinking);
+		return undefined;
+	}
 
-		activeName = name;
-		activePreset = preset;
+	/** 当前模型已不是预设的：预设失效。 */
+	function dropIfDiverged(ctx: ExtensionContext): void {
+		if (!activeName || !activePreset || holds(activePreset, ctx.model)) return;
+		const name = activeName;
+		setActive(undefined, ctx);
+		ctx.ui.notify(`模型已不是预设「${name}」的，预设已失效`, "info");
 	}
 
 	async function activate(name: string, ctx: ExtensionContext): Promise<void> {
 		const preset = presets[name];
 		if (!preset) return;
 		await applyPreset(name, preset, ctx);
-		ctx.ui.notify(`已切换预设「${name}」`, "info");
-		updateStatus(ctx);
 	}
 
 	async function clearPreset(ctx: ExtensionContext): Promise<void> {
-		activeName = undefined;
-		activePreset = undefined;
-		if (originalState) {
-			if (originalState.model) await pi.setModel(originalState.model);
-			pi.setThinkingLevel(originalState.thinkingLevel);
-			pi.setActiveTools(originalState.tools);
+		const original = originalState;
+		setActive(undefined, ctx);
+		if (original) {
+			if (original.model) await pi.setModel(original.model);
+			pi.setThinkingLevel(original.thinkingLevel);
+			pi.setActiveTools(original.tools);
 		}
 		ctx.ui.notify("预设已清除，恢复默认", "info");
-		updateStatus(ctx);
 	}
 
 	async function showSelector(ctx: ExtensionContext): Promise<void> {
@@ -169,25 +205,7 @@ export function registerPresets(pi: ExtensionAPI): void {
 		else await activate(choice, ctx);
 	}
 
-	async function cyclePreset(ctx: ExtensionContext): Promise<void> {
-		const names = Object.keys(presets);
-		if (names.length === 0) {
-			noPresetsHint(ctx);
-			return;
-		}
-		const cycle = [CLEAR_ITEM, ...names];
-		const current = cycle.indexOf(activeName ?? CLEAR_ITEM);
-		const next = cycle[current === -1 ? 0 : (current + 1) % cycle.length];
-		if (next === CLEAR_ITEM) await clearPreset(ctx);
-		else await activate(next, ctx);
-	}
-
-	const { keys, presets: configured } = loadConfig().config;
-
-	pi.registerShortcut(keys.cyclePreset as never, {
-		description: "轮切预设",
-		handler: (ctx) => cyclePreset(ctx),
-	});
+	const { presets: configured } = loadConfig().config;
 
 	for (const [name, preset] of Object.entries(configured)) {
 		if (!preset.key) continue;
@@ -205,6 +223,11 @@ export function registerPresets(pi: ExtensionAPI): void {
 				await showSelector(ctx);
 				return;
 			}
+			// 与选择器同一个“无”项：清除当前预设。
+			if (name === CLEAR_ITEM) {
+				await clearPreset(ctx);
+				return;
+			}
 			if (!presets[name]) {
 				const available = Object.keys(presets).join(", ") || "(none defined)";
 				ctx.ui.notify(`未知预设「${name}」，可用：${available}`, "error");
@@ -214,12 +237,32 @@ export function registerPresets(pi: ExtensionAPI): void {
 		},
 	});
 
-	pi.on("before_agent_start", async (event) => {
+	pi.on("model_select", (_event, ctx) => {
+		if (!applying) dropIfDiverged(ctx);
+	});
+
+	pi.on("before_agent_start", async (event, ctx) => {
+		dropIfDiverged(ctx);
 		if (!activePreset?.instructions) return;
 		return { systemPrompt: `${event.systemPrompt}\n\n${activePreset.instructions}` };
 	});
 
+	/** 同进程内新开/切换会话或切分支复用本模块实例：上一处的预设不带进来。 */
+	const reset = () => {
+		activeName = undefined;
+		activePreset = undefined;
+		originalState = undefined;
+	};
+
+	// 切到另一分支：宿主按该分支恢复模型，预设也按该分支的记录重新判定。
+	pi.on("session_tree", (_event, ctx) => {
+		reset();
+		restore(ctx);
+		updateStatus(ctx);
+	});
+
 	pi.on("session_start", async (_event, ctx) => {
+		reset();
 		// 配置问题由 index.ts 统一提示，这里只取预设。
 		presets = loadConfig().config.presets;
 
@@ -227,31 +270,31 @@ export function registerPresets(pi: ExtensionAPI): void {
 		if (typeof flag === "string" && flag) {
 			if (presets[flag]) {
 				await applyPreset(flag, presets[flag], ctx);
-				ctx.ui.notify(`已切换预设「${flag}」`, "info");
 			} else {
 				const available = Object.keys(presets).join(", ") || "(none defined)";
 				ctx.ui.notify(`未知预设「${flag}」，可用：${available}`, "warning");
 			}
-		} else {
-			// 恢复上次会话的预设：只认名字，不重放模型与工具切换。
-			const restored = ctx.sessionManager
-				.getEntries()
-				.filter(
-					(entry: { type: string; customType?: string }) =>
-						entry.type === "custom" && entry.customType === "preset-state",
-				)
-				.pop() as { data?: { name: string } } | undefined;
-			const name = restored?.data?.name;
-			if (name && presets[name]) {
-				activeName = name;
-				activePreset = presets[name];
-			}
-		}
-
+		} else restore(ctx);
 		updateStatus(ctx);
 	});
 
-	pi.on("turn_start", async () => {
-		if (activeName) pi.appendEntry("preset-state", { name: activeName });
-	});
+	/** 按当前分支最后一条预设记录恢复：宿主已恢复模型与工具集，模型仍是预设的才算生效。 */
+	function restore(ctx: ExtensionContext): void {
+		const record = ctx.sessionManager
+			.getBranch()
+			.filter((entry: { type: string; customType?: string }) => entry.type === "custom" && entry.customType === STATE_ENTRY)
+			.pop() as { data?: { name: string | null } } | undefined;
+		const name = record?.data?.name;
+		if (!name) return;
+		const preset = presets[name];
+		if (!preset || !holds(preset, ctx.model)) {
+			setActive(undefined, ctx);
+			ctx.ui.notify(preset ? `模型已不是预设「${name}」的，预设已失效` : `预设「${name}」已不在配置里，已清除`, "info");
+			return;
+		}
+		activeName = name;
+		activePreset = preset;
+		// 应用预设之前的状态不在会话记录里：清除时不动模型，思考档与工具集维持宿主恢复的。
+		originalState = { model: undefined, thinkingLevel: pi.getThinkingLevel(), tools: pi.getActiveTools() };
+	}
 }

package/session/quota.ts

@@ -0,0 +1,123 @@
+/** /quota：按需查询 Pi OAuth 订阅额度，只投界面通知，不参与会话或模型调用。 */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+const REQUEST_TIMEOUT_MS = 3_000;
+const FABLE_WINDOW = "Fable 本周";
+const HOUR_SECONDS = 3_600;
+const DAY_SECONDS = 86_400;
+const WEEK_SECONDS = 7 * DAY_SECONDS;
+const PROVIDERS = [
+	{ id: "openai-codex", name: "Codex", url: "https://chatgpt.com/backend-api/wham/usage", parse: codexWindows },
+	{ id: "anthropic", name: "Claude", url: "https://api.anthropic.com/api/oauth/usage", parse: claudeWindows },
+] as const;
+type QuotaProvider = (typeof PROVIDERS)[number];
+type QuotaWindow = { label: string; remaining: number };
+const record = (value: unknown): Record<string, unknown> =>
+	value !== null && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
+
+function changedFormat(): never {
+	throw new Error("额度响应格式已变化");
+}
+
+function quotaWindow(label: string, used: unknown): QuotaWindow {
+	if (typeof used !== "number" || !Number.isFinite(used) || used < 0) return changedFormat();
+	return { label, remaining: Math.max(0, Math.round(100 - used)) };
+}
+
+function codexWindows(value: unknown): QuotaWindow[] {
+	const rate = record(record(value).rate_limit);
+	const windows: QuotaWindow[] = [];
+	for (const value of [rate.primary_window, rate.secondary_window]) {
+		if (value == null) continue;
+		const entry = record(value);
+		const seconds = entry.limit_window_seconds;
+		if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds <= 0) return changedFormat();
+		const label = seconds === WEEK_SECONDS ? "本周"
+			: seconds % DAY_SECONDS === 0 ? `${seconds / DAY_SECONDS}天` : `${seconds / HOUR_SECONDS}小时`;
+		windows.push(quotaWindow(label, entry.used_percent));
+	}
+	return windows;
+}
+
+function claudeWindows(value: unknown): QuotaWindow[] {
+	const limits = record(value).limits;
+	if (!Array.isArray(limits)) return changedFormat();
+	return limits.flatMap((value): QuotaWindow[] => {
+		const entry = record(value);
+		if (entry.kind === "session") return [quotaWindow("5小时", entry.percent)];
+		if (entry.kind === "weekly_all") return [quotaWindow("本周", entry.percent)];
+		const model = record(record(entry.scope).model).display_name;
+		if (entry.kind === "weekly_scoped" && model === "Fable") return [quotaWindow(FABLE_WINDOW, entry.percent)];
+		return [];
+	});
+}
+
+function codexAccountId(token: string): string {
+	try {
+		const claims = record(JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString("utf8")));
+		const id = record(claims["https://api.openai.com/auth"]).chatgpt_account_id;
+		if (typeof id === "string" && id) return id;
+	} catch {
+		throw new Error("Codex 登录凭据无效");
+	}
+	throw new Error("Codex 登录凭据缺少账户信息");
+}
+
+async function query(
+	provider: QuotaProvider,
+	registry: ExtensionContext["modelRegistry"],
+	signal: AbortSignal,
+	fetcher: typeof fetch,
+): Promise<string> {
+	try {
+		const model = registry.getAll().find((model) => model.provider === provider.id);
+		if (!model || !registry.isUsingOAuth(model)) return `${provider.name}：未通过 Pi OAuth 登录`;
+		const resolution = await registry.getProviderAuth(provider.id);
+		const token = resolution?.auth.apiKey;
+		if (!token) throw new Error("未取得 OAuth 登录凭据");
+		const headers = new Headers({ Authorization: `Bearer ${token}`, Accept: "application/json" });
+		if (provider.id === "anthropic") headers.set("anthropic-beta", "oauth-2025-04-20");
+		else headers.set("ChatGPT-Account-Id", codexAccountId(token));
+		const response = await fetcher(provider.url, {
+			headers, signal: AbortSignal.any([signal, AbortSignal.timeout(REQUEST_TIMEOUT_MS)]),
+		});
+		if (!response.ok) throw new Error(`HTTP ${response.status}`);
+		const windows = provider.parse(await response.json());
+		if (!windows.length) return changedFormat();
+		const parts = windows.map(({ label, remaining }) => `${label}剩余 ${remaining}%`);
+		if (provider.id === "anthropic" && !windows.some(({ label }) => label === FABLE_WINDOW))
+			parts.push(`${FABLE_WINDOW}：未提供独立额度`);
+		return `${provider.name}：${parts.join(" ｜ ")}`;
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		return `${provider.name}：查询失败（${reason}）`;
+	}
+}
+
+export function registerQuota(pi: ExtensionAPI, fetcher: typeof fetch = fetch): void {
+	let inFlight: AbortController | undefined;
+	pi.registerCommand("quota", {
+		description: "查询 Codex、Claude 和 Fable 的订阅剩余额度，不打断当前任务",
+		handler: async (args, ctx) => {
+			if (args.trim()) return ctx.ui.notify("用法：/quota", "warning");
+			if (inFlight) return ctx.ui.notify("额度正在查询，请稍候", "info");
+			// 在首个 await 前占住唯一请求槽，重复命令不会叠加抓取。
+			const owner = new AbortController();
+			inFlight = owner;
+			const { ui, modelRegistry } = ctx;
+			ui.notify("正在查询订阅额度…", "info");
+			try {
+				const results = await Promise.all(PROVIDERS.map((provider) => query(provider, modelRegistry, owner.signal, fetcher)));
+				if (inFlight !== owner) return;
+				const time = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+				ui.notify(`订阅剩余额度 · 查询于 ${time}\n${results.join("\n")}`, "info");
+			} finally {
+				if (inFlight === owner) inFlight = undefined;
+			}
+		},
+	});
+	pi.on("session_shutdown", () => {
+		inFlight?.abort();
+		inFlight = undefined;
+	});
+}

package/session/stats.ts

@@ -8,6 +8,8 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { DynamicBorder, getAgentDir, getMarkdownTheme } from "@earendil-works/pi-coding-agent";
 import { type AutocompleteItem, Container, Markdown, Text, matchesKey } from "@earendil-works/pi-tui";
 
+import { registerQuota } from "./quota.js";
+
 const DEFAULT_DAYS = 30;
 const DAY_MS = 24 * 60 * 60 * 1000;
 
@@ -277,7 +279,7 @@ async function show(markdown: string, ctx: ExtensionCommandContext): Promise<voi
 }
 
 /** 支持 `/tokens 7`、`/tokens --days 7`、`/tokens 0`（全部）。 */
-export function parseDays(args: string | undefined): number {
+function parseDays(args: string | undefined): number {
 	const text = (args ?? "").trim();
 	if (!text) return DEFAULT_DAYS;
 
@@ -293,6 +295,7 @@ const dayCompletions: AutocompleteItem[] = [
 ];
 
 export function registerStats(pi: ExtensionAPI): void {
+	registerQuota(pi);
 	pi.registerCommand("tokens", {
 		description: "统计会话 token 与成本，参数为天数：默认 30，0 表示全部",
 		getArgumentCompletions: (prefix: string) => {