pi-context 1.0.0 → 1.0.1

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "pi-context",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "agent-driven context management tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "src",
+    "skills",
+    "README.md"
   ],
   "scripts": {},
   "keywords": [
@@ -31,11 +33,15 @@
   },
   "pi": {
     "extensions": [
-      "./dist/index.js"
+      "src/index.ts"
     ],
     "skills": [
-      "./skills/context-management/SKILL.md"
+      "skills/context-management/SKILL.md"
     ],
     "image": "https://github.com/ttttmr/pi-context/raw/refs/heads/main/img/context.png"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ttttmr/pi-context.git"
   }
-}
+}

package/skills/context-management/SKILL.md

@@ -0,0 +1,180 @@
+---
+name: context-management
+description: Strategies for efficient context management using context_log, context_tag, and context_checkout. Learn when to tag, how to visualize the graph, and safe ways to squash history. Use for complex refactoring, debugging, and long conversations.
+---
+
+# Context Management
+
+**CRITICAL: THIS SKILL MANAGES YOUR MEMORY (CONVERSATION HISTORY), NOT THE USER'S FILES.**
+
+Your context window is a limited resource. As the conversation grows, "pollution" (noise, failed attempts, intermediate logs) degrades your reasoning.
+
+**CRITICAL: YOU ARE RESPONSIBLE FOR YOUR CONTEXT STRUCTURE.**
+**DO NOT WAIT FOR THE USER TO TELL YOU TO MANAGE CONTEXT.**
+
+You must proactively use these tools to keep your reasoning sharp and your history structured.
+
+**Use this skill to optimize your "Context Economy":**
+1.  **Structure (Save Points)**: Use `context_tag` to bookmark stable states. **Untagged progress is risky.** Always tag before a major step.
+2.  **Monitor (Awareness)**: Use `context_log` to check your "Usage" and "Segment Size". **Don't fly blind.** High usage degrades your reasoning.
+3.  **Compress (Hygiene)**: Use `context_checkout` to squash history. **Finished tasks are noise.** Summarize them to reclaim memory.
+
+## The Context Dashboard
+
+Call `context_log` to see your status. It provides a **HUD** (Health Metrics) and a **Graph** (Map).
+
+### 1. The HUD (Health)
+```text
+• Context Usage:    85% (108k/128k)
+• Segment Size:     84 steps since last tag
+```
+
+### 2. The Graph (Map)
+The log tree shows where you are and where you've been.
+```text
+| 1a2b3c4 (ROOT, tag: start) [USER] Start the project.
+| ... (50 hidden messages) ...
+| f9e8d7c (tag: task-a-done) [SUMMARY] Task A completed.
+| ... (5 hidden messages) ...
+* a1b2c3d (HEAD, tag: task-b-start) [AI] I have switched to Task B.
+```
+- **`*` (Asterisk)**: Your current location (HEAD).
+- **`... (hidden)`**: Low-value steps (thinking/tools) are auto-collapsed.
+- **`tag: name`**: Safe checkpoints to jump back to.
+- **`[SUMMARY]`**: A compressed history node (squashed context).
+
+## Decision Framework: When to Act?
+
+### 1. Resource Perspective (The Dashboard)
+*Check the `context_log` HUD.*
+
+| Signal | Diagnosis | Prescription |
+| :--- | :--- | :--- |
+| **Usage > 50%** | **ATTENTION DECAY**: Recall fades, instruction adherence drops, and reasoning quality suffers. | **COMPRESS**: `context_checkout({ target: "task-start", message: "Consolidated progress...", tagName: "clean-up" })` |
+| **Segment > 10** | **LINEAR FATIGUE**: Hard to distinguish signal from noise in long threads. | **TAG**: `context_tag({ name: "safe-point" })` |
+| **Reading Huge Files / Web Search** | **LOW INFO DENSITY**: You read 500 lines but only need 5 lines. | **EXTRACT & REWIND**: `context_checkout({ target: "pre-read", message: "File content summary: [Key Configs...]", tagName: "extracted-info" })` |
+
+### 2. Task Perspective (The Workflow)
+*Reflect on your current progress.*
+
+| Signal | Diagnosis | Prescription |
+| :--- | :--- | :--- |
+| **"I tried 3 times and failed"** | **POISONED CONTEXT**: Previous failures bias future attempts and eat up token budget. | **BACKTRACK**: `context_checkout({ target: "last-working-tag", message: "Approach A failed..." })` |
+| **"I think I finished the task"** | **PENDING**: User might ask for tweaks. | **TAG ONLY**: `context_tag({ name: "feature-x-candidate" })`. **Do not squash yet.** |
+| **"User starts a NEW task"** | **SAFE TO CLOSE**: Old context is now clutter. | **SQUASH**: `context_checkout({ target: "root", message: "Prev task done. Summary...", tagName: "clean-slate" })` |
+
+## Workflow Best Practices
+
+### 1. Build the ToC (`context_tag`)
+Don't just work blindly. Tag your milestones so you (and the user) can see the structure.
+- *Good*: `start` -> `plan-v1` -> `impl-v1` -> `test-pass`
+- *Bad*: `start` -> (100 messages) -> `done`
+
+### 2. View the Map (`context_log`)
+Check where you are and how expensive the path is.
+- Use `verbose: false` (default) to see the high-level "ToC" (Milestones).
+
+### 3. Squash & Merge (`context_checkout`)
+**This is your Garbage Collector.** Use it to delete low-value history but keep high-value insights.
+
+> **CRITICAL REMINDER: CONTEXT IS NOT CODEBASE**
+> Checking out a new context branch **DOES NOT DELETE FILES**. It only resets your *conversation memory*. Your code on disk is safe.
+
+**Checkout Messages**
+
+The `message` is your lifeline to your past self.
+A good message preserves critical context that would otherwise be lost.
+
+Structure: `[Status] + [Reason] + [Important Changes] + [Carryover Data]`
+
+*   **Status**: What did you just finish or stop doing?
+*   **Reason**: Why are you branching/moving? (e.g., "Too much noise", "Task complete", "Failed attempt")
+*   **Important Changes**: What files or logic have been modified? (This checkout only resets *conversation history*, NOT disk files, so you must remember what changed.)
+*   **Carryover**: What specific details (IDs, file paths, user constraints) must be remembered?
+
+Examples:
+
+*   *Good (Resetting after failure)*: "Abandoning the recursive approach (infinite loop). Switching back to iterative. **Important Changes**: Modified `utils/recursion.ts`. **Carryover**: The test case `test_retry_logic` is the one failing."
+*   *Good (Cleaning up)*: "Completed authentication module. All tests passed. **Important Changes**: Created `auth/` directory and updated `routes.ts`. **Carryover**: The user ID is stored in `localStorage` under `auth_token`. Moving to Dashboard UI."
+*   *Bad*: "Switching context." (Too vague - you will forget why)
+*   *Bad*: "Done." (What is done? What did we learn?)
+
+**Safety Net (Undo Button):**
+`context_checkout` is non-destructive. If you squash too much, use `context_log` to find the old branch ID and checkout back to it.
+
+**Checkout Failures**
+If `context_checkout` fails with "Target not found":
+1.  Run `context_log` immediately to see available commit IDs and tags.
+2.  Select a valid ID from the log.
+3.  Retry the checkout.
+
+## Scenarios
+
+**Scenario: Task Complete & Confirmed**
+You finished Feature A. **Wait for user confirmation.**
+*User*: "Looks good. Now let's work on Feature B."
+*Reasoning*: Feature A details are now noise. Feature B needs a clean slate.
+
+```javascript
+// 1. Tag the raw history (just in case)
+context_tag({ name: "feature-a-raw" });
+
+// 2. Squash to Root (or previous milestone)
+context_checkout({
+  target: "root", // or "project-start"
+  message: "Feature A completed. All tests passed. Key files created: X, Y, Z.",
+  tagName: "feature-a-done"
+});
+```
+*Result*: You are now at a clean state with just the summary of Feature A. Cost dropped from 50 msgs to 1 msg.
+
+**Scenario: Pivot / Retry**
+You tried approach A and it failed 5 times (Pollution).
+*Solution*: Backtrack and summarize the failure.
+
+```javascript
+// Return to the state BEFORE the failed attempts
+context_checkout({
+  target: "task-start", 
+  message: "Approach A failed due to library incompatibility. Context clean. Starting Approach B.",
+  tagName: "retry-approach-b"
+});
+```
+
+**Scenario: Data Extraction / Research**
+You read a huge file (e.g., 2000 lines) or searched the web, but only found 3 relevant lines.
+*Problem*: The context is now polluted with 1997 lines of noise.
+*Solution*: Send the 3 lines back to your past self.
+
+```javascript
+// 1. Tag BEFORE you start reading/searching (proactive)
+context_tag({ name: "pre-research" });
+
+// ... (You read the huge file and find the key config) ...
+
+// 2. Checkout back to the tag, bringing ONLY the key info
+context_checkout({
+  target: "pre-research",
+  message: "Found the key configuration in line 150: 'MAX_CONNECTIONS=5'. The rest of the file was irrelevant.",
+  tagName: "research-complete"
+});
+```
+*Result*: Your context now contains the prompt, the tag, and the single message with the key config. The 2000 lines of noise are gone.
+
+**Scenario: Code Fix / "Time Travel" Debugging**
+You wrote code, it failed, you fixed it after 10 tries.
+*Problem*: Context has 10 failed attempts and error logs.
+*Solution*: Send the *final working code* back to the moment before you started coding.
+
+```javascript
+// 1. You realize you are in a messy debug loop.
+// 2. You finally get the code working.
+// 3. Checkout back to BEFORE you started the implementation.
+
+context_checkout({
+  target: "impl-start", 
+  message: "Implementation successful. Here is the working code: \n```javascript\n...\n```\nSkipped the debugging steps.",
+  tagName: "impl-done"
+});
+```
+*Result*: It looks like you got it right on the first try. Context is clean and focused.

package/src/index.ts

@@ -0,0 +1,480 @@
+import {
+  type ExtensionAPI,
+  type SessionEntry,
+  type SessionManager,
+  DynamicBorder,
+} from "@mariozechner/pi-coding-agent";
+import type {
+  ToolCall,
+  TextContent,
+  ImageContent,
+} from "@mariozechner/pi-ai";
+import { Type, type Static } from "@sinclair/typebox";
+import { Container, Text, Spacer } from "@mariozechner/pi-tui";
+
+// Define missing types locally as they are not exported from the main entry point
+interface SessionTreeNode {
+  entry: SessionEntry;
+  children: SessionTreeNode[];
+  label?: string;
+}
+
+const ContextLogParams = Type.Object({
+  limit: Type.Optional(Type.Number({ description: "History limit for visible entries (default: 50)." })),
+  verbose: Type.Optional(Type.Boolean({ description: "If true, show ALL messages. If false (default), collapses intermediate AI steps and only shows 'milestones': User messages, Tags, Branch Points, and Summaries." })),
+});
+
+const ContextCheckoutParams = Type.Object({
+  target: Type.String({ description: "Where to jump/squash to. Can be a tag name (e.g., 'task-start'), a commit ID, or 'root'. This is the base for your new branch." }),
+  message: Type.String({ description: "The 'Carryover Message' for the new branch. A summary of your *current* progress/lessons that you want to bring with you to the new state. This ensures you don't lose key information when switching contexts. Good summary message: '[Status] + [Reason] + [Important Changes] + [Carryover Data]'" }),
+  tagName: Type.Optional(Type.String({ description: "Optional tag name to apply to the target state immediately after checking out." })),
+});
+
+const ContextTagParams = Type.Object({
+  name: Type.String({ description: "The tag/milestone name. Use meaningful names." }),
+  target: Type.Optional(Type.String({ description: "The commit ID to tag. Defaults to HEAD (current state)." })),
+});
+
+const isInternal = (name: string) => ["context_log", "context_checkout", "context_tag"].includes(name);
+
+const resolveTargetId = (sm: SessionManager, target: string): string => {
+  if (target.toLowerCase() === "root") {
+    const tree = sm.getTree();
+    return tree.length > 0 ? tree[0].entry.id : target;
+  }
+  if (/^[0-9a-f]{8,}$/i.test(target)) return target;
+  const find = (nodes: SessionTreeNode[]): string | null => {
+    for (const n of nodes) {
+      if (sm.getLabel(n.entry.id) === target) return n.entry.id;
+      const r = find(n.children);
+      if (r) return r;
+    }
+    return null;
+  };
+  // sm.getTree() returns the SDK's SessionTreeNode[], which is structurally compatible
+  return find(sm.getTree()) || target;
+};
+
+const formatTokens = (n: number) => {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
+  if (n >= 1_000) return Math.round(n / 1_000) + "k";
+  return n.toString();
+};
+
+export default function (pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "context_log",
+    label: "Context Log",
+    description: "Show the entire history structure (status, message, tags, milestones). Analogous to 'git log --graph --oneline --decorate'",
+    parameters: ContextLogParams,
+    async execute(_id, params: Static<typeof ContextLogParams>, _signal, _onUpdate, ctx) {
+      const sm = ctx.sessionManager as SessionManager;
+      const tree = sm.getTree();
+      const currentLeafId = sm.getLeafId();
+      const verbose = params.verbose ?? false;
+      const limit = params.limit ?? 50;
+
+      const parents = new Map<string, string>();
+      const entryMap = new Map<string, SessionEntry>();
+      const childrenMap = new Map<string, SessionEntry[]>();
+
+      const walk = (nodes: SessionTreeNode[], pId?: string) => {
+        for (const n of nodes) {
+          entryMap.set(n.entry.id, n.entry);
+          if (pId) {
+            parents.set(n.entry.id, pId);
+            const siblings = childrenMap.get(pId) || [];
+            siblings.push(n.entry);
+            childrenMap.set(pId, siblings);
+          }
+          walk(n.children, n.entry.id);
+        }
+      };
+      walk(tree);
+
+      const getMsgContent = (entry: SessionEntry): string => {
+        if (entry.type === "branch_summary" || entry.type === "compaction") {
+          const e = entry;
+          return e.summary || "[No summary provided]";
+        }
+        if (entry.type === "label") {
+          return `tag: ${entry.label}`;
+        }
+
+        if (entry.type === "message") {
+          const msg = entry.message;
+
+          if (msg.role === "toolResult") {
+            const tr = msg;
+            if (!verbose && isInternal(tr.toolName)) return "";
+
+            const extractText = (content: (TextContent | ImageContent)[]): string => {
+              return content
+                .map((p) => (p.type === "text" ? p.text : ""))
+                .join(" ")
+                .trim();
+            };
+
+            let resText = extractText(tr.content);
+            const details = tr.details as Record<string, unknown> | undefined;
+            if ((tr.toolName === "read" || tr.toolName === "edit") && details && "path" in details && typeof details.path === "string") {
+              resText = `${details.path}: ${resText}`;
+            }
+            return `(${tr.toolName}) ${resText}`;
+          }
+
+          if (msg.role === "bashExecution") {
+            return `[Bash] ${msg.command}`;
+          }
+
+          if (msg.role === "user" || msg.role === "assistant") {
+            let text = "";
+            if (typeof msg.content === "string") {
+              text = msg.content;
+            } else if (Array.isArray(msg.content)) {
+              text = msg.content
+                .map((p: any) => {
+                  if (typeof p === "object" && p !== null && "text" in p) return (p as TextContent).text;
+                  return "";
+                })
+                .join(" ")
+                .trim();
+            }
+
+            let toolCallsText = "";
+            if (msg.role === "assistant") {
+              const toolCalls = msg.content.filter((c): c is ToolCall => c.type === "toolCall");
+
+              toolCallsText = toolCalls
+                .filter((tc) => verbose || !isInternal(tc.name))
+                .map((tc) => `call: ${tc.name}(${JSON.stringify(tc.arguments)})`)
+                .join("; ");
+            }
+
+            return [text, toolCallsText].filter(Boolean).join(" ");
+          }
+        }
+        return "";
+      };
+
+      const backboneIds: string[] = [];
+      let currId: string | undefined = currentLeafId ?? undefined;
+      while (currId) {
+        backboneIds.unshift(currId);
+        currId = parents.get(currId);
+      }
+
+      const sequence: SessionEntry[] = [];
+      backboneIds.forEach((id) => {
+        const entry = entryMap.get(id);
+        if (!entry) return;
+        sequence.push(entry);
+        const children = childrenMap.get(id) || [];
+        children.forEach((child) => {
+          if ((child.type === "branch_summary" || child.type === "compaction") && !backboneIds.includes(child.id)) {
+            sequence.push(child);
+          }
+        });
+      });
+
+      const isInteresting = (entry: SessionEntry): boolean => {
+        // 1. HEAD and Root
+        if (entry.id === currentLeafId) return true;
+        if (!parents.has(entry.id)) return true;
+
+        // 2. Explicit Tags (Labels) - Only show the TAGGED node, not the label node itself
+        if (sm.getLabel(entry.id)) return true;
+        if (entry.type === 'label') return false; // Hide label nodes, they are redundant
+
+        // 3. Structural Milestones (Summaries, Forks)
+        if (entry.type === 'branch_summary' || entry.type === 'compaction') return true;
+        if ((childrenMap.get(entry.id)?.length ?? 0) > 1) return true;
+
+        // 4. Natural Milestones (User Messages) - This is the key auto-tagging mechanism
+        if (entry.type === 'message' && entry.message.role === 'user') return true;
+
+        return false;
+      };
+
+      const visibleSequenceIds = new Set<string>();
+      sequence.forEach(e => {
+        if (verbose || isInteresting(e)) {
+          visibleSequenceIds.add(e.id);
+        }
+      });
+
+      let visibleEntries = sequence.filter(e => visibleSequenceIds.has(e.id));
+      if (visibleEntries.length > limit) {
+        const allowedIds = new Set(visibleEntries.slice(-limit).map(e => e.id));
+        visibleSequenceIds.clear();
+        allowedIds.forEach(id => visibleSequenceIds.add(id));
+      }
+
+      const lines: string[] = [];
+      let hiddenCount = 0;
+
+      sequence.forEach((entry) => {
+        if (!visibleSequenceIds.has(entry.id)) {
+          hiddenCount++;
+          return;
+        }
+
+        if (hiddenCount > 0) {
+          lines.push(`  :  ... (${hiddenCount} hidden messages) ...`);
+          hiddenCount = 0;
+        }
+
+        const isHead = entry.id === currentLeafId;
+        const label = sm.getLabel(entry.id);
+        const content = getMsgContent(entry).replace(/\s+/g, " ");
+
+        let role = entry.type.toUpperCase();
+        if (entry.type === "message") {
+          const m = entry.message;
+          role =
+            m.role === "assistant"
+              ? "AI"
+              : m.role === "user"
+                ? "USER"
+                : m.role === "bashExecution"
+                  ? "BASH"
+                  : "TOOL";
+        } else if (entry.type === "branch_summary" || entry.type === "compaction") {
+          role = "SUMMARY";
+        }
+
+        const id = entry.id.slice(0, 8);
+        const isRoot = !parents.has(entry.id);
+        const meta = [isRoot ? "ROOT" : null, isHead ? "HEAD" : null, label ? `tag: ${label}` : null].filter(Boolean).join(", ");
+
+        const body = content.length > 100 ? content.slice(0, 100) + "..." : content;
+
+        const marker = isHead ? "*" : (role === "USER" ? "•" : "|");
+
+        lines.push(`${marker} ${id}${meta ? ` (${meta})` : ""} [${role}] ${body}`);
+      });
+
+      if (hiddenCount > 0) {
+        lines.push(`  :  ... (${hiddenCount} hidden messages) ...`);
+      }
+
+      // --- Context Dashboard (HUD) ---
+      const totalNodes = entryMap.size;
+      const currentDepth = backboneIds.length;
+
+      const usage = await ctx.getContextUsage();
+      let usageStr = "Unknown";
+      if (usage) {
+        usageStr = `${usage.percent.toFixed(1)}% (${formatTokens(usage.tokens)}/${formatTokens(usage.contextWindow)})`;
+      }
+
+      // Find the distance to the nearest tag
+      let stepsSinceTag = 0;
+      let nearestTagName = "None";
+      for (let i = backboneIds.length - 1; i >= 0; i--) {
+        const id = backboneIds[i];
+        const label = sm.getLabel(id);
+        if (label) {
+          nearestTagName = label;
+          break;
+        }
+        stepsSinceTag++;
+      }
+
+      const hud = [
+        `[Context Dashboard]`,
+        `• Context Usage:    ${usageStr}`,
+        `• Segment Size:     ${stepsSinceTag} steps since last tag '${nearestTagName}'`,
+        `---------------------------------------------------`
+      ].join("\n");
+
+      return { content: [{ type: "text", text: hud + "\n" + (lines.join("\n") || "(Root Path Only)") }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "context_checkout",
+    label: "Context Checkout",
+    description: "Navigate to ANY point in the conversation history. This checkout only resets *conversation history*, NOT disk files. ALWAYS provide a detailed 'message' to bridge context.",
+    parameters: ContextCheckoutParams,
+    async execute(_id, params: Static<typeof ContextCheckoutParams>, _signal, _onUpdate, ctx) {
+      const sm = ctx.sessionManager as SessionManager;
+      const tid = resolveTargetId(sm, params.target);
+
+      const currentLeaf = sm.getLeafId();
+      if (currentLeaf === tid) {
+        return { content: [{ type: "text", text: `Already at target ${tid.slice(0, 7)}` }], details: {} };
+      }
+
+      const currentLabel = currentLeaf ? sm.getLabel(currentLeaf) : undefined;
+      const origin = currentLabel ? `tag: ${currentLabel}` : (currentLeaf ? currentLeaf.slice(0, 8) : "unknown");
+
+      const enrichedMessage = `${params.message} (branched from ${origin})`;
+      await sm.branchWithSummary(tid, enrichedMessage);
+
+      // Fix: Label the NEW leaf (the summary node or the checkout target), not necessarily the old target ID.
+      // This ensures 'tagName' acts like naming the NEW branch tip.
+      const newLeaf = sm.getLeafId();
+      if (params.tagName && newLeaf) pi.setLabel(newLeaf, params.tagName);
+
+      return { content: [{ type: "text", text: `Checked out ${tid.slice(0, 7)}` }], details: {} };
+    },
+  });
+
+  pi.registerTool({
+    name: "context_tag",
+    label: "Context Tag",
+    description: "Creates a 'Save Point' (Bookmark) in the history. Use this before trying risky changes or when a feature is stable. 'Untagged progress is risky'.",
+    parameters: ContextTagParams,
+    async execute(_id, params: Static<typeof ContextTagParams>, _signal, _onUpdate, ctx) {
+      const sm = ctx.sessionManager as SessionManager;
+      const id = params.target ? resolveTargetId(sm, params.target) : (sm.getLeafId() ?? "");
+      pi.setLabel(id, params.name);
+      return { content: [{ type: "text", text: `Created tag '${params.name}' at ${id.slice(0, 7)}` }], details: {} };
+    },
+  });
+
+  pi.registerCommand("context", {
+    description: "Show context usage visualization",
+    handler: async (args, ctx) => {
+      const usage = await ctx.getContextUsage();
+      if (!usage) {
+        ctx.ui.notify("Context usage info not available.", "warning");
+        return;
+      }
+
+      const sm = ctx.sessionManager as SessionManager;
+      const branch = sm.getBranch();
+      const systemPrompt = ctx.getSystemPrompt();
+      const tools = pi.getActiveTools();
+      const allTools = pi.getAllTools();
+      const activeToolDefs = allTools.filter(t => tools.includes(t.name));
+
+      const estimateTokens = (text: string) => Math.ceil(text.length / 4);
+
+      let msgTokensRaw = 0;
+      let toolUseTokensRaw = 0;
+      let toolResultTokensRaw = 0;
+
+      for (const entry of branch) {
+        if (entry.type === "message") {
+          const m = entry.message;
+          if (m.role === "user") {
+            if (typeof m.content === "string") msgTokensRaw += estimateTokens(m.content);
+            else if (Array.isArray(m.content)) {
+              for (const p of m.content) if (p.type === "text") msgTokensRaw += estimateTokens(p.text);
+            }
+          } else if (m.role === "assistant") {
+            if (typeof m.content === "string") msgTokensRaw += estimateTokens(m.content);
+            else if (Array.isArray(m.content)) {
+              for (const p of m.content) {
+                if (p.type === "text") msgTokensRaw += estimateTokens(p.text);
+                if (p.type === "toolCall") toolUseTokensRaw += estimateTokens(JSON.stringify(p));
+              }
+            }
+          } else if (m.role === "toolResult") {
+            if (Array.isArray(m.content)) {
+              for (const p of m.content) if (p.type === "text") toolResultTokensRaw += estimateTokens(p.text);
+            }
+          } else if (m.role === "bashExecution") {
+            toolUseTokensRaw += estimateTokens(m.command || "");
+          }
+        } else if (entry.type === "branch_summary" || entry.type === "compaction") {
+          msgTokensRaw += estimateTokens(entry.summary || "");
+        }
+      }
+
+      const systemTokensRaw = estimateTokens(systemPrompt);
+      const toolDefTokensRaw = estimateTokens(JSON.stringify(activeToolDefs));
+      const totalActual = usage.tokens;
+      const limit = usage.contextWindow;
+
+      const totalRaw = systemTokensRaw + toolDefTokensRaw + msgTokensRaw + toolUseTokensRaw + toolResultTokensRaw;
+      const ratio = totalRaw > 0 ? (totalActual / totalRaw) : 1;
+
+      const systemTokens = Math.round(systemTokensRaw * ratio);
+      const toolDefTokens = Math.round(toolDefTokensRaw * ratio);
+      const msgTokens = Math.round(msgTokensRaw * ratio);
+      const toolUseTokens = Math.round(toolUseTokensRaw * ratio);
+      const toolResultTokens = Math.round(toolResultTokensRaw * ratio);
+
+      await ctx.ui.custom((tui, theme, kb, done) => {
+        const container = new Container();
+        container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+        container.addChild(new Text(theme.fg("accent", theme.bold(" Context Usage")), 1, 0));
+        container.addChild(new Spacer(1));
+
+        // Grouped by function and color
+        const categories = [
+          { label: "System Prompt", value: systemTokens, color: "muted" },
+          { label: "System Tools", value: toolDefTokens, color: "dim" },
+          { label: "Tool Call", value: toolUseTokens + toolResultTokens, color: "success" },
+          { label: "Messages", value: msgTokens, color: "accent" },
+        ];
+
+        const otherTokens = Math.max(0, totalActual - (systemTokens + toolDefTokens + msgTokens + toolUseTokens + toolResultTokens));
+        if (otherTokens > 10) categories.push({ label: "Other", value: otherTokens, color: "dim" });
+
+        categories.push({ label: "Available", value: Math.max(0, limit - totalActual), color: "borderMuted" });
+
+        const gridWidth = 10;
+        const gridHeight = 5;
+        const totalBlocks = gridWidth * gridHeight;
+
+        const blocks: { color: string, filled: boolean }[] = [];
+        categories.forEach((cat) => {
+          if (cat.label === "Available") return;
+          let count = Math.round((cat.value / limit) * totalBlocks);
+          if (count === 0 && cat.value > 0) count = 1;
+          for (let i = 0; i < count && blocks.length < totalBlocks; i++) {
+            blocks.push({ color: cat.color, filled: true });
+          }
+        });
+
+        while (blocks.length < totalBlocks) {
+          blocks.push({ color: "borderMuted", filled: false });
+        }
+
+        const gridLines: string[] = [];
+        for (let r = 0; r < gridHeight; r++) {
+          let rowStr = "";
+          for (let c = 0; c < gridWidth; c++) {
+            const b = blocks[r * gridWidth + c];
+            rowStr += theme.fg(b.color as any, b.filled ? "■ " : "□ ");
+          }
+          gridLines.push(rowStr.trimEnd());
+        }
+
+        const totalUsageTitle = `${theme.fg("text", theme.bold("Total Usage".padEnd(16)))} ${theme.fg("text", theme.bold(formatTokens(totalActual).padStart(7)))} ${theme.fg("text", theme.bold(`(${usage.percent.toFixed(1).padStart(5)}%)`))}`;
+
+        const catDetailLines = categories.map(cat => {
+          const labelStr = cat.label.padEnd(14);
+          const valStr = formatTokens(cat.value).padStart(7);
+          const rowPercent = ((cat.value / limit) * 100).toFixed(1).padStart(5);
+          const icon = cat.label === "Available" ? "□" : "■";
+          return `${theme.fg(cat.color as any, icon)} ${theme.fg("text", labelStr)} ${theme.fg("accent", valStr)} (${rowPercent}%)`;
+        });
+
+        const allDetailLines = [totalUsageTitle, "", ...catDetailLines];
+
+        const leftSideWidth = 20;
+        const maxH = Math.max(gridLines.length, allDetailLines.length);
+        for (let i = 0; i < maxH; i++) {
+          const left = (gridLines[i] || "").padEnd(leftSideWidth);
+          const right = allDetailLines[i] || "";
+          container.addChild(new Text(`    ${left}      ${right}`, 1, 0));
+        }
+
+        container.addChild(new Spacer(1));
+        container.addChild(new Text(theme.fg("dim", " Press any key to close"), 1, 0));
+        container.addChild(new DynamicBorder((s: string) => theme.fg("accent", s)));
+
+        return {
+          render: (w) => container.render(w),
+          invalidate: () => container.invalidate(),
+          handleInput: (data) => done(undefined),
+        };
+      }, { overlay: true });
+    }
+  });
+}

package/dist/index.d.ts

@@ -1,2 +0,0 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-export default function (pi: ExtensionAPI): void;

package/dist/index.js

@@ -1,215 +0,0 @@
-import { DynamicBorder } from "@mariozechner/pi-coding-agent";
-import { Type } from "@sinclair/typebox";
-import { Container, Text, Spacer } from "@mariozechner/pi-tui";
-const ContextLogParams = Type.Object({
-    limit: Type.Optional(Type.Number({ description: "History limit for visible entries (default: 50)." })),
-    verbose: Type.Optional(Type.Boolean({ description: "If true, show ALL messages. If false, collapses intermediate steps." })),
-});
-const ContextCheckoutParams = Type.Object({
-    target: Type.String({ description: "Tag name or ID." }),
-    message: Type.String({ description: "Carryover message." }),
-    tagName: Type.Optional(Type.String()),
-});
-const ContextTagParams = Type.Object({
-    name: Type.String(),
-    target: Type.Optional(Type.String()),
-});
-const formatTokens = (n) => {
-    if (n >= 1_000_000)
-        return (n / 1_000_000).toFixed(1) + "M";
-    if (n >= 1_000)
-        return Math.round(n / 1_000) + "k";
-    return n.toString();
-};
-const resolveTargetId = (sm, target) => {
-    if (target.toLowerCase() === "root") {
-        const tree = sm.getTree();
-        return tree.length > 0 ? tree[0].entry.id : target;
-    }
-    if (/^[0-9a-f]{8,}$/i.test(target))
-        return target;
-    const find = (nodes) => {
-        for (const n of nodes) {
-            if (sm.getLabel(n.entry.id) === target)
-                return n.entry.id;
-            const r = find(n.children);
-            if (r)
-                return r;
-        }
-        return null;
-    };
-    return find(sm.getTree()) || target;
-};
-export default function (pi) {
-    pi.registerTool({
-        name: "context_log",
-        label: "Context Log",
-        description: "Show history structure.",
-        parameters: ContextLogParams,
-        async execute(_id, params, _signal, _onUpdate, ctx) {
-            return { content: [{ type: "text", text: "Use /tree or context_log for history." }], details: {} };
-        }
-    });
-    pi.registerTool({
-        name: "context_checkout",
-        label: "Context Checkout",
-        description: "Navigate history.",
-        parameters: ContextCheckoutParams,
-        async execute(_id, params, _signal, _onUpdate, ctx) {
-            const sm = ctx.sessionManager;
-            const tid = resolveTargetId(sm, params.target);
-            await sm.branchWithSummary(tid, params.message);
-            return { content: [{ type: "text", text: `Jumped to ${tid.slice(0, 7)}` }], details: {} };
-        }
-    });
-    pi.registerTool({
-        name: "context_tag",
-        label: "Context Tag",
-        description: "Create checkpoint.",
-        parameters: ContextTagParams,
-        async execute(_id, params, _signal, _onUpdate, ctx) {
-            const sm = ctx.sessionManager;
-            const id = params.target ? resolveTargetId(sm, params.target) : (sm.getLeafId() ?? "");
-            pi.setLabel(id, params.name);
-            return { content: [{ type: "text", text: `Tagged ${params.name}` }], details: {} };
-        }
-    });
-    pi.registerCommand("context", {
-        description: "Show context usage visualization (Claude Code style)",
-        handler: async (args, ctx) => {
-            const usage = await ctx.getContextUsage();
-            if (!usage) {
-                ctx.ui.notify("Context usage info not available.", "warning");
-                return;
-            }
-            const sm = ctx.sessionManager;
-            const branch = sm.getBranch();
-            const systemPrompt = ctx.getSystemPrompt();
-            const tools = pi.getActiveTools();
-            const allTools = pi.getAllTools();
-            const activeToolDefs = allTools.filter(t => tools.includes(t.name));
-            const estimateTokens = (text) => Math.ceil(text.length / 4);
-            let msgTokensRaw = 0;
-            let toolUseTokensRaw = 0;
-            let toolResultTokensRaw = 0;
-            for (const entry of branch) {
-                if (entry.type === "message") {
-                    const m = entry.message;
-                    if (m.role === "user") {
-                        if (typeof m.content === "string")
-                            msgTokensRaw += estimateTokens(m.content);
-                        else if (Array.isArray(m.content)) {
-                            for (const p of m.content)
-                                if (p.type === "text")
-                                    msgTokensRaw += estimateTokens(p.text);
-                        }
-                    }
-                    else if (m.role === "assistant") {
-                        if (typeof m.content === "string")
-                            msgTokensRaw += estimateTokens(m.content);
-                        else if (Array.isArray(m.content)) {
-                            for (const p of m.content) {
-                                if (p.type === "text")
-                                    msgTokensRaw += estimateTokens(p.text);
-                                if (p.type === "toolCall")
-                                    toolUseTokensRaw += estimateTokens(JSON.stringify(p));
-                            }
-                        }
-                    }
-                    else if (m.role === "toolResult") {
-                        if (Array.isArray(m.content)) {
-                            for (const p of m.content)
-                                if (p.type === "text")
-                                    toolResultTokensRaw += estimateTokens(p.text);
-                        }
-                    }
-                    else if (m.role === "bashExecution") {
-                        toolUseTokensRaw += estimateTokens(m.command || "");
-                    }
-                }
-                else if (entry.type === "branch_summary" || entry.type === "compaction") {
-                    msgTokensRaw += estimateTokens(entry.summary || "");
-                }
-            }
-            const systemTokensRaw = estimateTokens(systemPrompt);
-            const toolDefTokensRaw = estimateTokens(JSON.stringify(activeToolDefs));
-            const totalActual = usage.tokens;
-            const limit = usage.contextWindow;
-            const totalRaw = systemTokensRaw + toolDefTokensRaw + msgTokensRaw + toolUseTokensRaw + toolResultTokensRaw;
-            const ratio = totalRaw > 0 ? (totalActual / totalRaw) : 1;
-            const systemTokens = Math.round(systemTokensRaw * ratio);
-            const toolDefTokens = Math.round(toolDefTokensRaw * ratio);
-            const msgTokens = Math.round(msgTokensRaw * ratio);
-            const toolUseTokens = Math.round(toolUseTokensRaw * ratio);
-            const toolResultTokens = Math.round(toolResultTokensRaw * ratio);
-            await ctx.ui.custom((tui, theme, kb, done) => {
-                const container = new Container();
-                container.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
-                container.addChild(new Text(theme.fg("accent", theme.bold(" Context Usage")), 1, 0));
-                container.addChild(new Spacer(1));
-                // Grouped by function and color
-                const categories = [
-                    { label: "System", value: systemTokens, color: "dim" },
-                    { label: "Tools", value: toolDefTokens, color: "dim" },
-                    { label: "Messages", value: msgTokens, color: "accent" },
-                    { label: "Tool Use", value: toolUseTokens, color: "success" },
-                    { label: "Tool Results", value: toolResultTokens, color: "success" },
-                ];
-                const otherTokens = Math.max(0, totalActual - (systemTokens + toolDefTokens + msgTokens + toolUseTokens + toolResultTokens));
-                if (otherTokens > 10)
-                    categories.push({ label: "Other", value: otherTokens, color: "dim" });
-                categories.push({ label: "Available", value: Math.max(0, limit - totalActual), color: "borderMuted" });
-                const gridWidth = 10;
-                const gridHeight = 5;
-                const totalBlocks = gridWidth * gridHeight;
-                const blocks = [];
-                categories.forEach((cat) => {
-                    if (cat.label === "Available")
-                        return;
-                    let count = Math.round((cat.value / limit) * totalBlocks);
-                    if (count === 0 && cat.value > 0)
-                        count = 1;
-                    for (let i = 0; i < count && blocks.length < totalBlocks; i++) {
-                        blocks.push({ color: cat.color, filled: true });
-                    }
-                });
-                while (blocks.length < totalBlocks) {
-                    blocks.push({ color: "borderMuted", filled: false });
-                }
-                const gridLines = [];
-                for (let r = 0; r < gridHeight; r++) {
-                    let rowStr = "";
-                    for (let c = 0; c < gridWidth; c++) {
-                        const b = blocks[r * gridWidth + c];
-                        rowStr += theme.fg(b.color, b.filled ? "■ " : "□ ");
-                    }
-                    gridLines.push(rowStr.trimEnd());
-                }
-                const totalUsageTitle = `${theme.fg("text", theme.bold("Total Usage".padEnd(16)))} ${theme.fg("accent", theme.bold(formatTokens(totalActual).padStart(7)))} ${theme.fg("accent", theme.bold(`(${usage.percent.toFixed(1).padStart(5)}%)`))}`;
-                const catDetailLines = categories.map(cat => {
-                    const labelStr = cat.label.padEnd(14);
-                    const valStr = formatTokens(cat.value).padStart(7);
-                    const rowPercent = ((cat.value / limit) * 100).toFixed(1).padStart(5);
-                    const icon = cat.label === "Available" ? "□" : "■";
-                    return `${theme.fg(cat.color, icon)} ${theme.fg("text", labelStr)} ${theme.fg("accent", valStr)} (${rowPercent}%)`;
-                });
-                const allDetailLines = [totalUsageTitle, "", ...catDetailLines];
-                const leftSideWidth = 20;
-                const maxH = Math.max(gridLines.length, allDetailLines.length);
-                for (let i = 0; i < maxH; i++) {
-                    const left = (gridLines[i] || "").padEnd(leftSideWidth);
-                    const right = allDetailLines[i] || "";
-                    container.addChild(new Text(`    ${left}      ${right}`, 1, 0));
-                }
-                container.addChild(new Spacer(1));
-                container.addChild(new Text(theme.fg("dim", " Press any key to close"), 1, 0));
-                container.addChild(new DynamicBorder((s) => theme.fg("accent", s)));
-                return {
-                    render: (w) => container.render(w),
-                    invalidate: () => container.invalidate(),
-                    handleInput: (data) => done(undefined),
-                };
-            }, { overlay: true });
-        }
-    });
-}