@saccolabs/pi-claude-cli 0.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rebecca Chernoff
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,54 @@
+# pi-claude-cli
+
+> **This is a maintenance fork.** The upstream project's last commit was in March 2026, and it had stopped working against current [pi](https://github.com/earendil-works/pi). This fork updates it for compatibility with the current pi version, and folds in three open upstream pull requests that hadn't been merged:
+>
+> - **[#25](https://github.com/rchern/pi-claude-cli/pull/25)** — don't resume a Claude CLI session that was never created (fixes empty replies when switching to this provider mid-conversation), and surface CLI errors instead of silently returning nothing.
+> - **[#26](https://github.com/rchern/pi-claude-cli/pull/26)** — fix a false "not authenticated" warning on Claude Code 2.x, and correct the outdated login instructions.
+> - **[#29](https://github.com/rchern/pi-claude-cli/pull/29)** — let all models use the full thinking-effort range (up to `max`), not just Opus.
+>
+> Together these resolve the widely-reported problem where prompting a `pi-claude-cli` model just returned an empty response ([#3](https://github.com/rchern/pi-claude-cli/issues/3)). Credit for the three fixes goes to their original PR authors.
+
+A [pi](https://github.com/earendil-works/pi) extension that routes LLM calls through the [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) as a subprocess. Use your Claude Pro/Max subscription as the LLM backend — no API key, no separate billing.
+
+## How it works
+
+The extension registers as a custom pi provider exposing all Claude models. Each request spawns a `claude -p` subprocess using the stream-json wire protocol, with `--resume` on follow-up turns to reuse the CLI's session state instead of replaying full history. Claude proposes tool calls, pi executes them natively. Custom pi tools are exposed to Claude via a schema-only MCP server.
+
+## Requirements
+
+- [Claude Code CLI](https://docs.anthropic.com/en/docs/claude-code) installed and authenticated (`claude` on PATH)
+- A Claude Pro or Max subscription
+- [pi](https://github.com/earendil-works/pi) or [GSD](https://github.com/gsd-build/gsd-2)
+
+## Installation
+
+```bash
+pi install npm:@saccolabs/pi-claude-cli
+```
+
+Or declare it in `~/.pi/agent/settings.json` (global) or `.pi/settings.json` (project):
+
+```json
+{
+  "packages": ["npm:@saccolabs/pi-claude-cli"]
+}
+```
+
+Then select a Claude model via `/model` in the interactive UI. All Claude models appear under the `pi-claude-cli` provider.
+
+Requires the `claude` binary on your login-shell PATH (`npm install -g @anthropic-ai/claude-code`), authenticated with your Claude Pro/Max account.
+
+## Features
+
+- Streams text, thinking, and tool call tokens in real-time
+- Maps tool names and arguments bidirectionally between Claude and pi
+- Exposes custom pi tools to Claude via MCP (schema-only, no execution)
+- Break-early pattern prevents Claude CLI from auto-executing tools
+- Session resume via `--resume` eliminates history replay on follow-up turns
+- Configurable thinking effort across the full ladder (low to max) for all models, with elevated mapping for Opus
+- Cross-platform subprocess management (Windows, macOS, Linux)
+- Inactivity timeout and process registry for cleanup
+
+## License
+
+MIT

package/index.ts

@@ -0,0 +1,133 @@
+/**
+ * Pi extension entry point for pi-claude-cli.
+ *
+ * Registers a custom provider that routes LLM calls through the Claude Code CLI
+ * subprocess using stream-json NDJSON protocol.
+ */
+
+import { getBuiltinModels as getModels } from "@earendil-works/pi-ai/providers/all";
+import { registerApiProvider } from "@earendil-works/pi-ai/compat";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { streamViaCli } from "./src/provider.js";
+import {
+  validateCliPresence,
+  validateCliAuth,
+  killAllProcesses,
+} from "./src/process-manager.js";
+import { getCustomToolDefs, writeMcpConfig } from "./src/mcp-config.js";
+
+// Kill all active Claude subprocesses on process exit to prevent orphans
+process.on("exit", killAllProcesses);
+
+const PROVIDER_ID = "pi-claude-cli";
+
+let mcpConfigPath: string | undefined;
+let mcpConfigResolved = false;
+
+/**
+ * Lazily generate MCP config on first request (not at load time).
+ * pi.getAllTools() fails during extension loading; this defers it
+ * until the pi runtime is fully initialized.
+ *
+ * Only locks (sets mcpConfigResolved) when getAllTools() returns a
+ * real array — if it returns undefined/null (registry not ready),
+ * we retry on the next request. Once the registry is ready we
+ * commit to the result even if there are zero custom tools.
+ *
+ * Uses warn-don't-block: failure logs a warning but does not
+ * prevent the provider from functioning (built-ins still work).
+ */
+function ensureMcpConfig(pi: ExtensionAPI): string | undefined {
+  if (mcpConfigResolved) return mcpConfigPath;
+  try {
+    const allTools = pi.getAllTools();
+
+    // Registry not ready yet — don't lock, retry on next call
+    if (!Array.isArray(allTools)) {
+      return mcpConfigPath;
+    }
+
+    // Registry is ready — lock regardless of whether custom tools exist
+    mcpConfigResolved = true;
+
+    const toolDefs = getCustomToolDefs(pi);
+    if (toolDefs.length > 0) {
+      mcpConfigPath = writeMcpConfig(toolDefs);
+      console.error(
+        `[pi-claude-cli] MCP config generated with ${toolDefs.length} custom tool(s)`,
+      );
+    }
+  } catch (err) {
+    console.warn(
+      "[pi-claude-cli] MCP config generation failed, custom tools unavailable:",
+      err,
+    );
+  }
+  return mcpConfigPath;
+}
+
+export default function (pi: ExtensionAPI) {
+  try {
+    // Startup validation
+    validateCliPresence(); // throws if CLI not on PATH
+    validateCliAuth(); // warns if not authenticated
+
+    const models = getModels("anthropic").map((model) => ({
+      id: model.id,
+      name: model.name,
+      reasoning: model.reasoning,
+      input: model.input,
+      cost: model.cost,
+      contextWindow: model.contextWindow,
+      maxTokens: model.maxTokens,
+      // pi's thinking selector only offers xhigh/max when the model's
+      // thinkingLevelMap declares them (getSupportedThinkingLevels in pi-ai);
+      // without this, every model is capped at "high" in the UI. The mapped
+      // values are unused by this provider — effort is derived from
+      // options.reasoning in mapThinkingEffort.
+      thinkingLevelMap: { xhigh: "xhigh", max: "max" },
+    }));
+
+    // Ensure all registered tools are active so pi can execute them.
+    // Some tools (find, grep, ls) are registered but not activated by default.
+    pi.on("session_start", async () => {
+      const allTools = pi.getAllTools();
+      if (Array.isArray(allTools)) {
+        pi.setActiveTools(allTools.map((t: any) => t.name));
+      }
+    });
+
+    const streamFn = (
+      model: Parameters<typeof streamViaCli>[0],
+      context: Parameters<typeof streamViaCli>[1],
+      options?: Parameters<typeof streamViaCli>[2],
+    ) => {
+      const configPath = ensureMcpConfig(pi);
+      return streamViaCli(model, context, {
+        ...options,
+        mcpConfigPath: configPath,
+      });
+    };
+
+    // pi.registerProvider() feeds pi's provider composer, but pi 0.84's
+    // default stream fn (pi-agent-core setDefaultStreamFn) resolves
+    // model.api against pi-ai's global api registry instead — print mode
+    // and nested agent loops take that path and would throw
+    // "No API provider registered for api: pi-claude-cli" (#32).
+    // Register the custom api id there too.
+    registerApiProvider(
+      { api: PROVIDER_ID as any, stream: streamFn, streamSimple: streamFn },
+      PROVIDER_ID,
+    );
+
+    pi.registerProvider(PROVIDER_ID, {
+      baseUrl: "pi-claude-cli",
+      apiKey: "unused",
+      api: "pi-claude-cli",
+      models,
+      streamSimple: streamFn,
+    });
+  } catch (err) {
+    console.error(`[pi-claude-cli] Failed to register provider:`, err);
+  }
+}

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@saccolabs/pi-claude-cli",
+  "version": "0.4.0",
+  "description": "Pi coding agent extension that routes LLM calls through the Claude Code CLI",
+  "main": "index.ts",
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agustinsacco/pi-claude-cli"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*"
+  },
+  "dependencies": {
+    "cross-spawn": "^7.0.6"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "0.84.2",
+    "@earendil-works/pi-coding-agent": "0.84.2",
+    "@eslint/js": "^9.39.4",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.39.4",
+    "eslint-config-prettier": "^10.1.8",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.8.1",
+    "typescript": "^5.7.0",
+    "typescript-eslint": "^8.57.0",
+    "vitest": "^3.0.0"
+  },
+  "lint-staged": {
+    "*.{ts,js,cjs,mjs}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "scripts": {
+    "test": "vitest run --reporter=verbose",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "format:check": "prettier --check .",
+    "prepare": "husky || true",
+    "test:e2e": "bash scripts/e2e-stub.sh"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "index.ts",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/control-handler.ts

@@ -0,0 +1,68 @@
+/**
+ * Control protocol handler for Claude CLI stream-json communication.
+ *
+ * Processes control_request messages from Claude CLI stdout and writes
+ * control_response messages to stdin.
+ *
+ * - Custom MCP tools (mcp__custom-tools__*): DENIED — pi executes these
+ * - Everything else (user MCP tools, internal tools): ALLOWED — Claude handles
+ */
+
+import type { ClaudeControlRequest } from "./types";
+import { CUSTOM_TOOLS_MCP_PREFIX } from "./tool-mapping.js";
+
+export const TOOL_EXECUTION_DENIED_MESSAGE =
+  "Tool execution is unavailable in this environment.";
+
+/** Prefix for MCP (Model Context Protocol) tool names. */
+export const MCP_PREFIX = "mcp__";
+
+interface ControlResponse {
+  type: "control_response";
+  request_id: string;
+  response: {
+    subtype: "success";
+    response: {
+      behavior: "allow" | "deny";
+      message?: string;
+    };
+  };
+}
+
+/**
+ * Handle a control_request from the Claude CLI.
+ *
+ * Denies custom MCP tools (mcp__custom-tools__*) so pi can execute them.
+ * Allows everything else (user MCP tools, internal Claude tools).
+ *
+ * @returns true if the tool was allowed, false if denied
+ */
+export function handleControlRequest(
+  msg: ClaudeControlRequest,
+  stdin: NodeJS.WritableStream,
+): boolean {
+  if (!msg.request_id || !msg.request) {
+    console.error(
+      "[pi-claude-cli] Malformed control_request: missing request_id or request object",
+      msg,
+    );
+    return false;
+  }
+
+  const toolName = msg.request?.tool_name ?? "";
+  const isCustomTool = toolName.startsWith(CUSTOM_TOOLS_MCP_PREFIX);
+
+  const response: ControlResponse = {
+    type: "control_response",
+    request_id: msg.request_id,
+    response: {
+      subtype: "success",
+      response: isCustomTool
+        ? { behavior: "deny", message: TOOL_EXECUTION_DENIED_MESSAGE }
+        : { behavior: "allow" },
+    },
+  };
+
+  stdin.write(JSON.stringify(response) + "\n");
+  return !isCustomTool;
+}