@master.g/pi-wingman 0.0.1 → 0.0.2

package/README.md

@@ -10,7 +10,7 @@
 | **advisor** | oh-my-pi advisor | 指定一个模型当顾问，读主 agent 的每个 turn，以 steer 消息内联注入便签（aside / concern / blocker）让主 agent 纠偏 |
 | **hint** | Claude Code prompt suggestions | 任务结束后按上下文与目标生成下一步 prompt，输入框 ghost text 呈现：Tab 填入、Enter 直接发送 |
 
-> 状态：骨架（v0.0.1）。命令与配置已可用；三个控制器按 M1 hint → M2 advisor → M3 heads-up 接入。
+> 状态：早期版本（v0.0.2）。hint、advisor、heads-up 三个功能均已实现，默认关闭，尚在试用打磨中。
 
 ## 安装
 
@@ -27,7 +27,7 @@ pi --extension ~/github/pi-wingman/index.ts
 ## 命令
 
 - `/wingman` — 查看三个功能的状态与模型
-- `/advisor`、`/hint`、`/headsup` — 各接 `<provider/model>`（开启并设模型，模型须存在）、`on` / `off`（开关，保留已设模型）、无参（看状态）；参数支持补全
+- `/wingman advisor|hint|headsup` — 不带值时弹出 pi 的模型选择器（同 `/model`，可搜索），选完模型再选思考强度（同 `/thinking`，Esc 跳过）；也可直接写 `<provider/model> [effort]`（模型须存在，effort 须是该模型支持的档位）、`on` / `off`（开关，保留已设模型与 effort）；参数支持补全
 - `/ask-advisor <问题>` — 就当前上下文咨询顾问模型，回答注入对话
 
 ## 配置
@@ -37,12 +37,12 @@ pi --extension ~/github/pi-wingman/index.ts
 ```json
 {
 	"headsup": { "enabled": false },
-	"advisor": { "enabled": true, "model": "openai-codex/gpt-5.5" },
+	"advisor": { "enabled": true, "model": "openai-codex/gpt-5.5", "effort": "low" },
 	"hint": { "enabled": false }
 }
 ```
 
-三个功能默认都关闭：每个功能都会额外调用模型，需要用户自己开启。模型形如 `provider/model-id`；hint 没配模型时用当前模型（`/hint on`），advisor/heads-up 必须配模型才会激活。
+三个功能默认都关闭：每个功能都会额外调用模型，需要用户自己开启。模型形如 `provider/model-id`；hint 没配模型时用当前模型（`/wingman hint on`），advisor/heads-up 必须配模型才会激活。`effort` 可选（off / minimal / low / medium / high / xhigh / max，按模型支持的档位校正），不设则不开推理。advisor/heads-up 在后台跑，单次调用超时 60 秒；hint 要求快，超时 10 秒，高 effort 多半超时，超时就不出 hint。
 
 ## License
 

package/advisor.ts

@@ -72,7 +72,8 @@ export function installAdvisor(pi: ExtensionAPI, getConfig: () => WingmanConfig,
 			registry,
 			model,
 			{ goal: getGoal(), digest },
-			{ timeoutMs: 15_000, signal: shutdown.signal },
+			// 后台审计不卡主流程,超时放宽给高 effort 留余地
+			{ timeoutMs: 60_000, signal: shutdown.signal, effort: getConfig().advisor.effort },
 		);
 		if (!verdict || verdict.level === "ok") return;
 		ctx.ui.notify(`advisor [${verdict.level}] ${verdict.summary}`, NOTIFY_TYPE[verdict.level]);
@@ -86,7 +87,7 @@ export function installAdvisor(pi: ExtensionAPI, getConfig: () => WingmanConfig,
 
 	pi.on("turn_end", (event, ctx) => {
 		const config = getConfig().advisor;
-		// advisor 必须显式配置模型才激活(开启必经 /advisor <model>);
+		// advisor 必须显式配置模型才激活(开启必经 /wingman advisor <model>);
 		// 未设或拼错模型都不回退当前模型,避免双份成本。
 		if (!config.enabled || !config.model) return;
 		if (!state.shouldAuditTurn()) return;
@@ -108,7 +109,7 @@ export function installAdvisor(pi: ExtensionAPI, getConfig: () => WingmanConfig,
 		handler: async (args, ctx) => {
 			const config = getConfig().advisor;
 			if (!config.enabled || !config.model) {
-				ctx.ui.notify("advisor 未启用,先 /advisor <provider/model> 配置", "error");
+				ctx.ui.notify("advisor 未启用,先 /wingman advisor <provider/model> 配置", "error");
 				return;
 			}
 			const question = args.trim();
@@ -144,7 +145,7 @@ export function installAdvisor(pi: ExtensionAPI, getConfig: () => WingmanConfig,
 						},
 					],
 				},
-				{ timeoutMs: 30_000, signal: shutdown.signal },
+				{ timeoutMs: 60_000, signal: shutdown.signal, effort: config.effort },
 			);
 			if (!result.ok) {
 				ctx.ui.notify(`advisor 调用失败:${result.reason}`, "error");

package/audit.ts

@@ -9,7 +9,7 @@
  * undefined);失败一律静默(返回 undefined),不抛进 pi 事件循环。
  */
 
-import { completeText, messageText, type AnyModel, type Message, type ModelRegistry } from "./llm.js";
+import { completeText, messageText, type AnyModel, type CallOptions, type Message, type ModelRegistry } from "./llm.js";
 
 export type VerdictLevel = "ok" | "note" | "concern" | "blocker";
 
@@ -92,7 +92,7 @@ export async function runAudit(
 	registry: ModelRegistry,
 	model: AnyModel,
 	input: { goal: string; digest: string },
-	options: { timeoutMs?: number; signal?: AbortSignal } = {},
+	options: CallOptions = {},
 ): Promise<Verdict | undefined> {
 	const goal = input.goal ? `用户目标:${input.goal}\n\n` : "";
 	const result = await completeText(
@@ -108,7 +108,7 @@ export async function runAudit(
 				},
 			],
 		},
-		{ timeoutMs: options.timeoutMs ?? 15_000, signal: options.signal },
+		options,
 	);
 	if (!result.ok) return undefined;
 	return parseVerdict(result.text);
@@ -135,7 +135,7 @@ export class Auditor {
 		registry: ModelRegistry,
 		model: AnyModel,
 		input: { goal: string; digest: string },
-		options: { timeoutMs?: number; signal?: AbortSignal } = {},
+		options: CallOptions = {},
 	): Promise<Verdict | undefined> {
 		if (!this.ready) return undefined;
 		this.inFlight = true;

package/config.ts

@@ -2,10 +2,11 @@
  * config.ts — wingman 配置：读写 <agentDir>/wingman.json（默认 ~/.pi/agent）。
  *
  * 三个功能各自独立开关，默认全关（旁路调用都有成本，须用户显式开启）；
- * 模型形如 "provider/model-id"。未配置模型时各模块自行回退：hint 用当前
- * 模型，advisor/heads-up 保持关闭。
+ * 模型形如 "provider/model-id"，effort 是可选思考强度。未配置模型时各模块
+ * 自行回退：hint 用当前模型，advisor/heads-up 保持关闭。
  */
 
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -13,8 +14,14 @@ import { dirname, join } from "node:path";
 export interface FeatureConfig {
 	enabled: boolean;
 	model?: string;
+	effort?: ModelThinkingLevel;
 }
 
+export const EFFORTS: readonly ModelThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+export const isEffort = (value: unknown): value is ModelThinkingLevel =>
+	EFFORTS.includes(value as ModelThinkingLevel);
+
 export interface WingmanConfig {
 	headsup: FeatureConfig;
 	advisor: FeatureConfig;
@@ -37,6 +44,7 @@ function mergeFeature(base: FeatureConfig, override: unknown): FeatureConfig {
 	return {
 		enabled: typeof o.enabled === "boolean" ? o.enabled : base.enabled,
 		model: typeof o.model === "string" ? o.model : base.model,
+		effort: isEffort(o.effort) ? o.effort : base.effort,
 	};
 }
 
@@ -60,27 +68,29 @@ export function saveConfig(config: WingmanConfig, path: string = configPath()):
 	writeFileSync(path, JSON.stringify(config, null, "\t") + "\n");
 }
 
-/** 状态行:"hint: on (provider/model)" / "hint: on (current model)" / "hint: off"。 */
+/** 状态行:"hint: on (provider/model · high)" / "hint: on (current model)" / "hint: off"。 */
 export function featureLine(name: string, feature: FeatureConfig): string {
-	const state = feature.enabled ? `on (${feature.model ?? "current model"})` : "off";
+	const model = feature.model ?? "current model";
+	const state = feature.enabled ? `on (${feature.effort ? `${model} · ${feature.effort}` : model})` : "off";
 	return `${name}: ${state}`;
 }
 
 /**
- * 应用配置命令参数:"off" 关闭、"on" 重新开启(都保留已设模型),
- * "provider/model" 开启并设模型,空参只读。返回状态行;模型校验、
+ * 应用配置命令参数:"off" 关闭、"on" 重新开启(都保留已设模型与 effort),
+ * "provider/model" 开启并设模型与 effort(档位随模型变,不带即清空),空参只读。返回状态行;模型校验、
  * saveConfig 与后续副作用(如编辑器同步)由调用方负责。
  */
 export function applyFeatureArg(
 	config: WingmanConfig,
 	feature: keyof WingmanConfig,
 	arg: string,
+	effort?: ModelThinkingLevel,
 ): string {
 	const value = arg.trim();
 	if (value === "off" || value === "on") {
 		config[feature] = { ...config[feature], enabled: value === "on" };
 	} else if (value) {
-		config[feature] = { enabled: true, model: value };
+		config[feature] = { enabled: true, model: value, effort };
 	}
 	return featureLine(feature, config[feature]);
 }

package/headsup.ts

@@ -193,7 +193,7 @@ export function installHeadsUp(
 		clearTimer();
 		if (pending.length === 0) return;
 		const config = getConfig().headsup;
-		// heads-up 必须显式配置模型才激活(开启必经 /headsup <model>);拼错模型也不回退当前模型
+		// heads-up 必须显式配置模型才激活(开启必经 /wingman headsup <model>);拼错模型也不回退当前模型
 		if (!config.enabled || !config.model) {
 			debug(`flush 跳过:enabled=${config.enabled} model=${config.model}`);
 			pending = [];
@@ -217,7 +217,7 @@ export function installHeadsUp(
 			ctx.modelRegistry,
 			model,
 			{ goal: getGoal(), digest: formatToolEvents(events) },
-			{ timeoutMs: 15_000, signal: shutdown.signal },
+			{ timeoutMs: 60_000, signal: shutdown.signal, effort: config.effort },
 		);
 		debug(`verdict: ${verdict ? `${verdict.level} ${verdict.summary}` : "(调用失败/跳过)"}`);
 		if (!verdict || (verdict.level !== "concern" && verdict.level !== "blocker")) return;

package/hint.ts

@@ -48,7 +48,8 @@ export function installHint(
 					},
 				],
 			},
-			{ timeoutMs: 10_000, signal: shutdown.signal },
+			// hint 要快:高 effort 多半超时,失败即无 hint
+			{ timeoutMs: 10_000, signal: shutdown.signal, effort: getConfig().hint.effort },
 		);
 		if (!result.ok || gen !== generation) return; // 静默降级 / 已过期
 		editors.current?.setHint(result.text.replace(/\s+/g, " ").trim().slice(0, MAX_HINT_CHARS));

package/index.ts

@@ -7,19 +7,22 @@
  * headsup 任一开启即装);llm.ts 是共享旁路调用层,audit.ts 是 M2/M3
  * 共享的审计管线。
  *
- * 配置入口对称：/advisor、/hint、/headsup 各接 <provider/model> 开启并设
- * 模型（须能在 modelRegistry 解析）、on/off 开关（保留模型）、无参看状态；
- * /wingman 总览。用户目标在此统一捕获，跳过 advisor 注入的旁注，供三个
+ * 配置集中在 /wingman：无参看总览；/wingman <feature> 接 <provider/model>
+ * [effort] 开启并设模型（须能在 modelRegistry 解析，effort 须是该模型支持
+ * 的档位）、on/off 开关（保留模型）；不带值时 TUI 里弹 pi 的模型与思考
+ * 强度选择器，其他模式只看该功能状态。用户目标在此统一捕获，跳过 advisor 注入的旁注，供三个
  * 功能共用。
  */
 
+import { getSupportedThinkingLevels, type ModelThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { installAdvisor, isAdvisorNote } from "./advisor.js";
-import { applyFeatureArg, featureLine, loadConfig, saveConfig, type WingmanConfig } from "./config.js";
+import { applyFeatureArg, featureLine, isEffort, loadConfig, saveConfig, type WingmanConfig } from "./config.js";
 import { EditorManager } from "./editor.js";
 import { installHeadsUp } from "./headsup.js";
 import { installHint } from "./hint.js";
 import { resolveModel, type ModelRegistry } from "./llm.js";
+import { pickModel, type Picked } from "./picker.js";
 
 export default function (pi: ExtensionAPI) {
 	let config: WingmanConfig = loadConfig();
@@ -30,50 +33,93 @@ export default function (pi: ExtensionAPI) {
 	const getConfig = () => config;
 	const getGoal = () => goal;
 
-	pi.registerCommand("wingman", {
-		description: "Show wingman status (headsup / advisor / hint)",
-		handler: async (_args, ctx) => {
-			ctx.ui.notify(
-				[
-					"wingman",
-					featureLine("headsup", config.headsup),
-					featureLine("advisor", config.advisor),
-					featureLine("hint", config.hint),
-				].join(" · "),
-				"info",
-			);
-		},
-	});
+	const features = ["advisor", "hint", "headsup"] as const;
+	type Feature = (typeof features)[number];
+	const isFeature = (name: string | undefined): name is Feature => features.includes(name as Feature);
 
-	for (const feature of ["advisor", "hint", "headsup"] as const) {
-		pi.registerCommand(feature, {
-			description: `Configure wingman ${feature}: /${feature} <provider/model> | on | off`,
-			getArgumentCompletions: (prefix) => {
-				const models = registry?.getAvailable().map((m) => `${m.provider}/${m.id}`) ?? [];
-				const items = ["on", "off", ...models]
-					.filter((value) => value.startsWith(prefix))
-					.map((value) => ({ value, label: value }));
+	const usage = "/wingman <advisor|hint|headsup> [<provider/model> [effort] | on | off]";
+
+	pi.registerCommand("wingman", {
+		description: `Wingman status, or configure: ${usage}`,
+		getArgumentCompletions: (prefix) => {
+			const [feature, value, effort, ...rest] = prefix.trimStart().split(/\s+/);
+			if (rest.length > 0) return null;
+			if (value === undefined) {
+				const items = features
+					.filter((name) => name.startsWith(feature ?? ""))
+					.map((name) => ({ value: `${name} `, label: name }));
 				return items.length > 0 ? items : null;
-			},
-			handler: async (args, ctx) => {
-				const value = args.trim();
-				if (value && value !== "on" && value !== "off" && !resolveModel(ctx.modelRegistry, value, undefined)) {
-					ctx.ui.notify(`wingman · 找不到模型 ${value}(格式 provider/model-id)`, "error");
+			}
+			if (!isFeature(feature)) return null;
+			if (effort !== undefined) {
+				const model = registry && resolveModel(registry, value, undefined);
+				if (!model) return null;
+				const items = getSupportedThinkingLevels(model)
+					.filter((level) => level.startsWith(effort))
+					.map((level) => ({ value: `${feature} ${value} ${level}`, label: level }));
+				return items.length > 0 ? items : null;
+			}
+			const models = registry?.getAvailable().map((m) => `${m.provider}/${m.id}`) ?? [];
+			const items = ["on", "off", ...models]
+				.filter((option) => option.startsWith(value))
+				.map((option) => ({ value: `${feature} ${option}`, label: option }));
+			return items.length > 0 ? items : null;
+		},
+		handler: async (args, ctx) => {
+			const [feature, arg = "", effortArg, ...extra] = args.trim().split(/\s+/).filter(Boolean);
+			if (feature === undefined) {
+				ctx.ui.notify(
+					["wingman", ...features.map((name) => featureLine(name, config[name]))].join(" · "),
+					"info",
+				);
+				return;
+			}
+			const isSwitch = arg === "on" || arg === "off";
+			if (!isFeature(feature) || extra.length > 0 || (effortArg !== undefined && isSwitch)) {
+				ctx.ui.notify(`wingman · 用法 ${usage}`, "error");
+				return;
+			}
+			let value = arg;
+			let effort: ModelThinkingLevel | undefined;
+			if (!value && ctx.mode === "tui") {
+				let picked: Picked | undefined;
+				try {
+					picked = await pickModel(ctx, config[feature]);
+				} catch (error) {
+					const reason = error instanceof Error ? error.message : String(error);
+					ctx.ui.notify(`wingman · 选择器不可用(${reason}),改用 /wingman ${feature} <provider/model> [effort]`, "error");
 					return;
 				}
-				if (value === "on" && feature !== "hint" && !config[feature].model) {
-					ctx.ui.notify(`wingman · ${feature} 需要模型,先 /${feature} <provider/model>`, "error");
+				if (!picked) return;
+				value = `${picked.model.provider}/${picked.model.id}`;
+				effort = picked.effort;
+			} else if (value && !isSwitch) {
+				const model = resolveModel(ctx.modelRegistry, value, undefined);
+				if (!model) {
+					ctx.ui.notify(`wingman · 找不到模型 ${value}(格式 provider/model-id)`, "error");
 					return;
 				}
-				const line = applyFeatureArg(config, feature, args);
-				if (args.trim()) {
-					saveConfig(config);
-					editors.sync(ctx, config);
+				if (effortArg !== undefined) {
+					const levels = getSupportedThinkingLevels(model);
+					if (!isEffort(effortArg) || !levels.includes(effortArg)) {
+						ctx.ui.notify(`wingman · ${value} 支持的 effort:${levels.join(" / ")}`, "error");
+						return;
+					}
+					effort = effortArg;
 				}
-				ctx.ui.notify(`wingman · ${line}`, "info");
-			},
-		});
-	}
+			}
+			if (value === "on" && feature !== "hint" && !config[feature].model) {
+				ctx.ui.notify(`wingman · ${feature} 需要模型,先 /wingman ${feature} <provider/model>`, "error");
+				return;
+			}
+			const line = applyFeatureArg(config, feature, value, effort);
+			if (value) {
+				saveConfig(config);
+				editors.sync(ctx, config);
+			}
+			ctx.ui.notify(`wingman · ${line}`, "info");
+		},
+	});
 
 	pi.on("session_start", (_event, ctx) => {
 		config = loadConfig();

package/llm.ts

@@ -1,7 +1,8 @@
 /**
  * llm.ts — 旁路模型调用封装。
  *
- * 经 ctx.modelRegistry.complete() 调 provider 模型：
+ * 经 ctx.modelRegistry.streamSimple() 调 provider 模型（provider 中立的选项里
+ * 才有 reasoning，complete() 没有）：
  * - resolveModel(registry, "provider/model-id") 解析配置串，未配置/找不到时
  *   回退当前模型；
  * - completeText() 统一超时与 AbortController（idle 时 ctx.signal 不存在，
@@ -11,14 +12,18 @@
  * 失败一律返回 { ok: false, reason }，不抛异常进 pi 事件循环。
  */
 
+import { clampThinkingLevel, type ModelThinkingLevel } from "@earendil-works/pi-ai";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 export type ModelRegistry = ExtensionContext["modelRegistry"];
 export type AnyModel = NonNullable<ExtensionContext["model"]>;
-export type LlmContext = Parameters<ModelRegistry["complete"]>[1];
+export type LlmContext = Parameters<ModelRegistry["streamSimple"]>[1];
 /** pi-ai 的 Message:按 role 可辨识的联合(system/user/assistant/toolResult)。 */
 export type Message = LlmContext["messages"][number];
 
+/** effort 是思考强度,按模型支持的档位校正;未设或 "off" 不开推理。 */
+export type CallOptions = { timeoutMs?: number; signal?: AbortSignal; effort?: ModelThinkingLevel };
+
 export type CompleteResult = { ok: true; text: string } | { ok: false; reason: string };
 
 /** 拼接内容块里的文本块。 */
@@ -59,14 +64,17 @@ export async function completeText(
 	registry: ModelRegistry,
 	model: AnyModel,
 	context: LlmContext,
-	options: { timeoutMs?: number; signal?: AbortSignal } = {},
+	options: CallOptions = {},
 ): Promise<CompleteResult> {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 15_000);
 	const onOuterAbort = () => controller.abort();
 	options.signal?.addEventListener("abort", onOuterAbort, { once: true });
 	try {
-		const response = await registry.complete(model, context, { signal: controller.signal });
+		const effort = options.effort && clampThinkingLevel(model, options.effort);
+		const response = await registry
+			.streamSimple(model, context, { signal: controller.signal, reasoning: effort === "off" ? undefined : effort })
+			.result();
 		if (response.stopReason !== "stop") {
 			return { ok: false, reason: `stopReason=${response.stopReason}` };
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@master.g/pi-wingman",
-	"version": "0.0.1",
+	"version": "0.0.2",
 	"description": "Wingman for pi — heads-up audit while the agent works, a designated advisor model, and next-prompt hints (Tab/Enter to accept)",
 	"type": "module",
 	"license": "MIT",
@@ -38,6 +38,7 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"peerDependencies": {
+		"@earendil-works/pi-ai": "*",
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*"
 	},

package/picker.ts

@@ -0,0 +1,42 @@
+/**
+ * picker.ts — `/wingman <feature>` 不带值时的交互选择：依次复用 pi 的
+ * /model 与 /thinking 选择器选模型和 effort。仅 TUI 可用。
+ */
+
+import { clampThinkingLevel, getSupportedThinkingLevels, type ModelThinkingLevel } from "@earendil-works/pi-ai";
+import {
+	ModelSelectorComponent,
+	ThinkingSelectorComponent,
+	type ExtensionContext,
+	type ModelRuntime,
+} from "@earendil-works/pi-coding-agent";
+import type { FeatureConfig } from "./config.js";
+import { resolveModel, type AnyModel, type ModelRegistry } from "./llm.js";
+
+export type Picked = { model: AnyModel; effort?: ModelThinkingLevel };
+
+/** 选模型再选 effort;选模型时取消返回 undefined,选 effort 时取消则不设 effort。 */
+export async function pickModel(ctx: ExtensionContext, current: FeatureConfig): Promise<Picked | undefined> {
+	const registry = ctx.modelRegistry;
+	// ponytail: 组件要 ModelRuntime,扩展只拿得到 ModelRegistry;组件只调这 4 个方法,
+	// registry 内部也是原样转发。pi 让组件多调方法时会抛错,调用方兜底回退手输。
+	const runtime = {
+		getAvailableSnapshot: () => registry.getAvailable(),
+		getModel: (provider: string, id: string) => registry.find(provider, id),
+		getError: () => registry.getError(),
+		refresh: (options: Parameters<ModelRegistry["refresh"]>[0]) => registry.refresh(options),
+	} as unknown as ModelRuntime;
+	const currentModel = resolveModel(registry, current.model, undefined);
+	const model = await ctx.ui.custom<AnyModel | undefined>(
+		(tui, _theme, _kb, done) => new ModelSelectorComponent(tui, currentModel, runtime, [], done, () => done(undefined)),
+	);
+	if (!model) return undefined;
+
+	const levels = getSupportedThinkingLevels(model);
+	if (levels.length <= 1) return { model };
+	const effort = await ctx.ui.custom<ModelThinkingLevel | undefined>(
+		(_tui, _theme, _kb, done) =>
+			new ThinkingSelectorComponent(clampThinkingLevel(model, current.effort ?? "off"), levels, done, () => done(undefined)),
+	);
+	return { model, effort };
+}