pi-context-map 0.6.2 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## [0.7.1] - 2026-06-15
+### Bug Fixes
+- **Fixed insights dropdown**: Changed from direct `addEventListener` to event delegation (`document.addEventListener('click', ...)` with `e.target.closest('.insight-header')`). The dropdown now works after SSE body replacement.
+- **Fixed auto-open browser**: Added `cmd /c start` with `explorer` fallback for Windows. Browser now opens reliably on first `/context-map` invocation.
+- **Removed unused variable**: Cleaned up `reportPath` destructuring warning in command handler.
+
+## [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.

package/README.md

@@ -8,11 +8,15 @@ A visual context window mapping extension for [Pi](https://pi.dev/) that transfo
 
 ## Features
 
-- **Visual Context Budget**: Real-time breakdown of tokens used by System, History, Files, and Tool Results.
-- **Working Set Analysis**: Categorizes files as `Active`, `Stale`, or `Legacy` based on access recency.
+- **Visual Context Budget**: Real-time breakdown of tokens used by System, Tools, History, Files, and Summaries.
+- **Accurate Token Count**: Uses Pi's actual token count from `ctx.getContextUsage()`, not heuristic estimation — matches the terminal display.
+- **Working Set Analysis**: Categorizes files as `Active`, `Stale`, or `Legacy` based on position in the conversation.
 - **Token Weighting**: Identifies "token hogs" by calculating the approximate size of each file in the window.
-- **Operation Tracking**: Marks files with their last operation (Read 👁️, Write 📝, Edit ✍️).
-- **Temporal Mapping**: Visually maps when files entered the context to identify compaction candidates.
+- **Operation Tracking**: Marks files with their last operation (Read, Write, Edit).
+- **Compaction Detection**: Tracks compaction summaries and branch summaries as a separate slice.
+- **Auto-Open Browser**: Report automatically opens in your default browser on first invocation.
+- **Dark Mode**: Toggle between light and dark themes. Preference persists across sessions via localStorage.
+- **Live Server**: SSE-powered localhost server with auto-refresh after each assistant message.
 
 ## Installation
 
@@ -33,20 +37,21 @@ The extension will analyze the session and create an interactive HTML report at:
 
 ## Context Statuses
 
-The extension categorizes files to help you manage context bloat:
+Files are categorized by their position in the conversation (more reliable than turn-based calculation):
 
-| Status | Criteria | Action |
-|--------|----------|--------|
-| **Active** | Accessed in last 3 turns | Keep in context |
-| **Stale** | Accessed 4-10 turns ago | Monitor for removal |
-| **Legacy** | Accessed > 10 turns ago | Prime candidate for compaction |
+| Status | Position in Messages | Action |
+|--------|---------------------|--------|
+| **Active** | Last 30% of messages | Keep in context |
+| **Stale** | Middle 40% of messages | Monitor for removal |
+| **Legacy** | First 30% of messages | Prime candidate for compaction |
 
 ## How It Works
 
-1. **Scanning**: The analyzer iterates through the session history, identifying all `tool_use` calls involving file operations.
-2. **Weighting**: It extracts the content length of tool results and applies a token heuristic (approx. 4 chars/token).
-3. **Categorization**: It calculates the temporal distance between the current turn and the last file access.
-4. **Visualization**: It generates a standalone HTML dashboard featuring a stacked composition bar, a file-weight grid with search/filter, and an interactive insights section.
+1. **Scanning**: The analyzer iterates through session messages, detecting `toolCall` blocks, `toolResult` messages, `compactionSummary` entries, and image attachments.
+2. **Weighting**: It calculates token counts for each message type using a code-aware heuristic (multipliers for code blocks, strings, etc.).
+3. **Accuracy**: When available, Pi's actual token count from `ctx.getContextUsage()` overrides the heuristic for the usage percentage.
+4. **Categorization**: Files are classified by their position in the message array (last 30% = active, middle 40% = stale, first 30% = legacy).
+5. **Visualization**: Generates a self-contained HTML dashboard with stacked composition bar, file cards with search/filter, dark mode toggle, and interactive insights.
 
 ## Live Localhost Server
 

package/extensions/analyzer.ts

@@ -3,13 +3,16 @@
  * 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):
- *   UserMessage:       { role: "user", content: string | (TextContent | ImageContent)[] }
- *   AssistantMessage:  { role: "assistant", content: (TextContent | ThinkingContent | ToolCall)[] }
- *   ToolResultMessage: { role: "toolResult", toolCallId, toolName, content: (TextContent | ImageContent)[] }
+ * 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 }
- * ToolCall.id maps to ToolResultMessage.toolCallId
  */
 import { TokenCounter } from "./token-counter";
 
@@ -39,6 +42,9 @@ 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 {
@@ -60,23 +66,65 @@ export class ContextAnalyzer {
 			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 || "";
 
-			// 1. Compaction summaries (Pi compaction entries)
+			// 1. Compaction summaries (Pi uses role="compactionSummary" with summary field)
 			if (
+				role === "compactionSummary" ||
 				role === "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;
+			}
+
+			// 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;
 			}
 
-			// 2. Tool results (Pi uses role="toolResult")
+			// 5. Tool results (Pi uses role="toolResult")
 			if (role === "toolResult") {
 				toolTokens += TokenCounter.countMessage(msg);
 				// Track file content from tool results
@@ -100,7 +148,7 @@ export class ContextAnalyzer {
 									turn,
 									timestamp: msg.timestamp || Date.now(),
 								},
-								status: this.calculateStatus(turn, currentTurn),
+								status: this.calculateStatus(index, totalMessages),
 							});
 						}
 					}
@@ -108,7 +156,7 @@ export class ContextAnalyzer {
 				continue;
 			}
 
-			// 3. User messages
+			// 6. User messages
 			if (role === "user") {
 				historyTokens += TokenCounter.countMessage(msg);
 				// Track file attachments (images, file paths in text)
@@ -127,7 +175,7 @@ export class ContextAnalyzer {
 										turn,
 										timestamp: msg.timestamp || Date.now(),
 									},
-									status: this.calculateStatus(turn, currentTurn),
+									status: this.calculateStatus(index, totalMessages),
 								});
 							}
 						}
@@ -146,7 +194,7 @@ export class ContextAnalyzer {
 												turn,
 												timestamp: msg.timestamp || Date.now(),
 											},
-											status: this.calculateStatus(turn, currentTurn),
+											status: this.calculateStatus(index, totalMessages),
 										});
 									}
 								}
@@ -157,7 +205,7 @@ export class ContextAnalyzer {
 				continue;
 			}
 
-			// 4. Assistant messages — track toolCall blocks
+			// 7. Assistant messages — track toolCall blocks
 			if (role === "assistant") {
 				historyTokens += TokenCounter.countMessage(msg);
 				if (Array.isArray(msg.content)) {
@@ -179,7 +227,7 @@ export class ContextAnalyzer {
 										turn,
 										timestamp: msg.timestamp || Date.now(),
 									},
-									status: this.calculateStatus(turn, currentTurn),
+									status: this.calculateStatus(index, totalMessages),
 								});
 							}
 						}
@@ -188,7 +236,7 @@ export class ContextAnalyzer {
 				continue;
 			}
 
-			// 5. Everything else
+			// 8. Everything else
 			historyTokens += TokenCounter.countMessage(msg);
 		}
 
@@ -260,13 +308,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";
 	}
 

package/extensions/generator.ts

@@ -15,8 +15,13 @@ 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;
 
@@ -643,15 +648,15 @@ h2:first-of-type { margin-top: 48px; }
 		applyTheme(cur === 'dark' ? 'light' : 'dark');
 	});
 
-	// Insight toggles
-	var btns = document.querySelectorAll('.insight-header');
-	for (var j = 0; j < btns.length; j++) {
-		btns[j].addEventListener('click', function() {
-			var card = this.closest('.insight-card');
-			var was = card.classList.toggle('collapsed');
-			this.setAttribute('aria-expanded', was ? 'false' : 'true');
-		});
-	}
+	// Insight toggles (event delegation — survives SSE body replacement)
+	document.addEventListener('click', function(e) {
+		var btn = e.target.closest('.insight-header');
+		if (!btn) return;
+		var card = btn.closest('.insight-card');
+		if (!card) return;
+		var was = card.classList.toggle('collapsed');
+		btn.setAttribute('aria-expanded', was ? 'false' : 'true');
+	});
 
 	// Live SSE
 	try {

package/extensions/index.ts

@@ -1,7 +1,8 @@
 /**
  * pi-context-map
  * Professional Context Profiler for Pi.
- * v0.6.2 — Fixed Pi message format (toolCall), system prompt detection, message persistence.
+ * 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");
@@ -30,6 +32,27 @@ function makeReportPath(sessionName?: string): string {
 	return path.join(dir, filename);
 }
 
+function openBrowser(url: string): void {
+	const platform = process.platform;
+	try {
+		if (platform === "win32") {
+			// Use cmd /c start with separate title arg to handle URLs with special chars
+			exec(`cmd /c start "" "${url}"`, (err) => {
+				if (err) {
+					// Fallback: try explorer directly
+					exec(`explorer "${url}"`);
+				}
+			});
+		} else if (platform === "darwin") {
+			exec(`open "${url}"`);
+		} else {
+			exec(`xdg-open "${url}"`);
+		}
+	} catch {
+		// Silent — browser open is best-effort
+	}
+}
+
 export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 	const analyzer = new ContextAnalyzer();
 	const liveServer = new LiveReportServer();
@@ -37,18 +60,30 @@ 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, context window, and system prompt 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
@@ -71,6 +106,7 @@ 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
@@ -78,7 +114,7 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 		if (event?.compactionEntry) {
 			try {
 				pi.appendEntry("context-map-snapshot", {
-					messages: sessionMessages.slice(-50), // Keep last 50 messages
+					messages: sessionMessages.slice(-50),
 					turn: currentTurn,
 					timestamp: Date.now(),
 				});
@@ -99,11 +135,40 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 			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 {
@@ -113,7 +178,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) {
@@ -137,7 +202,7 @@ export default async function piContextMap(pi: ExtensionAPI): Promise<void> {
 
 			ctx.ui.notify("Analyzing session context...", "info");
 			try {
-				const { composition, insights, reportPath } = await runAnalysis();
+				const { composition, insights } = await runAnalysis();
 				const criticalCount = insights.filter(
 					(i) => i.severity === "critical",
 				).length;
@@ -145,17 +210,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}`;
 				}
-				details += ` | Messages: ${sessionMessages.length}`;
-				details += ` | System: ${composition.system.tokens}t (${composition.system.percent}%)`;
-				details += ` | Tools: ${composition.tools.tokens}t (${composition.tools.percent}%)`;
 				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}`,
@@ -183,15 +258,16 @@ 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. ` +
 					`Messages: ${sessionMessages.length}. ` +
 					`${insights.length} insight(s).`;
 				return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-context-map",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "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",