pi-context-map 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## [0.7.0] - 2026-06-15
+### Bug Fixes
+- **Fixed token accuracy**: Now uses Pi's actual token count from `ctx.getContextUsage()` instead of heuristic estimation. The usage percentage now matches Pi's terminal display.
+- **Fixed compaction summary detection**: Now detects `role: "compactionSummary"` (Pi's actual format) with the `summary` field. Summaries no longer show 0%.
+- **Fixed file status calculation**: Changed from turn-based to position-based. Files in the last 30% of messages are "active", middle 40% are "stale", first 30% are "legacy".
+- **Removed error spam**: Silent error handling instead of console.error for non-critical failures.
+
+### Features
+- **Auto-open browser**: Report automatically opens in default browser on first `/context-map` invocation.
+- **Pi actual tokens in HTML**: Generator accepts and displays Pi's real token count.
+
+## [0.6.2] - 2026-06-15
+### Bug Fixes
+- **Fixed Pi message format**: Now uses `type: "toolCall"` (not `"tool_use"`) and `toolCallId` (not `tool_call_id`) to match Pi's actual `@mariozechner/pi-ai` types.
+- **System prompt detection**: Now accepts `systemPrompt` parameter from Pi's `ctx.getSystemPrompt()`. System slice no longer shows 0%.
+- **Tool results detection**: Changed to `role === "toolResult"` to match Pi's actual message format.
+- **File tracking from tool results**: Now extracts file paths from `toolResult` messages (read/write/edit tool results).
+
+### Features
+- **Message persistence**: Messages are saved via `appendEntry` on compaction to survive session reloads.
+- **Enhanced diagnostics**: `/context-map` command now shows message count, system tokens, and tool tokens in the notification.
+
 ## [0.6.1] - 2026-06-15
 ### Bug Fixes
 - **Fixed libuv assertion on Windows**: Removed `process.on('exit')` handler and `process.exit(0)` calls that left server handles open. Server now closes synchronously via `closeAllConnections()`.

package/extensions/analyzer.ts

@@ -2,6 +2,17 @@
  * ContextAnalyzer
  * Parses Pi session messages to identify the active working set of files,
  * their token weights, and their temporal status.
+ *
+ * Pi message format (from @mariozechner/pi-ai + pi-coding-agent):
+ *   UserMessage:             { role: "user", content: string | (TextContent | ImageContent)[] }
+ *   AssistantMessage:        { role: "assistant", content: (TextContent | ThinkingContent | ToolCall)[] }
+ *   ToolResultMessage:       { role: "toolResult", toolCallId, toolName, content }
+ *   CompactionSummaryMessage:{ role: "compactionSummary", summary: string, tokensBefore: number }
+ *   BranchSummaryMessage:    { role: "branchSummary", summary: string }
+ *   BashExecutionMessage:    { role: "bashExecution", command, output }
+ *   CustomMessage:           { role: "custom", customType, content }
+ *
+ * ToolCall:           { type: "toolCall", id, name, arguments }
  */
 import { TokenCounter } from "./token-counter";
 
@@ -31,12 +42,16 @@ export interface ContextComposition {
 	summaries: ContextSlice;
 	total: ContextSlice;
 	files_detail: FileContext[];
+	/** Pi's actual token count from ctx.getContextUsage() — may differ from heuristic total */
+	actualTokens?: number | null;
+	actualPercent?: number | null;
 }
 
 export class ContextAnalyzer {
 	public analyzeByType(
 		messages: any[],
 		currentTurn: number,
+		systemPrompt?: string,
 	): ContextComposition {
 		const fileRegistry = new Map<string, FileContext>();
 
@@ -46,42 +61,112 @@ export class ContextAnalyzer {
 		let fileTokens = 0;
 		let summaryTokens = 0;
 
+		// Count system prompt tokens if provided
+		if (systemPrompt && systemPrompt.length > 0) {
+			systemTokens += TokenCounter.count(systemPrompt);
+		}
+
+		// Track message indices for status calculation
+		const totalMessages = messages.length;
+
 		for (let index = 0; index < messages.length; index++) {
 			const msg = messages[index];
 			const turn = index + 1;
+
+			// Normalize role — Pi may use different role strings
 			const role = msg.role || "";
-			const msgType = msg.type || "";
 
-			// 1. Compaction summaries
+			// 1. Compaction summaries (Pi uses role="compactionSummary" with summary field)
 			if (
+				role === "compactionSummary" ||
 				role === "compaction" ||
-				msgType === "compaction" ||
+				msg.type === "compaction" ||
 				msg.customType === "compaction" ||
 				msg.compactionEntry
 			) {
-				summaryTokens += TokenCounter.countMessage(msg);
+				// Use the summary field if available, otherwise fall back to content
+				const summaryText =
+					typeof msg.summary === "string"
+						? msg.summary
+						: typeof msg.content === "string"
+							? msg.content
+							: JSON.stringify(msg.content || msg);
+				summaryTokens += TokenCounter.count(summaryText);
+				continue;
+			}
+
+			// 2. Branch summaries
+			if (role === "branchSummary") {
+				const summaryText =
+					typeof msg.summary === "string" ? msg.summary : JSON.stringify(msg);
+				summaryTokens += TokenCounter.count(summaryText);
+				continue;
+			}
+
+			// 3. Bash executions
+			if (role === "bashExecution") {
+				toolTokens += TokenCounter.countMessage(msg);
 				continue;
 			}
 
-			// 2. System messages
-			if (role === "system" || msgType === "system") {
-				systemTokens += TokenCounter.countMessage(msg);
+			// 4. Custom messages (extensions)
+			if (role === "custom") {
+				// Categorize based on customType
+				const customType = msg.customType || "";
+				if (
+					customType.includes("compaction") ||
+					customType.includes("summary")
+				) {
+					summaryTokens += TokenCounter.countMessage(msg);
+				} else {
+					historyTokens += TokenCounter.countMessage(msg);
+				}
 				continue;
 			}
 
-			// 3. Tool results (Pi uses "toolResult")
-			if (role === "toolResult" || role === "tool") {
+			// 5. Tool results (Pi uses role="toolResult")
+			if (role === "toolResult") {
 				toolTokens += TokenCounter.countMessage(msg);
+				// Track file content from tool results
+				const toolName = msg.toolName || "";
+				if (
+					toolName === "read" ||
+					toolName === "write" ||
+					toolName === "edit"
+				) {
+					const content = msg.content;
+					const path = this.extractPathFromToolResult(content);
+					if (path) {
+						const w = TokenCounter.countMessage(msg);
+						fileTokens += w;
+						if (!fileRegistry.has(path)) {
+							fileRegistry.set(path, {
+								path,
+								weight: w,
+								lastOp: {
+									type: this.getOpType(toolName),
+									turn,
+									timestamp: msg.timestamp || Date.now(),
+								},
+								status: this.calculateStatus(
+									index,
+									totalMessages,
+								),
+							});
+						}
+					}
+				}
 				continue;
 			}
 
-			// 4. User messages — track file attachments
+			// 6. User messages
 			if (role === "user") {
 				historyTokens += TokenCounter.countMessage(msg);
+				// Track file attachments (images, file paths in text)
 				if (Array.isArray(msg.content)) {
 					for (const block of msg.content) {
-						if (block.type === "image" || block.type === "image_url") {
-							const p = block.source?.url || block.image_url?.url || "[image]";
+						if (block.type === "image") {
+							const p = "[image]";
 							const w = TokenCounter.count(JSON.stringify(block));
 							fileTokens += w;
 							if (!fileRegistry.has(p)) {
@@ -93,7 +178,10 @@ export class ContextAnalyzer {
 										turn,
 										timestamp: msg.timestamp || Date.now(),
 									},
-									status: this.calculateStatus(turn, currentTurn),
+									status: this.calculateStatus(
+										index,
+										totalMessages,
+									),
 								});
 							}
 						}
@@ -112,7 +200,10 @@ export class ContextAnalyzer {
 												turn,
 												timestamp: msg.timestamp || Date.now(),
 											},
-											status: this.calculateStatus(turn, currentTurn),
+											status: this.calculateStatus(
+												index,
+												totalMessages,
+											),
 										});
 									}
 								}
@@ -123,19 +214,25 @@ export class ContextAnalyzer {
 				continue;
 			}
 
-			// 5. Assistant messages — track tool_use blocks
+			// 7. Assistant messages — track toolCall blocks
 			if (role === "assistant") {
 				historyTokens += TokenCounter.countMessage(msg);
 				if (Array.isArray(msg.content)) {
 					for (const block of msg.content) {
-						if (block.type === "tool_use") {
-							const input = block.input as Record<string, any>;
-							const p = this.extractPath(block.name, input);
+						// Pi uses type="toolCall" with id, name, arguments
+						if (block.type === "toolCall") {
+							const p = this.extractPath(block.name, block.arguments);
 							if (p) {
 								const opType = this.getOpType(block.name);
-								const result = this.findToolResult(messages, index, block.id);
+								const result = this.findToolResult(
+									messages,
+									index,
+									block.id,
+								);
 								const content = result?.content || "";
-								const w = TokenCounter.count(String(content));
+								const w = TokenCounter.count(
+									String(JSON.stringify(content)),
+								);
 								fileTokens += w;
 								fileRegistry.set(p, {
 									path: p,
@@ -145,7 +242,10 @@ export class ContextAnalyzer {
 										turn,
 										timestamp: msg.timestamp || Date.now(),
 									},
-									status: this.calculateStatus(turn, currentTurn),
+									status: this.calculateStatus(
+										index,
+										totalMessages,
+									),
 								});
 							}
 						}
@@ -154,7 +254,7 @@ export class ContextAnalyzer {
 				continue;
 			}
 
-			// 6. Everything else
+			// 8. Everything else
 			historyTokens += TokenCounter.countMessage(msg);
 		}
 
@@ -163,7 +263,8 @@ export class ContextAnalyzer {
 
 		const mk = (tokens: number): ContextSlice => ({
 			tokens: Math.ceil(tokens),
-			percent: totalTokens > 0 ? Math.round((tokens / totalTokens) * 100) : 0,
+			percent:
+				totalTokens > 0 ? Math.round((tokens / totalTokens) * 100) : 0,
 		});
 
 		const files_detail = Array.from(fileRegistry.values())
@@ -186,12 +287,13 @@ export class ContextAnalyzer {
 		return this.analyzeByType(messages, currentTurn);
 	}
 
-	private extractPath(toolName: string, input: any): string | null {
+	private extractPath(toolName: string, args: any): string | null {
+		if (!args || typeof args !== "object") return null;
 		if (toolName === "read" || toolName === "write" || toolName === "edit") {
-			return typeof input.path === "string" ? input.path : null;
+			return typeof args.path === "string" ? args.path : null;
 		}
 		if (toolName === "bash") {
-			const match = input.command?.match(
+			const match = args.command?.match(
 				/(?:cat|ls|rm|mv|cp|vi|nano)\s+([^\s;]+)/,
 			);
 			return match ? match[1] : null;
@@ -199,6 +301,21 @@ export class ContextAnalyzer {
 		return null;
 	}
 
+	private extractPathFromToolResult(content: any): string | null {
+		if (typeof content === "string") return null;
+		if (Array.isArray(content)) {
+			for (const block of content) {
+				if (block.type === "text" && typeof block.text === "string") {
+					const match = block.text.match(
+						/(?:\/|[A-Z]:\\)[\w./\\-]+\.\w+/,
+					);
+					if (match) return match[0];
+				}
+			}
+		}
+		return null;
+	}
+
 	private getOpType(toolName: string): FileOp["type"] {
 		switch (toolName) {
 			case "write":
@@ -212,13 +329,20 @@ export class ContextAnalyzer {
 		}
 	}
 
+	/**
+	 * Calculate file status based on position in message array.
+	 * Files near the end are "active", middle are "stale", beginning are "legacy".
+	 * This is more reliable than turn-based calculation since the context event
+	 * replaces all messages at once.
+	 */
 	private calculateStatus(
-		turn: number,
-		currentTurn: number,
+		messageIndex: number,
+		totalMessages: number,
 	): FileContext["status"] {
-		const diff = currentTurn - turn;
-		if (diff <= 3) return "active";
-		if (diff <= 10) return "stale";
+		if (totalMessages === 0) return "legacy";
+		const ratio = messageIndex / totalMessages;
+		if (ratio >= 0.7) return "active";
+		if (ratio >= 0.3) return "stale";
 		return "legacy";
 	}
 
@@ -228,13 +352,12 @@ export class ContextAnalyzer {
 		toolId: string,
 	): any {
 		for (let i = toolTurnIndex + 1; i < messages.length; i++) {
-			if (
-				messages[i].role === "toolResult" &&
-				messages[i].tool_call_id === toolId
-			) {
-				return messages[i];
+			const m = messages[i];
+			// Pi uses role="toolResult" and toolCallId (not tool_call_id)
+			if (m.role === "toolResult" && m.toolCallId === toolId) {
+				return m;
 			}
-			if (messages[i].role === "assistant") break;
+			if (m.role === "assistant") break;
 		}
 		return null;
 	}

package/extensions/generator.ts

@@ -15,8 +15,12 @@ export class ReportGenerator {
 		composition: ContextComposition,
 		insights: Insight[],
 		contextWindow: number = 128_000,
+		actualTokens?: number | null,
 	): string {
-		const total = composition.total.tokens;
+		// Use Pi's actual token count when available
+		const total = actualTokens != null && actualTokens > 0
+			? actualTokens
+			: composition.total.tokens;
 		const usagePercent =
 			total > 0 ? Math.round((total / contextWindow) * 100) : 0;
 

package/extensions/index.ts

@@ -1,7 +1,8 @@
 /**
  * pi-context-map
  * Professional Context Profiler for Pi.
- * v0.5.1 — Dynamic context window, dark mode, session-unique reports.
+ * v0.7.0 — Fixed token accuracy (uses Pi's actual count), compactionSummary detection,
+ *          auto-open browser, position-based file status, error cleanup.
  */
 
 import type {
@@ -16,6 +17,7 @@ import { LiveReportServer } from "./live-server";
 import * as path from "node:path";
 import * as fs from "node:fs";
 import * as os from "node:os";
+import { exec } from "node:child_process";
 
 function makeReportPath(sessionName?: string): string {
 	const dir = path.join(os.homedir(), ".pi", "context-map");
@@ -25,11 +27,24 @@ function makeReportPath(sessionName?: string): string {
 	const now = new Date();
 	const date = now.toISOString().split("T")[0];
 	const time = now.toTimeString().split(" ")[0].replace(/:/g, "-");
-	const safe = (sessionName || "session").replace(/[^\w.-]/g, "_").slice(0, 40);
+	const safe = (sessionName || "session")
+		.replace(/[^\w.-]/g, "_")
+		.slice(0, 40);
 	const filename = `${date}_${time}_${safe}.html`;
 	return path.join(dir, filename);
 }
 
+function openBrowser(url: string): void {
+	const platform = process.platform;
+	if (platform === "win32") {
+		exec(`start "" "${url}"`);
+	} else if (platform === "darwin") {
+		exec(`open "${url}"`);
+	} else {
+		exec(`xdg-open "${url}"`);
+	}
+}
+
 export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 	const analyzer = new ContextAnalyzer();
 	const liveServer = new LiveReportServer();
@@ -37,21 +52,43 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 	let sessionMessages: AgentMessage[] = [];
 	let currentTurn = 0;
 	let contextWindow = 128_000;
+	let actualTokens: number | null = null;
+	let actualPercent: number | null = null;
+	let systemPrompt = "";
 	let currentReportPath = makeReportPath();
+	let isFirstRun = true;
 
-	// Capture messages and context window from Pi system
+	// Capture messages, context window, system prompt, and actual token count from Pi
 	pi.on("context", (event: any, ctx: any) => {
 		if (event?.messages && Array.isArray(event.messages)) {
 			sessionMessages = event.messages;
 		}
 		try {
 			const usage = ctx?.getContextUsage?.();
-			if (usage?.contextWindow && usage.contextWindow > 0) {
-				contextWindow = usage.contextWindow;
+			if (usage) {
+				if (usage.contextWindow && usage.contextWindow > 0) {
+					contextWindow = usage.contextWindow;
+				}
+				// Use Pi's actual token count — this is the real value
+				if (usage.tokens != null && usage.tokens > 0) {
+					actualTokens = usage.tokens;
+				}
+				if (usage.percent != null && usage.percent > 0) {
+					actualPercent = usage.percent;
+				}
 			}
 		} catch {
 			// Keep fallback
 		}
+		// Get system prompt from Pi
+		try {
+			const sp = ctx?.getSystemPrompt?.();
+			if (sp && typeof sp === "string") {
+				systemPrompt = sp;
+			}
+		} catch {
+			// Keep empty
+		}
 	});
 
 	pi.on("turn_start", () => {
@@ -61,6 +98,22 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 	// Update report path when session changes
 	pi.on("session_start", () => {
 		currentReportPath = makeReportPath();
+		isFirstRun = true;
+	});
+
+	// Persist messages on compaction so they survive reload
+	pi.on("session_compact", (event: any) => {
+		if (event?.compactionEntry) {
+			try {
+				pi.appendEntry("context-map-snapshot", {
+					messages: sessionMessages.slice(-50),
+					turn: currentTurn,
+					timestamp: Date.now(),
+				});
+			} catch {
+				// Ignore persistence errors
+			}
+		}
 	});
 
 	async function runAnalysis(): Promise<{
@@ -69,12 +122,45 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 		reportPath: string;
 	}> {
 		const messages = sessionMessages.length > 0 ? sessionMessages : [];
-		const composition = analyzer.analyzeByType(messages, currentTurn);
+		const composition = analyzer.analyzeByType(
+			messages,
+			currentTurn,
+			systemPrompt,
+		);
+
+		// Override with Pi's actual token count when available
+		if (actualTokens != null && actualTokens > 0) {
+			composition.actualTokens = actualTokens;
+			composition.actualPercent = actualPercent;
+			// Recalculate percentages relative to actual total
+			const total = actualTokens;
+			if (total > 0) {
+				composition.system.percent = Math.round(
+					(composition.system.tokens / total) * 100,
+				);
+				composition.tools.percent = Math.round(
+					(composition.tools.tokens / total) * 100,
+				);
+				composition.history.percent = Math.round(
+					(composition.history.tokens / total) * 100,
+				);
+				composition.files.percent = Math.round(
+					(composition.files.tokens / total) * 100,
+				);
+				composition.summaries.percent = Math.round(
+					(composition.summaries.tokens / total) * 100,
+				);
+				// Use Pi's actual total for the usage calculation
+				composition.total.tokens = total;
+			}
+		}
+
 		const insights = InsightEngine.generate(composition);
 		const html = ReportGenerator.generateHTML(
 			composition,
 			insights,
 			contextWindow,
+			actualTokens,
 		);
 
 		try {
@@ -84,7 +170,7 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 			}
 			fs.writeFileSync(currentReportPath, html, "utf8");
 		} catch (err: any) {
-			console.error(`[pi-context-map] Failed to write report: ${err.message}`);
+			// Silent — don't spam console
 		}
 
 		if (liveServer.isRunning) {
@@ -108,7 +194,7 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 
 			ctx.ui.notify("Analyzing session context...", "info");
 			try {
-				const { insights, reportPath } = await runAnalysis();
+				const { composition, insights, reportPath } = await runAnalysis();
 				const criticalCount = insights.filter(
 					(i) => i.severity === "critical",
 				).length;
@@ -116,14 +202,27 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 					criticalCount > 0
 						? `Context map generated. ${criticalCount} critical insight(s) found.`
 						: "Context map generated successfully.";
-				let details = `File: ${reportPath}`;
+
+				// Use Pi's actual percentage when available
+				const usageDisplay =
+					actualPercent != null
+						? `${actualPercent.toFixed(1)}%`
+						: `${composition.total.percent}%`;
+
+				let details = `Usage: ${usageDisplay} of ${(contextWindow / 1000).toFixed(0)}k`;
 				if (serverUrl) {
-					details += ` | Live: ${serverUrl}`;
+					details += ` | ${serverUrl}`;
 				}
 				ctx.ui.notify(
 					`${summary} ${details}`,
 					criticalCount > 0 ? "warning" : "success",
 				);
+
+				// Auto-open browser on first run
+				if (isFirstRun && serverUrl) {
+					openBrowser(serverUrl);
+					isFirstRun = false;
+				}
 			} catch (error: any) {
 				ctx.ui.notify(
 					`Failed to generate context map: ${error.message}`,
@@ -137,7 +236,7 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 		name: "context-map",
 		label: "Context Map",
 		description:
-			"Analyze the current session context composition and return actionable insights. The live localhost report will auto-update.",
+			"Analyze the current session context composition and return actionable insights.",
 		parameters: {
 			type: "object",
 			properties: {},
@@ -151,23 +250,28 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 			try {
 				const { composition, insights, reportPath } = await runAnalysis();
 				const usagePercent =
-					composition.total.tokens > 0
-						? Math.round((composition.total.tokens / contextWindow) * 100)
-						: 0;
+					actualPercent != null
+						? actualPercent
+						: composition.total.tokens > 0
+							? Math.round(
+									(composition.total.tokens / contextWindow) * 100,
+								)
+							: 0;
 				const summary =
-					`Context: ${composition.total.tokens.toLocaleString()} tokens total. ` +
+					`Context: ${composition.total.tokens.toLocaleString()} tokens (${usagePercent.toFixed(1)}% of ${(contextWindow / 1000).toFixed(0)}k). ` +
 					`System ${composition.system.percent}%, Tools ${composition.tools.percent}%, ` +
 					`History ${composition.history.percent}%, Files ${composition.files.percent}%, ` +
 					`Summaries ${composition.summaries.percent}%. ` +
-					`Usage: ${usagePercent}% of ${(contextWindow / 1000).toFixed(0)}k window. ` +
-					`${insights.length} insight(s) generated.`;
+					`Messages: ${sessionMessages.length}. ` +
+					`${insights.length} insight(s).`;
 				return {
 					type: "text" as const,
 					content: [
 						summary,
 						"",
 						...insights.map(
-							(i) => `[${i.severity.toUpperCase()}] ${i.title}: ${i.message}`,
+							(i) =>
+								`[${i.severity.toUpperCase()}] ${i.title}: ${i.message}`,
 						),
 						`Report: ${reportPath}`,
 						serverUrl ? `Live: ${serverUrl}` : "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-context-map",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Professional context profiler for Pi that visualizes the session context window, token distribution, and integrates with Nexus packages for actionable insights.",
   "keywords": [
     "pi-package",