@tian.zuo/pi-beautify-style 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @tian.zuo/pi-beautify-style
 
+## 0.3.0
+
+### Minor Changes
+
+- [#201](https://github.com/TianZuo555/pi-extensions/pull/201) [`fad61ea`](https://github.com/TianZuo555/pi-extensions/commit/fad61ea8cd833d5efc22c2e171507414f87e179a) Thanks [@TianZuo555](https://github.com/TianZuo555)! - Use a leading `## Heading` (or `**Bold**` line) from the reasoning as the thinking card title on every provider, not only OpenAI Responses. The title shows while the reasoning streams and stays on the finished card (`Plan · Thought for 8s`). Headings quoted from tool output mid-reasoning are ignored.
+
+- [#201](https://github.com/TianZuo555/pi-extensions/pull/201) [`fad61ea`](https://github.com/TianZuo555/pi-extensions/commit/fad61ea8cd833d5efc22c2e171507414f87e179a) Thanks [@TianZuo555](https://github.com/TianZuo555)! - Show the current reasoning step instead of `Thinking...` when the reasoning has no heading (DeepSeek, GLM, Kimi, and other `reasoning_content` models): `Step 3 · Check the CI config · 6s`. A step comes from an intent sentence (`Let me …`, `I'll …`, `让我…`), a lead such as `Plan:` or `Decision:`, or a rethink (`Actually, let me …`). Each label stays at least 800 ms, so fast thoughts do not flicker. The finished card keeps the last step and the count: `Check the CI config · Thought for 8s · 3 steps`.
+
 ## 0.2.0
 
 ### Minor Changes

package/README.md

@@ -90,6 +90,13 @@ and restart Pi to change behavior.
 > summary title — that heading becomes the card title while it streams, and stays
 > on the finished card (`Plan · Thought for 8s`). A heading copied out of tool
 > output mid-reasoning is ignored.
+>
+> Raw reasoning with no heading (DeepSeek, GLM, Kimi, and other
+> `reasoning_content` models) shows its current step instead of `Thinking...`:
+> `Step 3 · Check the CI config · 6s`. A step comes from an intent sentence
+> (`Let me …`, `I'll …`, `让我…`), a lead such as `Plan:` or `Decision:`, or a
+> rethink (`Actually, let me …`). The finished card keeps the last step and the
+> count: `Check the CI config · Thought for 8s · 3 steps`.
 
 > [!NOTE]
 > For Mermaid diagrams, set `markdown.mermaid` to `final` in

package/extensions/config/config.ts

@@ -54,9 +54,11 @@ export type Config = {
 	toolLabelClip: number;
 	/**
 	 * Title the reasoning card from a heading the reasoning leads with: an OpenAI
-	 * Responses summary heading, or a leading `# Heading` / `**Bold**` line. Other
-	 * providers get no title because their reasoning carries no reliable heading.
-	 * The title stays on the finished card (`Plan · Thought for 8s`).
+	 * Responses summary heading, or a leading `# Heading` / `**Bold**` line. Reasoning
+	 * without a heading shows its current step while it streams (`Step 3 · Check the
+	 * CI config`), taken from intent sentences such as `Let me …` or leads such as
+	 * `Plan:`. The title stays on the finished card (`Plan · Thought for 8s`, or
+	 * `Check the CI config · Thought for 8s · 3 steps`).
 	 */
 	useSummaryTitlesAsThinkingTitle: boolean;
 	/**

package/extensions/feature/compact-thinking.ts

@@ -29,6 +29,12 @@ import {
 	styleCompactThinkingText,
 } from "../renderer/compact-mode.ts";
 import { refreshMountedTranscript } from "../renderer/transcript-refresh.ts";
+import {
+	formatStepCount,
+	formatThinkingStep,
+	parseThinkingSteps,
+	type ThinkingStep,
+} from "./thinking-steps.ts";
 import {
 	COMPACT_THINKING_OWNER,
 	COMPACT_THINKING_PATCH_KEY,
@@ -49,6 +55,9 @@ export type CompactThinkingConfig = {
 	 * Use a title that the reasoning leads with — an OpenAI Responses summary
 	 * heading or a leading `# Heading` / `**Bold**` line — as the card heading
 	 * instead of the `Thinking...` label. The title stays on the finished card.
+	 * Reasoning without a title shows its current step instead
+	 * (`Step 3 · Check the CI config`); the finished card keeps the last step and
+	 * the step count.
 	 */
 	useSummaryTitlesAsThinkingTitle: boolean;
 	/**
@@ -132,6 +141,8 @@ const config: CompactThinkingConfig = {
 };
 
 const DURATION_ENTRY_TYPE = "compact-thinking-duration";
+/** A live step label stays at least this long before the next one replaces it. */
+const STEP_LABEL_MIN_MS = 800;
 
 /** 当前激活 session 的只读查询委托（compact 渲染层使用）。 */
 type ThinkingDurationQuery = (messageTimestamp: number) => number | undefined;
@@ -690,6 +701,30 @@ function compactThinking(pi: ExtensionAPI) {
 	let animationFrame = 0;
 	let compactSummaryActive = false;
 	let patchInstalled = true;
+	/** Live step label on screen per run (`timestamp:runStartIndex`), for the flicker hold. */
+	const shownSteps = new Map<string, { label: string; count: number; shownAt: number }>();
+	let stepMemo: { text: string; streaming: boolean; steps: ThinkingStep[] } | undefined;
+
+	function stepsOf(text: string, streaming: boolean): ThinkingStep[] {
+		if (stepMemo?.text !== text || stepMemo.streaming !== streaming) {
+			stepMemo = { text, streaming, steps: parseThinkingSteps(text, streaming) };
+		}
+		return stepMemo.steps;
+	}
+
+	/** Keep the shown step for STEP_LABEL_MIN_MS so fast thoughts do not flicker. */
+	function heldStep(key: string, label: string, count: number) {
+		const now = Date.now();
+		const shown = shownSteps.get(key);
+		if (shown && shown.label !== label && now - shown.shownAt < STEP_LABEL_MIN_MS) return shown;
+		if (shown?.label === label) {
+			shown.count = count;
+			return shown;
+		}
+		const next = { label, count, shownAt: now };
+		shownSteps.set(key, next);
+		return next;
+	}
 
 	function thinkingStyle(text: string) {
 		return styleCompactThinkingText(text, activeTheme);
@@ -792,30 +827,40 @@ function compactThinking(pi: ExtensionAPI) {
 						(previous.type === "thinking" && previous.thinking.trim()),
 				);
 			const thinkingBlocks: string[] = [];
+			// Untrimmed text: a trailing newline proves the last sentence is complete.
+			const rawThinkingBlocks: string[] = [];
 			let latestSummary: SummaryPart | undefined;
+			const responses = isOpenAiResponsesMessage(message);
 			for (; i < message.content.length; i++) {
 				const thinkingContent = message.content[i];
 				if (thinkingContent.type !== "thinking") break;
 				const thinking = thinkingContent.thinking.trim();
 				if (!thinking) continue;
 				thinkingBlocks.push(thinking);
+				rawThinkingBlocks.push(thinkingContent.thinking);
 
 				if (config.useSummaryTitlesAsThinkingTitle) {
 					const contentIsActive =
 						activeThinking?.messageTimestamp === message.timestamp &&
 						activeThinking.contentIndex === i;
+					// Raw reasoning: a block's leading title names the card and leaves that
+					// block's body. Every block of the run stays in the preview.
+					if (!responses) {
+						const leading = parseLeadingTitle(thinking, contentIsActive);
+						if (leading) {
+							latestSummary = leading;
+							thinkingBlocks[thinkingBlocks.length - 1] = leading.body;
+						}
+						continue;
+					}
 					// During streaming, thinkingSignature may contain only the previously
 					// completed summary parts. Prefer the live text so a newly arriving
 					// title immediately replaces the old one instead of appearing in its
 					// preview body. Once complete, the structured signature is canonical.
 					// OpenAI Responses concatenates several summary parts in one block, so
-					// only there does the newest title win; any other provider only gets a
-					// title from the leading line of its reasoning.
+					// the newest title wins and its summary body is the preview.
 					const titleFromText = (streaming: boolean) =>
-						isOpenAiResponsesMessage(message)
-							? (parseLatestTitle(thinking, streaming) ??
-								parseLeadingTitle(thinking, streaming))
-							: parseLeadingTitle(thinking, streaming);
+						parseLatestTitle(thinking, streaming) ?? parseLeadingTitle(thinking, streaming);
 					const titleFromSignature = getLatestOpenAiSummary(
 						thinkingContent.thinkingSignature,
 					);
@@ -842,8 +887,23 @@ function compactThinking(pi: ExtensionAPI) {
 			const durationMs = active ? elapsedMs : completedMs;
 			const durationText = durationMs === undefined ? undefined : formatThoughtDuration(durationMs);
 
+			const steps =
+				config.useSummaryTitlesAsThinkingTitle && !latestSummary
+					? stepsOf(rawThinkingBlocks.join("\n\n"), active)
+					: [];
+			const lastStep = steps.at(-1);
+
 			let heading: string;
-			if (active && latestSummary) {
+			if (active && lastStep) {
+				const shown = heldStep(
+					`${message.timestamp}:${runStartIndex}`,
+					formatThinkingStep(lastStep),
+					steps.length,
+				);
+				heading =
+					animatedText(`Step ${shown.count} · ${shown.label}`, thinkingStyle, true) +
+					(durationText ? thinkingStyle(` · ${durationText}`) : "");
+			} else if (active && latestSummary) {
 				heading =
 					animatedText(latestSummary.title, summaryTitleStyle, true) +
 					(durationText ? thinkingStyle(` · ${durationText}`) : "");
@@ -857,13 +917,17 @@ function compactThinking(pi: ExtensionAPI) {
 				// A detected title stays in front of it, so the card keeps its identity
 				// after the run. 无时长记录（中断流/旧会话/entry 缺失或索引错位）时不回退到
 				// 加载文案 "Thinking..."：改用标题或中性 "Thought"。
-				const title = latestSummary?.title;
-				const status = durationText ? `Thought for ${durationText}` : undefined;
-				heading = thinkingStyle(
-					title ? (status ? `${title} · ${status}` : title) : (status ?? "Thought"),
-				);
+				// Without a title, the last step names the card and the step count follows.
+				const title = latestSummary?.title ?? (lastStep && formatThinkingStep(lastStep));
+				const parts = [
+					title,
+					durationText ? `Thought for ${durationText}` : undefined,
+					lastStep ? formatStepCount(steps.length) : undefined,
+				].filter((part): part is string => Boolean(part));
+				heading = thinkingStyle(parts.length > 0 ? parts.join(" · ") : "Thought");
 			}
-			const previewSource = (latestSummary?.body ?? thinkingBlocks.join("\n\n")).trim();
+			const fullRun = thinkingBlocks.filter(Boolean).join("\n\n");
+			const previewSource = (responses ? (latestSummary?.body ?? fullRun) : fullRun).trim();
 			self.contentContainer.addChild(
 				new ThinkingPreviewBlock(
 					heading,
@@ -968,6 +1032,7 @@ function compactThinking(pi: ExtensionAPI) {
 			startedAt: Date.now(),
 		};
 		streamingComponents.clear();
+		shownSteps.clear();
 		animationFrame = 0;
 
 		// Depending on event-listener order, Pi may have rendered the empty
@@ -1003,6 +1068,7 @@ function compactThinking(pi: ExtensionAPI) {
 		} as DurationEntryData);
 
 		activeThinking = undefined;
+		shownSteps.clear();
 		stopAnimationTimerIfIdle();
 
 		const components = [...streamingComponents];

package/extensions/feature/thinking-steps.ts

@@ -0,0 +1,123 @@
+// Step labels for raw chain-of-thought reasoning (DeepSeek, GLM, Kimi, Claude, …).
+// These providers stream no headings, so the card would only say `Thinking...`.
+// The reasoning still narrates itself: one paragraph per thought, an intent
+// sentence (`Let me check X.`) for the next action, a pivot word (`Wait`,
+// `Actually`) for a rethink, and a labeled lead (`Plan:`, `Decision:`) for a
+// milestone. Each paragraph gives at most one step.
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+export type ThinkingStepKind = "intent" | "rethink" | "milestone";
+
+export type ThinkingStep = {
+	kind: ThinkingStepKind;
+	label: string;
+};
+
+/** Max columns of a step label, so the duration after it stays visible. */
+const MAX_STEP_WIDTH = 60;
+
+const LEAD_WORDS =
+	"ok|okay|so|now|next|then|first|finally|good|great|alright|right|actually|wait|hmm+|but|and|also|instead|alternatively";
+const INTENT_EN = new RegExp(
+	`^(?:(?:${LEAD_WORDS})[,.!:;—–-]*\\s+)*(?:let me|let's|let us|i'll|i will|i'm going to|i need to)\\s+(?:(?:also|quickly|first|now|just|then|next|still)\\s+)*(.+)$`,
+	"i",
+);
+const INTENT_ZH =
+	/^(?:好的?|那么|现在|接下来|然后|首先|最后|嗯|不过|其实)?[，,、\s]*(?:让我|我来|我先|我需要|我要|我将|下一步)[，,：:\s]*(.+)$/;
+const PIVOT_EN = /^(?:wait|actually|but wait|alternatively|hold on|on second thought|instead)\b/i;
+const PIVOT_ZH = /^(?:不对|等等|其实|或者|换个思路)/;
+const MILESTONE =
+	/^(plan|decision|conclusion|confirmed|root cause|key question|approach|goal|summary|fix|findings?|result|answer|计划|结论|决定|方案|原因|根因|目标)[ \t]*[:：][ \t]*([\s\S]*)$/i;
+const LIST_MARKER = /^\s*(?:\d+[.)]|[-*•])\s+/;
+/** End of a complete sentence or line. A `.` counts only before whitespace, so `foo.ts` is not cut. */
+const BOUNDARY = /[.!?](?=\s)|[。！？]|\n/g;
+
+function completePart(text: string): string {
+	let end = 0;
+	for (const match of text.matchAll(BOUNDARY)) end = match.index + match[0].length;
+	return text.slice(0, end);
+}
+
+function sentences(paragraph: string): string[] {
+	return paragraph
+		.split("\n")
+		.flatMap((line) => line.split(/(?<=[.!?])\s+(?=\S)|(?<=[。！？])/))
+		.map((sentence) => sentence.trim())
+		.filter(Boolean);
+}
+
+function clean(text: string): string {
+	const plain = text
+		.replace(/\s+/g, " ")
+		.replace(/[\s.!?:;,。！？：；，…]+$/, "")
+		.trim();
+	if (visibleWidth(plain) <= MAX_STEP_WIDTH) return plain;
+	let out = "";
+	let width = 0;
+	for (const char of plain) {
+		const charWidth = visibleWidth(char);
+		if (width + charWidth > MAX_STEP_WIDTH - 1) break;
+		out += char;
+		width += charWidth;
+	}
+	return `${out.trimEnd()}…`;
+}
+
+function capitalize(text: string): string {
+	return text.charAt(0).toUpperCase() + text.slice(1);
+}
+
+function milestoneStep(paragraph: string): ThinkingStep | undefined {
+	const match = MILESTONE.exec(paragraph);
+	if (!match) return undefined;
+	const lead = capitalize(match[1]);
+	const first = match[2]
+		.split("\n")
+		.map((line) => line.replace(LIST_MARKER, "").trim())
+		.find(Boolean);
+	const detail = first ? clean(sentences(first)[0] ?? "") : "";
+	return { kind: "milestone", label: detail ? clean(`${lead}: ${detail}`) : lead };
+}
+
+function intentStep(paragraph: string): ThinkingStep | undefined {
+	const all = sentences(paragraph);
+	for (let i = all.length - 1; i >= 0; i--) {
+		const sentence = all[i];
+		const english = INTENT_EN.exec(sentence);
+		const action = english?.[1] ?? INTENT_ZH.exec(sentence)?.[1];
+		if (!action || /^know\b/i.test(action)) continue;
+		const label = clean(english ? capitalize(action) : action);
+		if (label.length < 3) continue;
+		const pivot = PIVOT_EN.test(sentence) || PIVOT_ZH.test(sentence);
+		return { kind: pivot ? "rethink" : "intent", label };
+	}
+	return undefined;
+}
+
+/**
+ * Steps found in reasoning text, oldest first. While the text streams, the
+ * unfinished last sentence is ignored, so a label never shows half a word.
+ */
+export function parseThinkingSteps(text: string, streaming: boolean): ThinkingStep[] {
+	const source = (streaming ? completePart(text) : text)
+		// Code in a fence is quoted material, not narration. An open fence runs to the end.
+		.replace(/```[\s\S]*?(?:```|$)/g, "\n")
+		.replace(/\*\*|`/g, "");
+	const steps: ThinkingStep[] = [];
+	for (const raw of source.split(/\n[ \t]*\n/)) {
+		const paragraph = raw.trim();
+		if (!paragraph) continue;
+		const step = milestoneStep(paragraph) ?? intentStep(paragraph);
+		if (step) steps.push(step);
+	}
+	return steps;
+}
+
+/** Card text of one step. */
+export function formatThinkingStep(step: ThinkingStep): string {
+	return step.kind === "rethink" ? clean(`Rethinking: ${step.label}`) : step.label;
+}
+
+export function formatStepCount(count: number): string {
+	return count === 1 ? "1 step" : `${count} steps`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tian.zuo/pi-beautify-style",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Claude Code-style TUI for the pi coding agent: tool cards, rich diffs, compact mode, footer chips, and integrations for this repo's ask-user, background-terminals, and usage extensions.",
   "type": "module",
   "keywords": [