@rexvane/piweb 0.3.21 → 0.3.22

package/src/lib/thinking-level.ts

@@ -0,0 +1,39 @@
+/**
+ * 思考档位的纯函数，客户端与服务端共用（不引入 pi-ai）。规则与 pi-ai 的 clampThinkingLevel、
+ * pi 的 createAgentSession 一致；tests/thinking-level.test.ts 里逐项和 pi-ai 对照。
+ */
+
+/** pi-ai 的 EXTENDED_THINKING_LEVELS：从低到高 */
+export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+/** pi 的 DEFAULT_THINKING_LEVEL：设置里没有默认档位、模型也没有覆盖时用它 */
+export const DEFAULT_THINKING_LEVEL = "medium";
+
+/**
+ * 把档位钳到模型支持的范围：支持就原样返回；否则先向更高的档位找，再向更低的档位找，都没有就取第一个支持的。
+ */
+export function clampThinkingLevelTo(supported: readonly string[], level: string): string {
+	if (supported.includes(level)) return level;
+	const index = THINKING_LEVELS.indexOf(level);
+	if (index === -1) return supported[0] ?? "off";
+	for (let i = index; i < THINKING_LEVELS.length; i += 1) {
+		if (supported.includes(THINKING_LEVELS[i])) return THINKING_LEVELS[i];
+	}
+	for (let i = index - 1; i >= 0; i -= 1) {
+		if (supported.includes(THINKING_LEVELS[i])) return THINKING_LEVELS[i];
+	}
+	return supported[0] ?? "off";
+}
+
+/**
+ * 新会话实际会用的档位（SDK createAgentSession 的规则）：用户显式选过就用它；否则依次取该模型的每模型覆盖、
+ * 设置里的默认档位、DEFAULT_THINKING_LEVEL；最后按模型能力钳制。
+ */
+export function newSessionThinkingLevel(input: {
+	supported: readonly string[];
+	requested?: string;
+	modelOverride?: string;
+	defaultLevel?: string;
+}): string {
+	return clampThinkingLevelTo(input.supported, input.requested || input.modelOverride || input.defaultLevel || DEFAULT_THINKING_LEVEL);
+}

package/src/lib/trajectory.ts

@@ -1,12 +1,17 @@
 /**
  * 轨迹账本：对齐 dsh ui-trajectory 的 cell 模型（system/user/message/tool/compacted）。
  * 活跃会话由 pi 事件实时驱动；冷会话从 JSONL 条目离线重建。
- * pi 无耗时字段——TTFT/decode 由服务端自测，仅活跃会话有值。
+ * pi 持久化 LLM / 工具 durationMs；TTFT/decode 由服务端自测，仅活跃会话有值。
  */
 import type { AgentSessionEvent } from "@earendil-works/pi-coding-agent";
 import type { TrajEntry, TrajTokens } from "./types";
 import { sanitizeToolOutput } from "./text-sanitize";
 
+/** 只恢复 SDK 已记录的耗时，不从相邻消息时间戳推算。 */
+function storedDuration(value: unknown): number | undefined {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
 export function toTrajTokens(u: any): TrajTokens | undefined {
 	if (!u || typeof u !== "object") return undefined;
 	const t: TrajTokens = {};
@@ -88,6 +93,8 @@ export class TrajLedger {
 						e.encodingLoss = result.encodingLoss || e.encodingLoss;
 						e.isError = m.isError === true;
 						e.tokens = toTrajTokens(m.usage) ?? e.tokens;
+						const durationMs = storedDuration(m.durationMs);
+						if (durationMs !== undefined) e.timing = { ...e.timing, durationMs };
 						this.touch(e);
 					}
 				}
@@ -96,7 +103,7 @@ export class TrajLedger {
 			case "message_update": {
 				const e: any = evt.assistantMessageEvent;
 				if (!e) break;
-				if ((e.type === "text_delta" || e.type === "thinking_delta") && this.streamingStart) {
+				if ((e.type === "text_delta" || e.type === "thinking_delta" || e.type === "toolcall_delta") && e.delta?.length > 0 && this.streamingStart) {
 					if (this.streamingStart.firstToken === undefined) {
 						this.streamingStart.firstToken = now;
 						const last = this.entries[this.entries.length - 1];
@@ -127,6 +134,8 @@ export class TrajLedger {
 							durationMs: now - this.streamingStart.t0,
 						};
 					}
+					const durationMs = storedDuration(m.durationMs);
+					if (durationMs !== undefined) e.timing = { ...e.timing, durationMs };
 					e.tokens = toTrajTokens(m.usage);
 					e.thinking = textOf(
 						(m.content ?? []).filter((c: any) => c.type === "thinking").map((c: any) => c.thinking),
@@ -194,7 +203,8 @@ export class TrajLedger {
 					e.encodingLoss = result.encodingLoss || e.encodingLoss;
 					e.isError = evt.isError === true;
 					const startedAt = this.toolStart.get(evt.toolCallId);
-					if (startedAt !== undefined) e.timing = { ...(e.timing ?? {}), durationMs: now - startedAt };
+					const durationMs = storedDuration((evt as any).durationMs) ?? (startedAt !== undefined ? now - startedAt : undefined);
+					if (durationMs !== undefined) e.timing = { ...(e.timing ?? {}), durationMs };
 					this.touch(e);
 				}
 				this.toolStart.delete(evt.toolCallId);
@@ -236,6 +246,7 @@ export function buildTrajectoryFromEntries(entries: any[]): TrajEntry[] {
 			} else if (m.role === "assistant") {
 				const thinking = textOf((m.content ?? []).filter((c: any) => c.type === "thinking"));
 				const text = textOf((m.content ?? []).filter((c: any) => c.type === "text"));
+				const durationMs = storedDuration(m.durationMs);
 				out.push({
 					seq: seq++,
 					kind: "message",
@@ -244,6 +255,7 @@ export function buildTrajectoryFromEntries(entries: any[]): TrajEntry[] {
 					detail: text,
 					thinking: thinking || undefined,
 					tokens: toTrajTokens(m.usage),
+					...(durationMs === undefined ? {} : { timing: { durationMs } }),
 					isError: m.stopReason === "error" || undefined,
 				});
 				for (const c of m.content ?? []) {
@@ -269,6 +281,8 @@ export function buildTrajectoryFromEntries(entries: any[]): TrajEntry[] {
 					target.encodingLoss = result.encodingLoss || target.encodingLoss;
 					target.isError = m.isError === true || undefined;
 					target.tokens = toTrajTokens(m.usage) ?? target.tokens;
+					const durationMs = storedDuration(m.durationMs);
+					if (durationMs !== undefined) target.timing = { durationMs };
 				}
 			}
 		} else if (raw.type === "compaction") {

package/src/lib/types.ts

@@ -145,8 +145,10 @@ export type WebEvent =
 	  }
 	| { type: "extension_ui_resolved"; id: string; ts: number }
 	| { type: "error"; message: string; ts: number }
-	/** 自动重试：流程内通知，界面聚合成一条「重试 n/max」，不作为错误条目累积 */
+	/** 自动重试:流程内通知,界面聚合成一条「重试 n/max」,不作为错误条目累积 */
 	| { type: "retry"; attempt: number; maxAttempts: number; message: string; ts: number }
+	/** 重试区间结束(SDK auto_retry_end):收掉「重试 n/max」那一行;真失败由后续 error 消息表达 */
+	| { type: "retry_end"; attempt: number; ts: number }
 	/** 项目生长：提交了一个 commit（pi 的一轮 / 用户两轮之间的修改 / 工作区基线） */
 	| { type: "growth"; round: GrowthRound; ts: number }
 	| { type: "growth_error"; message: string | null; ts: number }
@@ -166,6 +168,11 @@ export interface WebStats {
 	ttftSteps: number;
 	decodeMs: number;
 	decodeTokens: number;
+	/** 有持久化耗时的消息 / 工具数量；旧历史缺数据时显示覆盖范围。 */
+	llmTimedSteps?: number;
+	toolTimedCalls?: number;
+	/** 生成速度实际测到的回复数，不代表整个历史。 */
+	decodeSteps?: number;
 }
 
 // ---------- 项目生长（每轮一个 git commit） ----------
@@ -236,6 +243,8 @@ export interface ContextResource {
  * 这里只放服务端才能拿到的部分。
  */
 export interface ContextBreakdown {
+	/** 当前投影中实际文本的字符数；不将估算 token 按比例分摊。 */
+	characters?: { systemPrompt: number; systemTools: number; customTools: number; memory: number; skills: number; compacted: number };
 	/** SDK 内建 system prompt 正文（不含 memory/skills/tools 段）的估算 token */
 	systemPrompt: number;
 	/** 内建工具（SDK 自带 bash/read/edit 等）定义的估算 token */
@@ -338,6 +347,8 @@ export interface AgentCommand {
 	instructions?: string;
 	provider?: string;
 	modelId?: string;
+	/** setModel：新会话页选的模型，思考档位按新会话的规则定（不沿用会话原来的档位） */
+	fresh?: boolean;
 	level?: string;
 	preset?: ToolPreset;
 	entryId?: string;

package/src/lib/workspace-index.ts

@@ -0,0 +1,270 @@
+/**
+ * @ 引用的候选与匹配（纯逻辑，便于单测）：照搬 pi 终端的 `@` 补全
+ * （pi-tui `CombinedAutocompleteProvider.getFuzzyFileSuggestions` + `extractAtPrefix`），
+ * 同一个 `@que` 在终端和网页里给出同一批、同一顺序的候选。
+ *
+ * pi 的做法：`@` 后的文字按最后一个 `/` 拆成「目录 + 查询」（目录存在才算），
+ * 在该目录下用 fd 过滤（查询当正则、smart case，默认只匹配文件名，带 `/` 时匹配整条路径），
+ * 再用 scoreEntry 打分（文件名全等 100 / 前缀 80 / 包含 50 / 路径包含 30，目录 +10），
+ * 按分数、层级、路径长度、字典序排，取前 20。
+ *
+ * 有意的差别（tests/mention-parity.test.ts 里逐条对照，差别也写在那里）：
+ * - 候选来自服务端给的工作区清单（git 可见文件 + 推导出的文件夹），不现场跑 fd；
+ *   pi 每次 fd 只取前 100 条再打分，这里对整份清单打分——结果是「fd 不截断时 pi 会给的」，而且稳定。
+ * - 不支持 `~/`、绝对路径和跳出工作区的 `../`：引用只针对当前工作区。
+ * - fd 的 `--full-path` 匹配绝对路径，这里匹配相对路径（只差在工作区自身路径恰好命中的极端情况）。
+ */
+
+export interface PathCandidate {
+	/** 工作区根的相对路径（"/" 分隔），目录不带尾斜杠 */
+	path: string;
+	dir: boolean;
+}
+
+/** 显示用：目录带尾斜杠 */
+export function candidateText(candidate: PathCandidate): string {
+	return candidate.dir ? `${candidate.path}/` : candidate.path;
+}
+
+/** 文件路径 → 全部父目录（去重、不含 "."） */
+export function dirsOfPaths(files: string[]): string[] {
+	const dirs = new Set<string>();
+	for (const file of files) {
+		const parts = file.split("/");
+		for (let i = 1; i < parts.length; i += 1) dirs.add(parts.slice(0, i).join("/"));
+	}
+	return [...dirs];
+}
+
+export function buildCandidates(files: string[], dirs: string[]): PathCandidate[] {
+	const out: PathCandidate[] = [];
+	for (const dir of dirs) out.push({ path: dir, dir: true });
+	for (const file of files) out.push({ path: file, dir: false });
+	return out;
+}
+
+// ---------- 匹配与排序（pi-tui autocomplete.js） ----------
+
+/** pi 一次最多列 20 条 */
+export const MENTION_LIMIT = 20;
+
+export interface MentionSuggestion {
+	candidate: PathCandidate;
+	/** 文件名，目录带尾斜杠（pi 的 label） */
+	label: string;
+	/** 路径（pi 的 description）：按用户打的目录前缀显示，如 `./src/lib` */
+	description: string;
+}
+
+function toDisplayPath(value: string): string {
+	return value.replace(/\\/g, "/");
+}
+
+function baseName(path: string): string {
+	const trimmed = path.replace(/\/+$/, "");
+	return trimmed.slice(trimmed.lastIndexOf("/") + 1);
+}
+
+function escapeRegex(value: string): string {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/** pi 的 buildFdPathQuery：带 `/` 的查询按段转义、段间允许 `/` 或 `\` */
+function buildFdPathQuery(query: string): string {
+	const normalized = toDisplayPath(query);
+	if (!normalized.includes("/")) return normalized;
+	const trimmed = normalized.replace(/^\/+|\/+$/g, "");
+	if (!trimmed) return normalized;
+	const segments = trimmed.split("/").filter(Boolean).map(escapeRegex);
+	if (!segments.length) return normalized;
+	const separator = "[\\\\/]";
+	return segments.join(separator) + (normalized.endsWith("/") ? separator : "");
+}
+
+/**
+ * fd 的过滤：模式当正则，smart case（模式里有大写字母才区分大小写，转义序列如 `\W` 不算）。
+ * fd 用的是 Rust 正则，`c++` 这种叠加量词它能编（等于 `(c+)+`），JS 会报错：
+ * 编不过就退回字面包含——之后 scoreEntry 本来就要求查询按字面出现，所以 `c++` 的结果和 pi 一样；
+ * Rust 也编不过的（未闭合的括号等）pi 没有候选，这里按字面给，算有意放宽。
+ */
+function fdFilter(pattern: string): (target: string) => boolean {
+	const caseSensitive = /\p{Lu}/u.test(pattern.replace(/\\./g, ""));
+	try {
+		const regex = new RegExp(pattern, caseSensitive ? "" : "i");
+		return (target) => regex.test(target);
+	} catch {
+		const literal = caseSensitive ? pattern : pattern.toLowerCase();
+		return (target) => (caseSensitive ? target : target.toLowerCase()).includes(literal);
+	}
+}
+
+/** pi 的 scoreEntry：文件名全等 100 / 前缀 80 / 包含 50 / 整条路径包含 30，目录命中再 +10 */
+export function scoreEntry(filePath: string, query: string, isDirectory: boolean): number {
+	const lowerFileName = baseName(filePath).toLowerCase();
+	const lowerQuery = query.toLowerCase();
+	let score = 0;
+	if (lowerFileName === lowerQuery) score = 100;
+	else if (lowerFileName.startsWith(lowerQuery)) score = 80;
+	else if (lowerFileName.includes(lowerQuery)) score = 50;
+	else if (filePath.toLowerCase().includes(lowerQuery)) score = 30;
+	if (isDirectory && score > 0) score += 10;
+	return score;
+}
+
+/**
+ * pi 的 resolveScopedFuzzyQuery：最后一个 `/` 之前是目录（必须存在），之后是查询。
+ * 返回 base = 工作区相对路径（"" 为根），displayBase = 用户打的原样前缀。
+ */
+function resolveScopedQuery(rawQuery: string, dirs: ReadonlySet<string>): { base: string; query: string; displayBase: string } | null {
+	const normalized = toDisplayPath(rawQuery);
+	const slash = normalized.lastIndexOf("/");
+	if (slash === -1) return null;
+	const displayBase = normalized.slice(0, slash + 1);
+	if (displayBase.startsWith("/") || displayBase.startsWith("~/")) return null;
+	const segments: string[] = [];
+	for (const segment of displayBase.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") {
+			if (!segments.length) return null;
+			segments.pop();
+		} else segments.push(segment);
+	}
+	const base = segments.join("/");
+	if (base && !dirs.has(base)) return null;
+	return { base, query: normalized.slice(slash + 1), displayBase };
+}
+
+interface Entry {
+	candidate: PathCandidate;
+	/** 相对 fd 搜索目录的路径，目录带尾斜杠（和 fd 的输出一致，长度和字典序都按它算） */
+	path: string;
+	score: number;
+	depth: number;
+}
+
+/**
+ * 候选排序与截断，和 pi 一致：空查询全部 1 分，按层级 → 路径长度 → 字典序（先看当前目录、名字短的在前）。
+ * 不在模块里缓存目录集合：调用方用 useMemo 包住整次计算。
+ */
+export function suggestPaths(candidates: readonly PathCandidate[], rawQuery: string, limit = MENTION_LIMIT): MentionSuggestion[] {
+	const dirs = new Set<string>();
+	for (const candidate of candidates) if (candidate.dir) dirs.add(candidate.path);
+	const scoped = resolveScopedQuery(rawQuery, dirs);
+	const query = scoped ? scoped.query : rawQuery;
+	const prefix = scoped?.base ? `${scoped.base}/` : "";
+
+	let filter: ((relative: string) => boolean) | null = null;
+	if (query) {
+		// 默认只拿文件名去匹配；查询带 `/` 时（目录不存在、没走上面的限定目录）匹配整条路径
+		const fullPath = toDisplayPath(query).includes("/");
+		const matches = fdFilter(buildFdPathQuery(query));
+		filter = fullPath ? matches : (relative) => matches(baseName(relative));
+	}
+
+	const entries: Entry[] = [];
+	for (const candidate of candidates) {
+		if (prefix && !candidate.path.startsWith(prefix)) continue;
+		const relative = candidate.path.slice(prefix.length);
+		if (!relative || (filter && !filter(relative))) continue;
+		const path = candidate.dir ? `${relative}/` : relative;
+		const score = query ? scoreEntry(path, query, candidate.dir) : 1;
+		if (score <= 0) continue;
+		entries.push({ candidate, path, score, depth: relative.split("/").filter(Boolean).length });
+	}
+	entries.sort((a, b) => b.score - a.score || a.depth - b.depth || a.path.length - b.path.length || a.path.localeCompare(b.path));
+
+	return entries.slice(0, limit).map(({ candidate, path }) => {
+		const withoutSlash = candidate.dir ? path.slice(0, -1) : path;
+		return {
+			candidate,
+			label: baseName(withoutSlash) + (candidate.dir ? "/" : ""),
+			description: scoped ? `${scoped.displayBase}${withoutSlash}` : withoutSlash,
+		};
+	});
+}
+
+// ---------- @ token（pi-tui extractAtPrefix） ----------
+
+/** pi 的 PATH_DELIMITERS */
+const PATH_DELIMITERS = new Set([" ", "\t", '"', "'", "="]);
+/** pi-tui utils.js 的 cjkBreakRegex / cjkPunctuationRegex / autocompleteSeparatorRegex（原样抄来，测试里核对 source） */
+export const CJK_BREAK_REGEX = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+const CJK_PUNCTUATION_REGEX = new RegExp(`(?:(?=\\p{Punctuation})${CJK_BREAK_REGEX.source}|[，．：；！？（）［］｛｝“”‘’…—])`, "u");
+export const AUTOCOMPLETE_SEPARATOR_REGEX = new RegExp(`(?:\\s|${CJK_PUNCTUATION_REGEX.source})`, "u");
+const TOKEN_START_REGEX = new RegExp(`(?:^|${AUTOCOMPLETE_SEPARATOR_REGEX.source})$`, "u");
+/** 正文里路径前常见的左括号类：`(@src` 也能触发；token 里有对应的右括号就保留（`app/[slug]`） */
+const PATH_WRAPPERS: Record<string, string> = { "(": ")", "[": "]", "{": "}", "<": ">", "`": "`" };
+
+function isDelimiter(character: string): boolean {
+	return PATH_DELIMITERS.has(character) || AUTOCOMPLETE_SEPARATOR_REGEX.test(character);
+}
+
+/** 最后一个分隔符的位置（按码点走，返回它最后一个 UTF-16 单元的下标），没有则 -1 */
+function findLastDelimiter(text: string): number {
+	let last = -1;
+	let index = 0;
+	for (const character of text) {
+		index += character.length;
+		if (isDelimiter(character)) last = index - 1;
+	}
+	return last;
+}
+
+function stripLeadingWrappers(token: string): string {
+	let result = token;
+	while (result.length > 0) {
+		const closer = PATH_WRAPPERS[result[0]];
+		if (!closer || result.includes(closer, 1)) break;
+		result = result.slice(1);
+	}
+	return result;
+}
+
+function findUnclosedQuoteStart(text: string): number | null {
+	let inQuotes = false;
+	let quoteStart = -1;
+	for (let i = 0; i < text.length; i += 1) {
+		if (text[i] === '"') {
+			inQuotes = !inQuotes;
+			if (inQuotes) quoteStart = i;
+		}
+	}
+	return inQuotes ? quoteStart : null;
+}
+
+function isTokenStart(text: string, index: number): boolean {
+	let start = index;
+	while (start > 0 && PATH_WRAPPERS[text[start - 1]]) start -= 1;
+	return PATH_DELIMITERS.has(text[start - 1] ?? "") || TOKEN_START_REGEX.test(text.slice(0, start));
+}
+
+/**
+ * 光标前的 `@` 引用 token，规则同 pi：
+ * 从最后一个分隔符（空白、`"` `'` `=`、中日韩标点）之后取一段，去掉开头的左括号类，以 `@` 开头才算
+ * （`foo@bar` 这种邮箱不触发）；另支持 `@"带空格 的路径`。返回 null 表示当前不该弹候选。
+ * pi 只看光标所在的那一行；光标在 token 中间时（`@lib|bar`）删除范围盖住整个 token，免得留下半截。
+ */
+export function atToken(text: string, caret: number): { query: string; start: number; end: number; tokenEnd: number } | null {
+	const end = Math.max(0, Math.min(caret, text.length));
+	const lineStart = text.lastIndexOf("\n", end - 1) + 1;
+	const line = text.slice(lineStart, end);
+
+	const quoteStart = findUnclosedQuoteStart(line);
+	if (quoteStart !== null && quoteStart > 0 && line[quoteStart - 1] === "@" && isTokenStart(line, quoteStart - 1)) {
+		const close = text.indexOf('"', end);
+		const lineEnd = text.indexOf("\n", end);
+		const closed = close !== -1 && (lineEnd === -1 || close < lineEnd);
+		return { query: line.slice(quoteStart + 1), start: lineStart + quoteStart - 1, end, tokenEnd: closed ? close + 1 : end };
+	}
+
+	const tokenStart = findLastDelimiter(line) + 1;
+	const raw = line.slice(tokenStart);
+	const token = stripLeadingWrappers(raw);
+	if (!token.startsWith("@")) return null;
+	let tokenEnd = end;
+	for (const character of text.slice(end)) {
+		if (isDelimiter(character)) break;
+		tokenEnd += character.length;
+	}
+	return { query: token.slice(1), start: lineStart + tokenStart + raw.length - token.length, end, tokenEnd };
+}