pi-lean-ctx 1.0.8 → 3.0.0

package/README.md

@@ -1,9 +1,11 @@
 # pi-lean-ctx
 
-[Pi Coding Agent](https://github.com/badlogic/pi-mono) extension that routes all tool output through [lean-ctx](https://leanctx.com) for **60–90% token savings**.
+[Pi Coding Agent](https://github.com/badlogic/pi-mono) extension with **first-class MCP support** — routes all tool output through [lean-ctx](https://leanctx.com) for **60–90% token savings** and exposes **34 MCP tools** natively in Pi.
 
 ## What it does
 
+### Built-in Tool Overrides (CLI)
+
 Overrides Pi's built-in tools to route them through `lean-ctx`:
 
 | Tool | Compression |
@@ -14,6 +16,44 @@ Overrides Pi's built-in tools to route them through `lean-ctx`:
 | `find` | File listings compressed and .gitignore-aware |
 | `ls` | Directory output compressed |
 
+### MCP Tools (Embedded Bridge)
+
+Additionally, pi-lean-ctx spawns lean-ctx as an MCP server and registers all advanced tools directly in Pi:
+
+| Tool | Purpose |
+|------|---------|
+| `ctx_session` | Session state management and persistence |
+| `ctx_knowledge` | Project knowledge graph with temporal validity |
+| `ctx_semantic_search` | Find code by meaning, not exact text |
+| `ctx_overview` | Codebase overview and architecture analysis |
+| `ctx_compress` | Manual compression control |
+| `ctx_metrics` | Token savings dashboard |
+| `ctx_agent` | Multi-agent coordination and handoffs |
+| `ctx_graph` | Dependency graph analysis |
+| `ctx_discover` | Smart code discovery |
+| `ctx_context` | Context window management |
+| `ctx_preload` | Predictive file preloading |
+| `ctx_delta` | Changed-lines-only reads |
+| `ctx_edit` | Read-modify-write in one call |
+| `ctx_dedup` | Duplicate context elimination |
+| `ctx_fill` | Budget-aware context filling |
+| `ctx_intent` | Intent-based task routing |
+| `ctx_response` | Response optimization |
+| `ctx_wrapped` | Wrapped command execution |
+| `ctx_benchmark` | Compression benchmarking |
+| `ctx_analyze` | Code analysis |
+| `ctx_cache` | Cache management |
+| `ctx_execute` | Direct command execution |
+| `ctx_impact` | Reverse dependency analysis |
+| `ctx_architecture` | Project architecture map |
+| `ctx_heatmap` | File access heatmap |
+| `ctx_task` | Task management |
+| `ctx_cost` | Cost attribution tracking |
+| `ctx_share` | Cross-agent context sharing |
+| `ctx_smart_read` | Adaptive mode selection |
+
+These MCP tools are the same ones available in Cursor, Claude Code, VS Code, and all other supported editors — now first-class in Pi. Tools are auto-discovered via MCP, so new tools added to lean-ctx are automatically available without updating this package.
+
 ## Install
 
 ```bash
@@ -23,8 +63,57 @@ cargo install lean-ctx
 
 # 2. Install the Pi package
 pi install npm:pi-lean-ctx
+
+# 3. Restart Pi
+```
+
+Or use the automated setup:
+
+```bash
+lean-ctx init --agent pi
+```
+
+## How it works
+
+### CLI overrides (bash, read, grep, find, ls)
+
+These tools invoke the `lean-ctx` binary via CLI with `LEAN_CTX_COMPRESS=1`. The output is parsed for compression stats and displayed with a token savings footer.
+
+### MCP bridge (all other tools)
+
+On startup, pi-lean-ctx spawns the `lean-ctx` binary as an MCP server (JSON-RPC over stdio). It discovers available tools via `list_tools`, filters out those already covered by CLI overrides, and registers the rest as native Pi tools.
+
+If `lean-ctx` is already configured as an MCP server via [pi-mcp-adapter](https://github.com/nicobailon/pi-mcp-adapter) in `~/.pi/agent/mcp.json`, the embedded bridge is skipped to avoid duplicate tools.
+
+### Automatic reconnection
+
+If the MCP server process crashes, the bridge automatically reconnects (up to 3 attempts with exponential backoff). If reconnection fails, CLI-based tools continue working normally — only the advanced MCP tools become unavailable.
+
+## pi-mcp-adapter compatibility
+
+If you prefer using [pi-mcp-adapter](https://github.com/nicobailon/pi-mcp-adapter) to manage your MCP servers, lean-ctx integrates automatically:
+
+```bash
+# Option A: lean-ctx writes the config for you
+lean-ctx init --agent pi
+
+# Option B: Manual configuration in ~/.pi/agent/mcp.json
+```
+
+```json
+{
+  "mcpServers": {
+    "lean-ctx": {
+      "command": "/path/to/lean-ctx",
+      "lifecycle": "lazy",
+      "directTools": true
+    }
+  }
+}
 ```
 
+When pi-mcp-adapter manages the lean-ctx MCP server, pi-lean-ctx detects this and only registers its CLI-based tool overrides, leaving MCP tool management to the adapter.
+
 ## Binary Resolution
 
 The extension locates the `lean-ctx` binary in this order:
@@ -42,19 +131,32 @@ The `read` tool automatically selects the optimal lean-ctx mode:
 | File Type | Size | Mode |
 |-----------|------|------|
 | `.md`, `.json`, `.toml`, `.yaml`, etc. | Any | `full` |
-| Code files (55+ extensions) | < 24 KB | `full` |
-| Code files | 24–160 KB | `map` (deps + API signatures) |
-| Code files | > 160 KB | `signatures` (AST extraction) |
+| Code files (55+ extensions) | < 8 KB | `full` |
+| Code files | 8–96 KB | `map` (deps + API signatures) |
+| Code files | > 96 KB | `signatures` (AST extraction) |
 | Other files | < 48 KB | `full` |
 | Other files | > 48 KB | `map` |
 
-Code extensions include: `.rs`, `.ts`, `.tsx`, `.js`, `.jsx`, `.py`, `.go`, `.java`, `.c`, `.cpp`, `.cs`, `.rb`, `.php`, `.swift`, `.kt`, `.vue`, `.svelte`, `.astro`, `.html`, `.css`, `.scss`, `.lua`, `.zig`, `.dart`, `.scala`, `.sql`, `.graphql`, `.proto`, `.tf`, `.sh`, `.bash`, `.zsh`, `.fish`, `.ps1`, and more.
+## Slash Command
 
-**Partial reads** (with `offset`/`limit`) are also routed through lean-ctx using `lines:N-M` mode for compression.
+Use `/lean-ctx` in Pi to check:
+- Which binary is being used
+- MCP bridge status (embedded vs. adapter, connected/disconnected)
+- Number and names of registered MCP tools
 
-## Slash Command
+## Disabling specific tools
+
+To disable specific MCP tools, configure `disabled_tools` in `~/.lean-ctx/config.toml`:
+
+```toml
+disabled_tools = ["ctx_graph", "ctx_benchmark"]
+```
+
+Or via environment variable:
 
-Use `/lean-ctx` in Pi to check which binary is being used.
+```bash
+LEAN_CTX_DISABLED_TOOLS=ctx_graph,ctx_benchmark pi
+```
 
 ## Links
 

package/extensions/index.ts

@@ -10,10 +10,12 @@ import {
 } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { readFile, stat } from "node:fs/promises";
-import { dirname, extname, resolve } from "node:path";
+import { extname, resolve } from "node:path";
 import { homedir, platform } from "node:os";
+import { McpBridge } from "./mcp-bridge.js";
+import type { CompressionStats } from "./types.js";
 
 const CODE_EXTENSIONS = new Set([
   ".rs", ".ts", ".tsx", ".js", ".jsx", ".php", ".py", ".go",
@@ -121,12 +123,6 @@ async function readSlice(path: string, offset?: number, limit?: number) {
   return { text: truncation.content, lines: lines.length, truncated: truncation.truncated };
 }
 
-type CompressionStats = {
-  originalTokens: number;
-  compressedTokens: number;
-  percentSaved: number;
-};
-
 function estimateTokens(text: string) {
   return Math.ceil(text.length / 4);
 }
@@ -232,6 +228,27 @@ function splitFooter(text: string) {
   return { body: normalized.slice(0, -match[0].length), footer: match[1] };
 }
 
+function isMcpAdapterConfigured(): boolean {
+  const home = homedir();
+  const mcpConfigPaths = [
+    resolve(home, ".pi", "agent", "mcp.json"),
+    resolve(process.cwd(), ".pi", "mcp.json"),
+  ];
+
+  for (const configPath of mcpConfigPaths) {
+    if (!existsSync(configPath)) continue;
+    try {
+      const content = readFileSync(configPath, "utf8");
+      const json = JSON.parse(content);
+      const servers = json?.mcpServers ?? {};
+      if ("lean-ctx" in servers) return true;
+    } catch {
+      continue;
+    }
+  }
+  return false;
+}
+
 async function execLeanCtx(pi: ExtensionAPI, args: string[]) {
   const bin = resolveBinary();
   const result = await pi.exec(bin, args, { env: { LEAN_CTX_COMPRESS: "1" } });
@@ -455,15 +472,30 @@ export default function (pi: ExtensionAPI) {
     },
   });
 
+  const mcpBridge = new McpBridge(resolveBinary());
+
+  if (!isMcpAdapterConfigured()) {
+    mcpBridge.start(pi).catch((err) => {
+      console.error(`[pi-lean-ctx] MCP bridge startup failed: ${err}`);
+    });
+  }
+
   pi.registerCommand("lean-ctx", {
-    description: "Show the lean-ctx binary currently used by the Pi integration",
+    description: "Show lean-ctx status: binary path, MCP bridge, and registered tools",
     handler: async (_args, ctx) => {
       const bin = resolveBinary();
       const found = existsSync(bin);
-      ctx.ui.notify(
-        found ? `pi-lean-ctx using: ${bin}` : `lean-ctx not found. Install: cargo install lean-ctx`,
-        found ? "info" : "warning",
-      );
+      const status = mcpBridge.getStatus();
+
+      const lines: string[] = [];
+      lines.push(found ? `Binary: ${bin}` : "Binary: NOT FOUND — install: cargo install lean-ctx");
+      lines.push(`MCP bridge: ${status.mode} (${status.connected ? "connected" : "disconnected"})`);
+      lines.push(`MCP tools: ${status.toolCount} registered`);
+      if (status.toolNames.length > 0) {
+        lines.push(`  ${status.toolNames.join(", ")}`);
+      }
+
+      ctx.ui.notify(lines.join("\n"), found && status.connected ? "info" : "warning");
     },
   });
 }

package/extensions/mcp-bridge.ts

@@ -0,0 +1,215 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import type { McpBridgeStatus } from "./types.js";
+
+const CLI_OVERRIDE_TOOLS = new Set([
+  "ctx_read",
+  "ctx_multi_read",
+  "ctx_shell",
+  "ctx_search",
+  "ctx_tree",
+]);
+
+const MAX_RECONNECT_ATTEMPTS = 3;
+const RECONNECT_DELAY_MS = 2000;
+
+type McpTool = {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+};
+
+export class McpBridge {
+  private client: Client | null = null;
+  private transport: StdioClientTransport | null = null;
+  private registeredTools: string[] = [];
+  private connected = false;
+  private binary: string;
+  private reconnectAttempts = 0;
+
+  constructor(binary: string) {
+    this.binary = binary;
+  }
+
+  async start(pi: ExtensionAPI): Promise<void> {
+    try {
+      await this.connect();
+      await this.discoverAndRegisterTools(pi);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[lean-ctx MCP bridge] Failed to start: ${msg}`);
+    }
+  }
+
+  private async connect(): Promise<void> {
+    this.transport = new StdioClientTransport({
+      command: this.binary,
+      args: [],
+      stderr: "pipe",
+    });
+
+    this.client = new Client({
+      name: "pi-lean-ctx",
+      version: "3.0.0",
+    });
+
+    this.transport.onclose = () => {
+      this.connected = false;
+      this.scheduleReconnect();
+    };
+
+    this.transport.onerror = (err) => {
+      console.error(`[lean-ctx MCP bridge] Transport error: ${err.message}`);
+    };
+
+    await this.client.connect(this.transport);
+    this.connected = true;
+    this.reconnectAttempts = 0;
+  }
+
+  private scheduleReconnect(): void {
+    if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      console.error(
+        `[lean-ctx MCP bridge] Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached. MCP tools unavailable.`,
+      );
+      return;
+    }
+
+    this.reconnectAttempts++;
+    const delay = RECONNECT_DELAY_MS * this.reconnectAttempts;
+
+    setTimeout(async () => {
+      try {
+        await this.connect();
+        console.error("[lean-ctx MCP bridge] Reconnected successfully");
+      } catch {
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+
+  private async discoverAndRegisterTools(pi: ExtensionAPI): Promise<void> {
+    if (!this.client) return;
+
+    const result = await this.client.listTools();
+    const tools = (result.tools ?? []) as McpTool[];
+
+    for (const tool of tools) {
+      if (CLI_OVERRIDE_TOOLS.has(tool.name)) continue;
+      this.registerMcpTool(pi, tool);
+    }
+  }
+
+  private registerMcpTool(pi: ExtensionAPI, tool: McpTool): void {
+    const bridge = this;
+    const schema = this.jsonSchemaToTypebox(tool.inputSchema);
+
+    pi.registerTool({
+      name: tool.name,
+      label: tool.name,
+      description: tool.description ?? `lean-ctx MCP tool: ${tool.name}`,
+      promptSnippet: tool.description ?? tool.name,
+      parameters: schema,
+      async execute(_toolCallId, params, _signal) {
+        return bridge.callTool(tool.name, params as Record<string, unknown>);
+      },
+    });
+
+    this.registeredTools.push(tool.name);
+  }
+
+  async callTool(
+    name: string,
+    args: Record<string, unknown>,
+  ): Promise<{ content: Array<{ type: string; text: string }> }> {
+    if (!this.client || !this.connected) {
+      throw new Error(
+        `lean-ctx MCP bridge not connected. Tool "${name}" unavailable.`,
+      );
+    }
+
+    const result = await this.client.callTool({ name, arguments: args });
+
+    const content = (
+      result.content as Array<{ type: string; text?: string }>
+    ).map((block) => ({
+      type: "text" as const,
+      text: block.text ?? "",
+    }));
+
+    return { content };
+  }
+
+  private jsonSchemaToTypebox(
+    schema?: Record<string, unknown>,
+  ): ReturnType<typeof Type.Object> {
+    if (!schema || !schema.properties) {
+      return Type.Object({});
+    }
+
+    const properties = schema.properties as Record<
+      string,
+      Record<string, unknown>
+    >;
+    const required = new Set(
+      (schema.required as string[] | undefined) ?? [],
+    );
+    const fields: Record<string, ReturnType<typeof Type.String>> = {};
+
+    for (const [key, prop] of Object.entries(properties)) {
+      const desc = (prop.description as string) ?? undefined;
+      const jsonType = prop.type as string | undefined;
+
+      let field;
+      switch (jsonType) {
+        case "number":
+        case "integer":
+          field = Type.Number({ description: desc });
+          break;
+        case "boolean":
+          field = Type.Boolean({ description: desc });
+          break;
+        case "array":
+          field = Type.Array(Type.Unknown(), { description: desc });
+          break;
+        case "object":
+          field = Type.Record(Type.String(), Type.Unknown(), {
+            description: desc,
+          });
+          break;
+        default:
+          field = Type.String({ description: desc });
+          break;
+      }
+
+      fields[key] = required.has(key)
+        ? field
+        : Type.Optional(field);
+    }
+
+    return Type.Object(fields);
+  }
+
+  getStatus(): McpBridgeStatus {
+    return {
+      mode: "embedded",
+      connected: this.connected,
+      toolCount: this.registeredTools.length,
+      toolNames: [...this.registeredTools],
+    };
+  }
+
+  async shutdown(): Promise<void> {
+    this.reconnectAttempts = MAX_RECONNECT_ATTEMPTS;
+    try {
+      await this.client?.close();
+    } catch {
+      // best-effort cleanup
+    }
+    this.client = null;
+    this.transport = null;
+    this.connected = false;
+  }
+}

package/extensions/types.ts

@@ -0,0 +1,13 @@
+export type CompressionStats = {
+  originalTokens: number;
+  compressedTokens: number;
+  percentSaved: number;
+};
+
+export type McpBridgeStatus = {
+  mode: "embedded" | "adapter" | "disabled";
+  connected: boolean;
+  toolCount: number;
+  toolNames: string[];
+  error?: string;
+};

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "pi-lean-ctx",
-  "version": "1.0.8",
-  "description": "Pi Coding Agent extension that routes bash, read, grep, find, and ls through lean-ctx for 60-90% token savings",
-  "keywords": ["pi-package", "lean-ctx", "token-optimization", "compression"],
+  "version": "3.0.0",
+  "description": "Pi Coding Agent extension with first-class MCP support — routes bash, read, grep, find, and ls through lean-ctx CLI, and exposes all 34 lean-ctx MCP tools (ctx_session, ctx_knowledge, ctx_semantic_search, ctx_impact, ctx_architecture, etc.) natively in Pi",
+  "keywords": ["pi-package", "lean-ctx", "token-optimization", "compression", "mcp"],
   "license": "MIT",
   "author": "Yves Gugger",
   "repository": {
@@ -14,6 +14,9 @@
   "bugs": {
     "url": "https://github.com/yvgude/lean-ctx/issues"
   },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
   "peerDependencies": {
     "@mariozechner/pi-coding-agent": ">=0.50.0",
     "@mariozechner/pi-tui": "*"