pi-lazy-panel 0.1.0

package/src/config/keys.ts

@@ -0,0 +1,279 @@
+/**
+ * Key chord parsing and matching on top of pi-tui's `matchesKey`.
+ *
+ * Pure functions, no UI. Responsibilities:
+ *   - normalise a user-written chord ("G", "ctrl+d", "gg", "ctrl+w h") into
+ *     a sequence of pi-tui key ids ("shift+g", "ctrl+d", ["g","g"], ...)
+ *   - match one raw terminal input chunk against one key id
+ *   - resolve a (scope, pending keys) pair to an ActionId with multi-key
+ *     sequence support (vim-style "gg")
+ *
+ * 键位解析：用户配置里的 "G" 等价于 "shift+g"，"gg" 会被拆成两步按键序列。
+ * 匹配时优先用 pi-tui 的 matchesKey（它已经处理 ctrl/alt/shift/kitty 协议），
+ * 再回退到 kitty CSI-u 里解码出来的可打印字符（例如 kitty 终端下的 "?"）。
+ */
+
+import { decodeKittyPrintable, isKeyRelease, type KeyId, matchesKey } from "@earendil-works/pi-tui";
+import { KEY_SCOPES, TREE_DIALOG_SCOPE } from "../constants.ts";
+import type { ActionId, KeyChord, Keymap, KeyScope, PaneKeymap } from "../types.ts";
+
+/** Key names pi-tui understands that are longer than one character. */
+const NAMED_KEYS = new Set([
+	"escape",
+	"esc",
+	"enter",
+	"return",
+	"tab",
+	"space",
+	"backspace",
+	"delete",
+	"insert",
+	"clear",
+	"home",
+	"end",
+	"pageup",
+	"pagedown",
+	"up",
+	"down",
+	"left",
+	"right",
+	"f1",
+	"f2",
+	"f3",
+	"f4",
+	"f5",
+	"f6",
+	"f7",
+	"f8",
+	"f9",
+	"f10",
+	"f11",
+	"f12",
+]);
+
+const MODIFIERS = new Set(["ctrl", "shift", "alt", "super"]);
+
+/** Canonical (pi-tui) key ids that make up one chord, in press order. */
+export type KeySequence = string[];
+
+/**
+ * Normalise one key step. Accepts "G", "shift+g", "Ctrl+D", "Tab", "?".
+ * Returns the lowercase pi-tui key id, or undefined when the step is invalid.
+ */
+export function normalizeKeyStep(step: string): string | undefined {
+	const raw = step.trim();
+	if (!raw) return undefined;
+	// A bare "+" is a valid symbol key; anything else is split on "+".
+	const parts = raw === "+" ? ["+"] : raw.split("+").filter((p) => p.length > 0);
+	if (parts.length === 0) return undefined;
+	const key = parts[parts.length - 1]!;
+	const mods = new Set(parts.slice(0, -1).map((m) => m.toLowerCase()));
+	for (const m of mods) if (!MODIFIERS.has(m)) return undefined;
+
+	let base: string;
+	if (key.length === 1) {
+		// Uppercase letter is shorthand for shift+letter ("G" -> "shift+g").
+		if (key >= "A" && key <= "Z") {
+			mods.add("shift");
+			base = key.toLowerCase();
+		} else {
+			base = key;
+		}
+	} else {
+		const lower = key.toLowerCase();
+		if (!NAMED_KEYS.has(lower)) return undefined;
+		// pi-tui spells these two in camelCase.
+		base = lower === "pageup" ? "pageUp" : lower === "pagedown" ? "pageDown" : lower;
+	}
+	const order = ["ctrl", "shift", "alt", "super"].filter((m) => mods.has(m));
+	return order.length ? `${order.join("+")}+${base}` : base;
+}
+
+/**
+ * Parse a chord into a key sequence.
+ *   "j"          -> ["j"]
+ *   "ctrl+d"     -> ["ctrl+d"]
+ *   "gg"         -> ["g", "g"]          (verbatim run of printable chars)
+ *   "ctrl+w h"   -> ["ctrl+w", "h"]     (space separated steps)
+ *   "G"          -> ["shift+g"]
+ * Returns undefined for chords that cannot be parsed.
+ */
+export function parseChord(chord: KeyChord): KeySequence | undefined {
+	const trimmed = chord.trim();
+	if (!trimmed) return undefined;
+	if (trimmed === "space") return ["space"];
+	const steps = trimmed.includes(" ") ? trimmed.split(/\s+/) : [trimmed];
+	const out: KeySequence = [];
+	for (const step of steps) {
+		const single = normalizeKeyStep(step);
+		if (single) {
+			out.push(single);
+			continue;
+		}
+		// Multi-character run like "gg" / "yy" / "zz": every char must be a plain key.
+		if (step.length > 1 && !step.includes("+")) {
+			const chars = [...step];
+			const ids = chars.map((c) => normalizeKeyStep(c));
+			if (ids.every((id): id is string => id !== undefined)) {
+				out.push(...ids);
+				continue;
+			}
+		}
+		return undefined;
+	}
+	return out;
+}
+
+/** Does one raw terminal input chunk match one canonical key id? */
+export function matchesKeyId(data: string, keyId: string): boolean {
+	if (isKeyRelease(data)) return false;
+	if (matchesKey(data, keyId as KeyId)) return true;
+	// kitty 协议下，shift+符号（如 "?"）以 CSI-u 形式到达，matchesKey 不识别，
+	// 这里解码成可打印字符再比较一次。
+	if (keyId.length === 1) {
+		const printable = decodeKittyPrintable(data);
+		if (printable === keyId) return true;
+	}
+	return false;
+}
+
+/** One compiled binding: action + the key sequence that triggers it. */
+export interface Binding {
+	scope: KeyScope;
+	action: ActionId;
+	seq: KeySequence;
+	/** Original chord text, for help display. */
+	chord: KeyChord;
+}
+
+/** Flatten one scope of the keymap into bindings. Invalid chords are skipped. */
+export function compileScope(scope: KeyScope, keymap: PaneKeymap): Binding[] {
+	const out: Binding[] = [];
+	for (const [action, chords] of Object.entries(keymap) as Array<[ActionId, KeyChord | KeyChord[] | undefined]>) {
+		if (chords === undefined) continue;
+		for (const chord of Array.isArray(chords) ? chords : [chords]) {
+			const seq = parseChord(chord);
+			if (seq) out.push({ scope, action, seq, chord });
+		}
+	}
+	return out;
+}
+
+export type ResolveResult =
+	| { kind: "action"; action: ActionId; scope: KeyScope }
+	| { kind: "pending" }
+	| { kind: "none" };
+
+/**
+ * Scopes consulted for `focus`, innermost first: a pane shadows the global
+ * bindings, the tree dialog shadows the tree pane which shadows global.
+ *
+ * 键位查找顺序：对话框 → tree 面板 → global；面板 → global。
+ */
+export function scopeChain(focus: KeyScope): KeyScope[] {
+	if (focus === "global") return ["global"];
+	if (focus === TREE_DIALOG_SCOPE) return [TREE_DIALOG_SCOPE, "tree", "global"];
+	return [focus, "global"];
+}
+
+/**
+ * Resolve the pressed key sequence against the focused scope first, then the
+ * outer ones (see `scopeChain`). Inner bindings shadow outer ones for the same key.
+ *
+ * `pressed` holds the raw input chunks pressed so far (including the current
+ * one). "pending" means some binding starts with this prefix but needs more
+ * keys; the caller should buffer and wait.
+ */
+export function resolveKeys(bindings: Binding[], focus: KeyScope, pressed: string[]): ResolveResult {
+	const order = scopeChain(focus);
+	let pending = false;
+	for (const scope of order) {
+		for (const b of bindings) {
+			if (b.scope !== scope) continue;
+			const state = matchSequence(b.seq, pressed);
+			if (state === "match") return { kind: "action", action: b.action, scope };
+			if (state === "prefix") pending = true;
+		}
+		// 当前 scope 已经有前缀匹配时，不再回退到外层，避免 "g" 被 global 抢走。
+		if (pending) return { kind: "pending" };
+	}
+	return { kind: "none" };
+}
+
+function matchSequence(seq: KeySequence, pressed: string[]): "match" | "prefix" | "none" {
+	if (pressed.length > seq.length) return "none";
+	for (let i = 0; i < pressed.length; i++) {
+		if (!matchesKeyId(pressed[i]!, seq[i]!)) return "none";
+	}
+	return pressed.length === seq.length ? "match" : "prefix";
+}
+
+/** Compile a full keymap into a flat binding list. */
+export function compileKeymap(keymap: Keymap): Binding[] {
+	return KEY_SCOPES.flatMap((s) => compileScope(s, keymap[s]));
+}
+
+/** Human readable label for a chord, used by the footer and help overlay. */
+export function chordLabel(chord: KeyChord): string {
+	const seq = parseChord(chord);
+	if (!seq) return chord;
+	const steps = seq.map((id) =>
+		id
+			.split("+")
+			.map((part) => {
+				switch (part) {
+					case "ctrl":
+						return "Ctrl";
+					case "shift":
+						return "Shift";
+					case "alt":
+						return "Alt";
+					case "super":
+						return "Super";
+					case "tab":
+						return "Tab";
+					case "enter":
+					case "return":
+						return "Enter";
+					case "escape":
+					case "esc":
+						return "Esc";
+					case "space":
+						return "Space";
+					case "up":
+						return "↑";
+					case "down":
+						return "↓";
+					case "left":
+						return "←";
+					case "right":
+						return "→";
+					default:
+						// f1..f12 read better uppercase.
+						return /^f\d{1,2}$/.test(part) ? part.toUpperCase() : part;
+				}
+			})
+			.join("+")
+			// "Shift+g" reads better as "G".
+			.replace(/(^|\+)Shift\+([a-z])$/, (_m, pre: string, c: string) => `${pre}${c.toUpperCase()}`),
+	);
+	// vim 风格的纯字母序列（gg / yy）紧挨着显示；带修饰键或命名键的多步序列（ctrl+w h）用空格分开。
+	const plainRun = steps.every((s) => [...s].length === 1);
+	return steps.join(plainRun ? "" : " ");
+}
+
+/** All chords bound to `action` in `scope`, as display labels ("j / ↓"). */
+export function labelsFor(keymap: Keymap, scope: KeyScope, action: ActionId): string[] {
+	const chords = keymap[scope][action];
+	if (chords === undefined) return [];
+	return (Array.isArray(chords) ? chords : [chords]).map(chordLabel);
+}
+
+/** Labels for `action` as seen from `focus`: the innermost scope of `scopeChain(focus)` that binds it. */
+export function labelsForFocus(keymap: Keymap, focus: KeyScope, action: ActionId): string[] {
+	for (const scope of scopeChain(focus)) {
+		const labels = labelsFor(keymap, scope, action);
+		if (labels.length) return labels;
+	}
+	return [];
+}

package/src/config/pi-settings.ts

@@ -0,0 +1,54 @@
+/**
+ * pi's own settings that change how the panel behaves.
+ *
+ * The extension context exposes no settings API, so this reads pi's
+ * `~/.pi/agent/settings.json` (plus the project's `.pi/settings.json`)
+ * through pi's `SettingsManager`, the same way pi does. `SettingsManager.create`
+ * only reads the files (it takes the lock briefly and writes nothing). Only
+ * this module should know about pi's settings file.
+ *
+ * 目前用到两项：`branchSummary.skipPrompt`（为 true 时 pi 内置 /tree 不问 No summary /
+ * Summarize，直接不做摘要；面板的 TREE Enter 照做）和 `treeFilterMode`（内置 /tree 打开时的
+ * 默认过滤，面板的 TREE 以它作为初始过滤）。读不到就按 pi 的默认值来。
+ */
+
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
+import type { TreeFilter } from "../types.ts";
+
+export interface PiSettings {
+	/** `branchSummary.skipPrompt`: skip the "Summarize branch?" menu and restore without a summary. */
+	skipBranchSummaryPrompt: boolean;
+	/** `treeFilterMode`: the filter pi's /tree opens with, in the panel's naming (`labeled-only` → `labeled`). */
+	treeFilter: TreeFilter;
+}
+
+/** pi's defaults, used when the settings cannot be read. */
+export const DEFAULT_PI_SETTINGS: PiSettings = { skipBranchSummaryPrompt: false, treeFilter: "default" };
+
+/** pi's `treeFilterMode` values mapped to the panel's `TreeFilter`. */
+const TREE_FILTER_OF: Record<string, TreeFilter> = {
+	default: "default",
+	"no-tools": "no-tools",
+	"user-only": "user-only",
+	"labeled-only": "labeled",
+	all: "all",
+};
+
+/**
+ * Read the settings the panel cares about.
+ * @param cwd session working directory (for the project-level file)
+ * @param agentDir pi agent directory (usually ~/.pi/agent)
+ * @param projectTrusted whether pi trusts the project (untrusted projects ignore `.pi/settings.json`)
+ */
+export function loadPiSettings(cwd: string, agentDir: string, projectTrusted = true): PiSettings {
+	try {
+		const manager = SettingsManager.create(cwd, agentDir, { projectTrusted });
+		return {
+			skipBranchSummaryPrompt: manager.getBranchSummarySkipPrompt(),
+			// pi 自己已经把非法值归到 "default"，这里只是换成面板的命名。
+			treeFilter: TREE_FILTER_OF[manager.getTreeFilterMode()] ?? "default",
+		};
+	} catch {
+		return DEFAULT_PI_SETTINGS;
+	}
+}

package/src/constants.ts

@@ -0,0 +1,48 @@
+/**
+ * Project-wide constants.
+ */
+
+/** Extension identifier used for status/widget keys and log prefixes. */
+export const EXTENSION_ID = "lazy-panel";
+
+/** Slash command that opens the panel: `/lazy-panel`. */
+export const COMMAND_NAME = "lazy-panel";
+
+/** Name of the optional user config file inside the pi agent directory. */
+export const CONFIG_FILE_NAME = "lazy-panel.json";
+
+/** Layout ratio for the left column (sessions + tree) vs. the right column (content). */
+export const LEFT_COLUMN_RATIO = 0.25;
+
+/** Identifiers for the three focusable panes. */
+export const PANE_IDS = ["sessions", "tree", "content"] as const;
+
+/**
+ * Sort orders of the sessions pane in the order `s` cycles through them:
+ * recent (last update) → created → title (by the title the pane shows — name,
+ * else first-message preview — A–Z, empty sessions last) → threaded (forks
+ * indented under their parent, like pi's /resume). pi's "fuzzy" order only
+ * means something with a search query, so it is not offered here.
+ */
+export const SESSION_SORT_MODES = ["recent", "created", "title", "threaded"] as const;
+
+/**
+ * Key scope of the full tree dialog (`a` in the tree pane). Its bindings sit on
+ * top of the tree pane's, which sit on top of the global ones.
+ *
+ * 树对话框自己的键位 scope：对话框里先查这一层，再查 tree 面板，最后 global。
+ */
+export const TREE_DIALOG_SCOPE = "tree-dialog" as const;
+
+/** Every key scope of the keymap, in the order the user file lists them. */
+export const KEY_SCOPES = ["global", ...PANE_IDS, TREE_DIALOG_SCOPE] as const;
+
+/**
+ * Spinner frames for footer progress — a rotating square (正方形旋转). Kept here
+ * so slow operations (branch summary, compaction, the changelog dialog) share
+ * the same look. The progress text itself is localised via i18n (status.*).
+ */
+export const SPINNER_FRAMES = ["◰", "◳", "◲", "◱"] as const;
+
+/** How fast the footer spinner advances one frame. */
+export const SPINNER_INTERVAL_MS = 120;

package/src/data/changelog.ts

@@ -0,0 +1,63 @@
+/**
+ * pi's changelog, as `/changelog` shows it.
+ *
+ * pi reads `CHANGELOG.md` from its package directory, cuts it into one entry
+ * per `## [x.y.z]` heading and prints every entry. The parser
+ * (`utils/changelog.js`) is not exported by the package, so it is copied here;
+ * `getPackageDir` is exported and points at the running pi's install.
+ *
+ * 和 pi 内置 /changelog 读同一个文件、同样的切分规则；pi 的 parseChangelog 没有导出，这里照搬。
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { getPackageDir } from "@earendil-works/pi-coding-agent";
+
+/** What pi prints when the file has no entries. */
+export const NO_CHANGELOG = "No changelog entries found.";
+
+/** Path of the running pi's CHANGELOG.md. */
+export function changelogPath(): string {
+	return path.resolve(path.join(getPackageDir(), "CHANGELOG.md"));
+}
+
+/**
+ * Split changelog markdown into its version entries, in file order. Like pi:
+ * a `## ` line starts an entry when it carries a version (`## [0.86.1] - …`),
+ * text under a `## ` line without one (e.g. `## [Unreleased]`) is skipped.
+ */
+export function parseChangelog(markdown: string): string[] {
+	const entries: string[] = [];
+	let current: string[] | undefined;
+	const flush = () => {
+		if (current && current.length > 0) entries.push(current.join("\n").trim());
+	};
+	for (const line of markdown.split(/\r?\n/)) {
+		if (line.startsWith("## ")) {
+			flush();
+			current = /##\s+\[?(\d+)\.(\d+)\.(\d+)\]?/.test(line) ? [line] : undefined;
+		} else if (current) {
+			current.push(line);
+		}
+	}
+	flush();
+	return entries;
+}
+
+/**
+ * The markdown the dialog renders: every entry, or pi's "no entries" line.
+ * The file lists the newest version first; pi reverses it because its chat
+ * shows the bottom, the dialog opens at the top so it keeps the newest first.
+ *
+ * 和 pi 的一个差异：pi 倒序（最新的在最下面，聊天区看的是底部），弹窗从顶部开始看，所以保持文件顺序、最新的在最上面。
+ */
+export function changelogMarkdown(markdown: string): string {
+	const entries = parseChangelog(markdown);
+	return entries.length > 0 ? entries.join("\n\n") : NO_CHANGELOG;
+}
+
+/** Read the running pi's changelog (a missing file reads as "no entries", like pi). */
+export async function loadChangelog(file: string = changelogPath()): Promise<string> {
+	if (!existsSync(file)) return NO_CHANGELOG;
+	return changelogMarkdown(readFileSync(file, "utf-8"));
+}

package/src/data/content.ts

@@ -0,0 +1,178 @@
+/**
+ * Content data adapter.
+ *
+ * Produces the `ContentBlock[]` shown in the right-hand pane for a session
+ * (or a branch ending at a given tree node), distinguishing user vs assistant
+ * messages so they can be rendered in separate boxes.
+ */
+
+import { SessionManager, type SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { ContentBlock, ForkPoint, SessionInfo } from "../types.ts";
+import { normalizeNewlines, singleLine } from "../utils/format.ts";
+
+export interface LoadContentOptions {
+	sessionFile: string;
+	/** If set, show the branch that ends at this entry instead of the active leaf. */
+	leafEntryId?: string;
+}
+
+export async function loadContent(options: LoadContentOptions): Promise<ContentBlock[]> {
+	const manager = SessionManager.open(options.sessionFile);
+	const branch = manager.getBranch(options.leafEntryId ?? resolveContentLeaf(manager));
+	const blocks: ContentBlock[] = [];
+	for (const entry of branch) {
+		if (entry.type !== "message") continue;
+		const m = entry.message;
+		const timestamp = Date.parse(entry.timestamp);
+		if (m.role === "user") {
+			const markdown = partsToMarkdown(m.content);
+			if (markdown) blocks.push({ entryId: entry.id, role: "user", timestamp, markdown });
+		} else if (m.role === "assistant") {
+			const markdown = assistantToMarkdown(m.content);
+			if (markdown) blocks.push({ entryId: entry.id, role: "assistant", timestamp, markdown });
+		}
+	}
+	return blocks;
+}
+
+/**
+ * Entry id whose branch the panel shows by default.
+ *
+ * Normally the session's own leaf. Extensions may append bookkeeping entries
+ * that move the leaf onto a side branch with no messages at all; in that case
+ * fall back to the branch ending at the last message-bearing entry so the
+ * user still sees the conversation.
+ */
+export function resolveContentLeaf(manager: Pick<SessionManager, "getBranch" | "getEntries" | "getLeafId">): string | undefined {
+	const leafId = manager.getLeafId() ?? undefined;
+	if (leafId && manager.getBranch(leafId).some(isConversation)) return leafId;
+	const entries = manager.getEntries();
+	for (let i = entries.length - 1; i >= 0; i--) {
+		const e = entries[i]!;
+		if (isConversation(e)) return e.id;
+	}
+	return leafId;
+}
+
+/** User / assistant / tool traffic, as opposed to system prompts and bookkeeping entries. */
+function isConversation(entry: SessionEntry): boolean {
+	if (entry.type === "custom_message") return entry.display;
+	if (entry.type !== "message") return false;
+	const role = entry.message.role;
+	return role === "user" || role === "assistant" || role === "toolResult";
+}
+
+/**
+ * Every user message in the file, in order, as fork points for `/fork`'s selector.
+ *
+ * 照搬 pi 内置 /fork 的 `getUserMessagesForForking`：遍历所有条目（不限活动分支），
+ * 只取有文字的 user 消息（只有图片的不列），文本压成一行给选择器显示（选择器再按宽度截断）。
+ */
+export async function loadForkPoints(sessionFile: string): Promise<ForkPoint[]> {
+	const manager = SessionManager.open(sessionFile);
+	const points: ForkPoint[] = [];
+	for (const entry of manager.getEntries()) {
+		if (entry.type !== "message" || entry.message.role !== "user") continue;
+		const text = singleLine(textParts(entry.message.content, " "));
+		if (text) points.push({ entryId: entry.id, text });
+	}
+	return points;
+}
+
+/**
+ * Text of the last assistant message on the active branch (what `/copy` copies).
+ * `undefined` when there is nothing to copy.
+ *
+ * 照搬 pi 的 `getLastAssistantText`：跳过中止且没有内容的回复，取最后一条回复里的 text 片段
+ * 原样拼接（不含思考过程和工具调用）；这条回复只有工具调用时算没有可复制的，不再往前找。
+ */
+export async function loadLastReply(sessionFile: string): Promise<string | undefined> {
+	const manager = SessionManager.open(sessionFile);
+	const branch = manager.getBranch(resolveContentLeaf(manager));
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const entry = branch[i]!;
+		if (entry.type !== "message") continue;
+		const m = entry.message;
+		if (m.role !== "assistant") continue;
+		if (m.stopReason === "aborted" && m.content.length === 0) continue;
+		return textParts(m.content, "").trim() || undefined;
+	}
+	return undefined;
+}
+
+/** The `text` parts of a message joined by `separator` (images, thinking and tool calls left out). */
+function textParts(content: string | Part[], separator: string): string {
+	if (typeof content === "string") return normalizeNewlines(content);
+	return content
+		.filter((p) => p.type === "text")
+		.map((p) => normalizeNewlines(p.text ?? ""))
+		.join(separator);
+}
+
+type Part = { type: string; text?: string; name?: string; arguments?: Record<string, unknown> };
+
+function partsToMarkdown(content: string | Part[]): string {
+	if (typeof content === "string") return normalizeNewlines(content).trim();
+	return content
+		.map((p) => (p.type === "text" ? normalizeNewlines(p.text ?? "") : p.type === "image" ? "*[image]*" : ""))
+		.filter(Boolean)
+		.join("\n\n")
+		.trim();
+}
+
+function assistantToMarkdown(content: Part[]): string {
+	const out: string[] = [];
+	for (const p of content) {
+		if (p.type === "text" && p.text?.trim()) out.push(normalizeNewlines(p.text).trim());
+		else if (p.type === "toolCall") out.push(`*→ ${p.name ?? "tool"}${summarizeArgs(p.arguments)}*`);
+	}
+	return out.join("\n\n");
+}
+
+function summarizeArgs(args: Record<string, unknown> | undefined): string {
+	if (!args) return "";
+	const first = Object.values(args).find((v) => typeof v === "string") as string | undefined;
+	if (!first) return "";
+	const line = first.split(/\r?\n/)[0] ?? "";
+	return ` ${line.length > 60 ? `${line.slice(0, 60)}…` : line}`;
+}
+
+/** Gather the data shown by the Session Info dialog (mirrors /session). */
+export async function loadSessionInfo(sessionFile: string): Promise<SessionInfo | undefined> {
+	let manager: SessionManager;
+	try {
+		manager = SessionManager.open(sessionFile);
+	} catch {
+		return undefined;
+	}
+	const header = manager.getHeader();
+	let model: string | undefined;
+	let messages = 0;
+	let tokens = 0;
+	let cost = 0;
+	let updatedAt = header ? Date.parse(header.timestamp) : 0;
+	for (const entry of manager.getEntries()) {
+		updatedAt = Math.max(updatedAt, Date.parse(entry.timestamp));
+		if (entry.type === "model_change") model = entry.modelId;
+		if (entry.type !== "message") continue;
+		const m = entry.message as { role: string; usage?: { input?: number; output?: number; cost?: { total?: number } } };
+		if (m.role === "user" || m.role === "assistant") messages++;
+		if (m.role === "assistant" && m.usage) {
+			tokens += (m.usage.input ?? 0) + (m.usage.output ?? 0);
+			cost += m.usage.cost?.total ?? 0;
+		}
+	}
+	const info: SessionInfo = {
+		messages,
+		tokens,
+		cost,
+		createdAt: header ? Date.parse(header.timestamp) : 0,
+		updatedAt,
+		path: sessionFile,
+		id: manager.getSessionId(),
+	};
+	const name = manager.getSessionName();
+	if (name) info.name = name;
+	if (model) info.model = model;
+	return info;
+}