@quandev104/pi-style 0.1.1

package/extension-src/pi-style/pi/session-coordinator.ts

@@ -0,0 +1,187 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type KeyId, matchesKey } from "@earendil-works/pi-tui";
+import type { ConfigFilePort } from "../app/config-storage.js";
+import { createPiStyleApp, type PiStyleApp } from "../app/index.js";
+import { setSpecialBlockTheme } from "../features/messages/special-blocks.js";
+import { setToolsRenderConfig } from "../features/tools/boxed/session-config.js";
+import { createCompatibilityCoordinator } from "./compatibility-coordinator.js";
+import {
+	type CompatibilityCleanupResult,
+	type CompatibilityProbeReport,
+	disposePiCompatibilityProbe,
+} from "./compatibility-probe.js";
+import { createPiConfigFilePort, defaultStoragePaths } from "./config-host.js";
+import { createConfigSourceAdapter, readSessionAuthorization } from "./config-session.js";
+import { buildOperationalState } from "./operational-state.js";
+import { collectToolDetails } from "./startup-resources.js";
+
+export type CompatibilityTestHooks = {
+	dispose?: (report: CompatibilityProbeReport) => CompatibilityCleanupResult;
+	filePort?: ConfigFilePort;
+	paths?: (cwd: string) => { globalPath: string; projectPath: string };
+	/** Test-only capability seam; Pi's ExtensionContext does not provide a Git runner. */
+	gitRunner?: import("../domain/providers.js").GitCommandRunner;
+	/** Override the thinking-cycle key binding consumed to suppress Pi's status toast. */
+	thinkingCycleKey?: string;
+};
+
+const THINKING_CYCLE = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const;
+
+export function createPiStyleSessionCoordinator(pi: ExtensionAPI, hooks: CompatibilityTestHooks = {}) {
+	const filePort = hooks.filePort ?? createPiConfigFilePort();
+	const gitRunner =
+		hooks.gitRunner ??
+		({
+			run: async (args, commandCwd, timeoutMs, signal) => {
+				const result = await pi.exec("git", [...args], {
+					cwd: commandCwd,
+					timeout: timeoutMs,
+					...(signal ? { signal } : {}),
+				});
+				return { stdout: result.stdout, stderr: result.stderr, code: result.code };
+			},
+		} satisfies import("../domain/providers.js").GitCommandRunner);
+	let cwd = process.cwd();
+	let active = false;
+	let tuiSession = false;
+	let terminalInputUnsubscribe: (() => void) | undefined;
+	const source = createConfigSourceAdapter(
+		pi,
+		filePort,
+		hooks.paths ?? ((sessionCwd) => defaultStoragePaths(sessionCwd)),
+	);
+	const compatibility = createCompatibilityCoordinator(
+		(report) => hooks.dispose?.(report) ?? disposePiCompatibilityProbe(report),
+	);
+	// Initial read may be empty in real Pi (flag values apply after extension load);
+	// start() re-reads and re-captures at every session_start.
+	let authorization = readSessionAuthorization(pi);
+	let productGate: "omitted" | "allow" | "deny" = "omitted";
+	const syncOperational = (config: import("../domain/config-types.js").NormalizedPiStyleConfig) => {
+		app.setOperationalState(
+			buildOperationalState(
+				config,
+				authorization,
+				compatibility,
+				app.runtime.current?.installationState,
+				app.productPolicy.corePatchGate,
+			),
+		);
+	};
+	const app: PiStyleApp = createPiStyleApp(
+		undefined,
+		{
+			load: async (trusted) => {
+				source.setSession(cwd, trusted);
+				return source.load();
+			},
+		},
+		(config) => {
+			productGate = app.productPolicy.corePatchGate;
+			if (!active) return;
+			if (compatibility.report) {
+				const cleanup = compatibility.dispose();
+				if (!cleanup.complete) {
+					syncOperational(config);
+					return;
+				}
+			}
+			compatibility.install(config, tuiSession, productGate);
+			syncOperational(config);
+		},
+	);
+
+	return {
+		app,
+		async start(event: { reason: string }, ctx: ExtensionContext): Promise<void> {
+			// Authorization is session-bound: Pi applies extension flag values only after
+			// extension modules finish loading, so flags must be read here (session_start),
+			// never at coordinator creation time.
+			authorization = readSessionAuthorization(pi);
+			compatibility.captureAuthorization(
+				authorization.core,
+				authorization.user,
+				authorization.assistant,
+				authorization.specialBlocks,
+				authorization.tools,
+				authorization.ascii,
+			);
+			// Replacement is failure-atomic: retain the current runtime until
+			// compatibility ownership has been restored successfully.
+			if (compatibility.report) {
+				const cleanup = compatibility.dispose();
+				if (!cleanup.complete) {
+					syncOperational(app.config);
+					return;
+				}
+			}
+			if (app.runtime.current) app.sessionShutdown();
+			cwd = ctx.cwd ?? process.cwd();
+			tuiSession = ctx.mode === "tui";
+			app.setProjectTrusted(ctx.isProjectTrusted());
+			source.setSession(cwd, ctx.isProjectTrusted());
+			active = false;
+			await app.reload();
+			productGate = app.productPolicy.corePatchGate;
+			active = true;
+			compatibility.install(app.config, ctx.mode === "tui", productGate);
+			// Session-scoped render configuration for the boxed tool/message surfaces.
+			// Populated once per session (never inside render).
+			setToolsRenderConfig(app.config.tools);
+			if (ctx.ui?.theme) setSpecialBlockTheme(ctx.ui.theme as never);
+			const toolDetails = collectToolDetails(pi.getActiveTools?.(), pi.getAllTools?.());
+			app.sessionStart(
+				{
+					mode: ctx.mode,
+					hasUI: ctx.hasUI,
+					...(ctx.ui ? { ui: ctx.ui } : {}),
+					...(ctx.cwd ? { cwd: ctx.cwd } : {}),
+					...(ctx.model
+						? {
+								model: {
+									id: ctx.model.id,
+									name: ctx.model.name,
+									provider: ctx.model.provider,
+									reasoning: ctx.model.reasoning,
+								},
+							}
+						: {}),
+					...(ctx.thinkingLevel ? { thinkingLevel: ctx.thinkingLevel } : {}),
+					getContextUsage: ctx.getContextUsage,
+					projectTrusted: ctx.isProjectTrusted(),
+					gitRunner,
+				},
+				event.reason as "startup" | "reload" | "new" | "resume" | "fork",
+				{
+					...(typeof ctx.getSystemPrompt === "function" ? { systemPrompt: ctx.getSystemPrompt() } : {}),
+					...(toolDetails ? { toolDetails } : {}),
+					...(ctx.scopedModels && ctx.scopedModels.length > 0 ? { models: ctx.scopedModels.length } : {}),
+				},
+			);
+			terminalInputUnsubscribe?.();
+			terminalInputUnsubscribe = undefined;
+			// Consume Pi's default thinking-cycle key and re-issue it through the public API so
+			// the footer shows the level without Pi's transient "Thinking level: X" status toast.
+			const cycleKey = hooks.thinkingCycleKey ?? "shift+tab";
+			if (ctx.mode === "tui" && ctx.ui?.onTerminalInput) {
+				terminalInputUnsubscribe = ctx.ui.onTerminalInput((data) => {
+					if (!matchesKey(data, cycleKey as KeyId)) return undefined;
+					const current = pi.getThinkingLevel?.();
+					const index = Math.max(0, THINKING_CYCLE.indexOf(current as (typeof THINKING_CYCLE)[number]));
+					const next = THINKING_CYCLE[(index + 1) % THINKING_CYCLE.length];
+					pi.setThinkingLevel?.(next as never);
+					return { consume: true };
+				});
+			}
+			syncOperational(app.config);
+		},
+		shutdown(): void {
+			active = false;
+			tuiSession = false;
+			terminalInputUnsubscribe?.();
+			terminalInputUnsubscribe = undefined;
+			app.sessionShutdown();
+			compatibility.dispose();
+		},
+	};
+}

package/extension-src/pi-style/pi/session-usage.ts

@@ -0,0 +1,62 @@
+import type { SessionEntry } from "@earendil-works/pi-coding-agent";
+import type { UsageSnapshot } from "../domain/status.js";
+
+/**
+ * Minimal structural view of Pi's session manager: only the entry iteration
+ * needed to aggregate cumulative usage. `ExtensionContext.sessionManager`
+ * satisfies this shape.
+ */
+export interface SessionUsageSource {
+	getEntries(): readonly SessionEntry[];
+}
+
+interface UsageTotals {
+	input: number;
+	output: number;
+	cacheRead: number;
+	cacheWrite: number;
+	cost: number;
+}
+
+/**
+ * Aggregate cumulative token/cost usage from all session entries, mirroring
+ * Pi's native footer: assistant messages always carry usage, tool results and
+ * compaction/branch summaries carry it when available.
+ */
+export function usageFromSession(session: SessionUsageSource): UsageSnapshot | undefined {
+	const totals: UsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0 };
+	let sawUsage = false;
+	for (const entry of session.getEntries()) {
+		if (entry.type === "message") {
+			if (entry.message.role !== "assistant" && entry.message.role !== "toolResult") continue;
+			const usage = "usage" in entry.message ? entry.message.usage : undefined;
+			if (!usage) continue;
+			addUsage(totals, usage);
+			sawUsage = true;
+		} else if ((entry.type === "branch_summary" || entry.type === "compaction") && entry.usage) {
+			addUsage(totals, entry.usage);
+			sawUsage = true;
+		}
+	}
+	if (!sawUsage) return undefined;
+	return {
+		inputTokens: totals.input,
+		outputTokens: totals.output,
+		cacheReadTokens: totals.cacheRead,
+		cacheWriteTokens: totals.cacheWrite,
+		cost: totals.cost,
+		subscriptionMode: "unknown",
+		streaming: false,
+	};
+}
+
+function addUsage(
+	totals: UsageTotals,
+	usage: { input: number; output: number; cacheRead: number; cacheWrite: number; cost: { total: number } },
+): void {
+	totals.input += usage.input;
+	totals.output += usage.output;
+	totals.cacheRead += usage.cacheRead;
+	totals.cacheWrite += usage.cacheWrite;
+	totals.cost += usage.cost.total;
+}

package/extension-src/pi-style/pi/startup-resources.ts

@@ -0,0 +1,70 @@
+import type { SourceInfo, ToolInfo } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Startup resource collection for the pi/ adapter layer. Runs once at session
+ * start, outside any render path, and produces the bounded tool details that
+ * the startup surface renders.
+ */
+
+const CORE_TOOL_SOURCE_LABEL = "core";
+
+function stripKnownExtension(name: string): string {
+	return name.replace(/\.(?:mjs|cjs|js|jsx|ts|tsx)$/i, "");
+}
+
+function compactSourcePathLabel(path: string): string {
+	const trimmed = path.trim();
+	if (!trimmed) return "";
+	const synthetic = /^<([^:>]+)(?::[^>]*)?>$/.exec(trimmed);
+	if (synthetic?.[1]) return synthetic[1];
+	const segments = trimmed
+		.replace(/\\/g, "/")
+		.split("/")
+		.filter((segment) => segment.length > 0 && segment !== "." && segment !== "~");
+	const last = segments.at(-1) ?? trimmed;
+	if (/^index\.(?:mjs|cjs|js|jsx|ts|tsx)$/i.test(last) && segments.length > 1) {
+		return segments[segments.length - 2] ?? last;
+	}
+	return stripKnownExtension(last);
+}
+
+function compactPackageSourceLabel(source: string): string {
+	if (source.startsWith("npm:")) return source.slice("npm:".length) || source;
+	if (source.startsWith("git:")) return compactSourcePathLabel(source.replace(/\.git(?:#.*)?$/i, "")) || source;
+	return source;
+}
+
+/** Compact display label for a tool's source. */
+export function toolSourceLabel(sourceInfo: SourceInfo | undefined): string {
+	if (!sourceInfo || typeof sourceInfo !== "object") return CORE_TOOL_SOURCE_LABEL;
+	const source = typeof sourceInfo.source === "string" ? sourceInfo.source : "";
+	if (source === "builtin") return CORE_TOOL_SOURCE_LABEL;
+	if (source === "sdk") return "sdk";
+	if (source.startsWith("npm:") || source.startsWith("git:")) return compactPackageSourceLabel(source);
+	const baseDir = typeof sourceInfo.baseDir === "string" ? sourceInfo.baseDir : "";
+	if (baseDir) return compactSourcePathLabel(baseDir) || source || "extension";
+	const path = typeof sourceInfo.path === "string" ? sourceInfo.path : "";
+	if (path) return compactSourcePathLabel(path) || source || "extension";
+	return source || "extension";
+}
+
+/**
+ * Map registered tools to the bounded `{ source, name }` shape used by the
+ * startup tools panel. When Pi reports active tool names, only those are kept;
+ * an empty/absent active list keeps all registered tools so the panel is not
+ * silently empty. Returns undefined when there is nothing to show.
+ */
+export function collectToolDetails(
+	activeNames: readonly string[] | undefined,
+	tools: readonly ToolInfo[] | undefined,
+): { source: string; name: string }[] | undefined {
+	if (!tools || tools.length === 0) return undefined;
+	const activeSet = activeNames && activeNames.length > 0 ? new Set(activeNames) : undefined;
+	const details: { source: string; name: string }[] = [];
+	for (const tool of tools) {
+		if (typeof tool?.name !== "string" || tool.name.trim().length === 0) continue;
+		if (activeSet && !activeSet.has(tool.name)) continue;
+		details.push({ source: toolSourceLabel(tool.sourceInfo), name: tool.name.trim() });
+	}
+	return details.length > 0 ? details : undefined;
+}