@vanillagreen/pi-claude-bridge 1.0.0

package/src/models.ts

@@ -0,0 +1,25 @@
+// Canonical selection + display order for the model picker.
+// `resolveModelId` returns the first partial match, so `opus` resolves to the first-listed opus entry.
+// Extracted from index.ts so tests can import without activating the extension.
+
+export const MODEL_IDS_IN_ORDER = ["claude-opus-4-7", "claude-opus-4-6", "claude-sonnet-4-6", "claude-haiku-4-5"];
+
+// Project pi-ai's model entries down to the fields pi's registerProvider expects,
+// and keep MODEL_IDS_IN_ORDER ordering. IDs missing from pi-ai are silently dropped.
+export function buildModels<T extends { id: string; [key: string]: any }>(piAiModels: T[]) {
+	return MODEL_IDS_IN_ORDER
+		.map((id) => piAiModels.find((m) => m.id === id))
+		.filter((m) => m != null)
+		// Forward thinkingLevelMap so per-model overrides (e.g. opus-4-7 mapping
+		// xhigh→xhigh instead of xhigh→max) are visible to the effort lookup.
+		.map(({ id, name, reasoning, input, contextWindow, maxTokens, thinkingLevelMap }) => ({
+			id, name, reasoning, input, contextWindow, maxTokens, thinkingLevelMap,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+		}));
+}
+
+export function resolveModelId(models: Array<{ id: string }>, input: string): string {
+	const lower = input.toLowerCase();
+	const match = models.find((m) => m.id === lower || m.id.includes(lower));
+	return match ? match.id : input;
+}

package/src/prompt-context.ts

@@ -0,0 +1,138 @@
+import { existsSync, readFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+
+export interface PromptContextSettings {
+	includeAppendSystemPromptMd?: boolean;
+	includeProjectAgentsHook?: boolean;
+	includeTaskPanelHook?: boolean;
+	includeCavemanHook?: boolean;
+}
+
+export interface PromptContextAppend {
+	text?: string;
+	labels: string[];
+}
+
+function piUserDir(): string {
+	const configured = process.env.PI_CODING_AGENT_DIR?.trim();
+	if (configured) return resolve(configured.replace(/^~(?=\/|$)/, homedir()));
+	return join(homedir(), ".pi", "agent");
+}
+
+function readTrimmed(path: string): string | undefined {
+	try {
+		if (!existsSync(path)) return undefined;
+		const content = readFileSync(path, "utf8").trim();
+		return content.length > 0 ? content : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function findProjectAppendSystem(startDir: string): string | undefined {
+	let current = resolve(startDir);
+	while (true) {
+		const candidate = join(current, ".pi", "APPEND_SYSTEM.md");
+		if (existsSync(candidate)) return candidate;
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return undefined;
+}
+
+export function readAppendSystemPromptFiles(cwd: string): Array<{ label: string; content: string }> {
+	const files: Array<{ label: string; path: string }> = [
+		{ label: "global APPEND_SYSTEM.md", path: join(piUserDir(), "APPEND_SYSTEM.md") },
+	];
+	const projectPath = findProjectAppendSystem(cwd);
+	if (projectPath) files.push({ label: "project .pi/APPEND_SYSTEM.md", path: projectPath });
+
+	const seen = new Set<string>();
+	const output: Array<{ label: string; content: string }> = [];
+	for (const file of files) {
+		if (seen.has(file.path)) continue;
+		seen.add(file.path);
+		const content = readTrimmed(file.path);
+		if (content) output.push({ label: file.label, content });
+	}
+	return output;
+}
+
+function splitPromptBlocks(systemPrompt?: string): string[] {
+	return (systemPrompt ?? "")
+		.split(/\n{2,}/)
+		.map((block) => block.trim())
+		.filter(Boolean);
+}
+
+function extractHeadingSection(systemPrompt: string | undefined, headings: string[]): string | undefined {
+	if (!systemPrompt) return undefined;
+	let start = -1;
+	for (const heading of headings) {
+		const index = systemPrompt.indexOf(heading);
+		if (index >= 0 && (start < 0 || index < start)) start = index;
+	}
+	if (start < 0) return undefined;
+	const rest = systemPrompt.slice(start).trim();
+	const nextHeading = rest.slice(1).search(/\n##\s+/);
+	return (nextHeading >= 0 ? rest.slice(0, nextHeading + 1) : rest).trim();
+}
+
+function extractBlockByMarkers(systemPrompt: string | undefined, markers: RegExp[]): string | undefined {
+	for (const block of splitPromptBlocks(systemPrompt)) {
+		if (markers.some((marker) => marker.test(block))) return block;
+	}
+	return undefined;
+}
+
+export function buildPromptContextAppend(systemPrompt: string | undefined, cwd: string, settings: PromptContextSettings): PromptContextAppend {
+	const parts: string[] = [];
+	const labels: string[] = [];
+
+	if (settings.includeAppendSystemPromptMd) {
+		for (const file of readAppendSystemPromptFiles(cwd)) {
+			parts.push(`### ${file.label}\n\n${file.content}`);
+			labels.push(file.label);
+		}
+	}
+
+	if (settings.includeProjectAgentsHook) {
+		const projectAgents = extractHeadingSection(systemPrompt, ["## Project Agents", "## Project Subagents"]);
+		if (projectAgents) {
+			parts.push(`### before_agent_start: project agents\n\n${projectAgents}`);
+			labels.push("project agents hook");
+		}
+	}
+
+	if (settings.includeTaskPanelHook) {
+		const taskReminder = extractBlockByMarkers(systemPrompt, [/^Task workflow reminder:/]);
+		if (taskReminder) {
+			parts.push(`### before_agent_start: task panel\n\n${taskReminder}`);
+			labels.push("task panel hook");
+		}
+	}
+
+	if (settings.includeCavemanHook) {
+		const caveman = extractBlockByMarkers(systemPrompt, [
+			/^Caveman communication mode active/m,
+			/^Token efficiency mode: terse smart caveman/m,
+			/^Caveman mode is active/m,
+		]);
+		if (caveman) {
+			parts.push(`### before_agent_start: caveman\n\n${caveman}`);
+			labels.push("caveman hook");
+		}
+	}
+
+	if (parts.length === 0) return { labels };
+	return {
+		labels,
+		text: [
+			"## Forwarded Pi Context",
+			"The following content was explicitly enabled in pi-claude-bridge settings and comes from Pi prompt files or before_agent_start prompt hooks.",
+			...parts,
+		].join("\n\n"),
+	};
+}

package/src/query-state.ts

@@ -0,0 +1,80 @@
+// Query state: QueryContext class + context stack.
+//
+// All per-query and per-turn mutable state lives here. Reentrant queries
+// (subagents) push the parent context onto a stack and get a fresh instance.
+// Adding a new field = one property on the class.
+//
+// Extracted from index.ts so tests can import without activating the extension.
+
+import type { AssistantMessage, AssistantMessageEventStream, Model } from "@mariozechner/pi-ai";
+import type { McpResult } from "./extract-tool-results.js";
+
+export interface PendingToolCall {
+	toolName: string;
+	resolve: (result: McpResult) => void;
+}
+
+export class QueryContext {
+	// Query-scoped (fully isolated per query)
+	activeQuery: unknown | null = null;
+	currentPiStream: AssistantMessageEventStream | null = null;
+	latestCursor = 0;
+	pendingToolCalls = new Map<string, PendingToolCall>();
+	pendingResults = new Map<string, McpResult>();
+	turnToolCallIds: string[] = [];
+	nextHandlerIdx = 0;
+	deferredUserMessages: string[] = [];
+
+	// Per-turn (reset together)
+	turnOutput: AssistantMessage | null = null;
+	turnStarted = false;
+	turnSawStreamEvent = false;
+	turnSawToolCall = false;
+
+	get turnBlocks(): Array<any> {
+		if (!this.turnOutput) throw new Error("turnBlocks accessed before resetTurnState");
+		return this.turnOutput.content;
+	}
+
+	resetTurnState(model: Model<any>): void {
+		this.turnOutput = {
+			role: "assistant", content: [],
+			api: model.api, provider: model.provider, model: model.id,
+			usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0,
+				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+			stopReason: "stop", timestamp: Date.now(),
+		};
+		this.turnStarted = false;
+		this.turnSawStreamEvent = false;
+		this.turnSawToolCall = false;
+		// turnToolCallIds and nextHandlerIdx are NOT reset — they persist across
+		// tool-result delivery callbacks within the same assistant message.
+	}
+}
+
+let _ctx = new QueryContext();
+const contextStack: QueryContext[] = [];
+
+export function ctx(): QueryContext { return _ctx; }
+
+export function stackDepth(): number { return contextStack.length; }
+
+export function pushContext(): void {
+	if (!_ctx.activeQuery) throw new Error("pushContext() called with no active query");
+	contextStack.push(_ctx);
+	_ctx = new QueryContext();
+}
+
+export function popContext(): void {
+	if (contextStack.length === 0) throw new Error("popContext() called with empty stack");
+	const parent = contextStack[contextStack.length - 1];
+	parent.deferredUserMessages.push(..._ctx.deferredUserMessages);
+	_ctx = contextStack.pop()!;
+}
+
+// Test-only: drop all state so test files can start from a clean module.
+// Not called from production.
+export function resetStack(): void {
+	_ctx = new QueryContext();
+	contextStack.length = 0;
+}

package/src/session-verify.ts

@@ -0,0 +1,38 @@
+// Pure session-file integrity check. Returns an array of warning strings;
+// callers decide how to surface them (debug log, piUI, diagDump, etc.).
+// Extracted from index.ts so tests can import without activating the extension.
+
+import { statSync, readFileSync } from "fs";
+
+export function verifyWrittenSession(jsonlPath: string, expectedSessionId: string, expectedRecordCount: number): string[] {
+	const warnings = [];
+	let st;
+	try {
+		st = statSync(jsonlPath);
+	} catch (e) {
+		warnings.push(`file missing after save — path=${jsonlPath} err=${e.message}`);
+		return warnings;
+	}
+	let content;
+	try {
+		content = readFileSync(jsonlPath, "utf8");
+	} catch (e) {
+		warnings.push(`file unreadable — path=${jsonlPath} size=${st.size} err=${e.message}`);
+		return warnings;
+	}
+	const lines = content.split("\n").filter((l) => l.trim().length > 0);
+	if (lines.length !== expectedRecordCount) {
+		warnings.push(`record count mismatch — expected=${expectedRecordCount} actual=${lines.length} path=${jsonlPath} bytes=${content.length}`);
+		return warnings;
+	}
+	try {
+		const firstRec = JSON.parse(lines[0]);
+		const lastRec = JSON.parse(lines[lines.length - 1]);
+		if (firstRec.sessionId !== expectedSessionId || lastRec.sessionId !== expectedSessionId) {
+			warnings.push(`sessionId drift — expected=${expectedSessionId} first=${firstRec.sessionId} last=${lastRec.sessionId}`);
+		}
+	} catch (e) {
+		warnings.push(`malformed JSONL — path=${jsonlPath} err=${e.message}`);
+	}
+	return warnings;
+}

package/src/skills.ts

@@ -0,0 +1,24 @@
+// Skills block extraction + MCP naming constants.
+// Extracted from index.ts so tests can import without activating the extension.
+
+export const MCP_SERVER_NAME = "custom-tools";
+export const MCP_TOOL_PREFIX = `mcp__${MCP_SERVER_NAME}__`;
+
+// Extract skills block from pi's system prompt for forwarding to Claude Code.
+export function extractSkillsBlock(systemPrompt?: string): string | undefined {
+	if (!systemPrompt) return undefined;
+	const startMarker = "The following skills provide specialized instructions for specific tasks.";
+	const endMarker = "</available_skills>";
+	const start = systemPrompt.indexOf(startMarker);
+	if (start === -1) return undefined;
+	const end = systemPrompt.indexOf(endMarker, start);
+	if (end === -1) return undefined;
+	return rewriteSkillsBlock(systemPrompt.slice(start, end + endMarker.length).trim());
+}
+
+export function rewriteSkillsBlock(skillsBlock: string): string {
+	return skillsBlock.replace(
+		"Use the read tool to load a skill's file",
+		`Use the read tool (mcp__${MCP_SERVER_NAME}__read) to load a skill's file`,
+	);
+}

package/src/typebox-to-zod.ts

@@ -0,0 +1,42 @@
+// TypeBox (JSON Schema) → Zod conversion used by buildMcpServers.
+//
+// Pi tools declare their parameters as TypeBox objects (i.e. JSON Schema at
+// runtime). The Agent SDK's createSdkMcpServer requires Zod — its internal
+// `Z0()` detects Zod via the `~standard` marker or `_def`/`_zod` properties
+// and silently downgrades unrecognized schemas to
+// `{type: "object", properties: {}}`, which leaves the model with no
+// parameter info. This module bridges the two so MCP-exposed pi tools retain
+// their schemas. If this breaks after an SDK update, check whether `Z0()`
+// detection changed or createSdkMcpServer now accepts raw JSON Schema.
+
+import { z } from "zod";
+
+export function jsonSchemaPropertyToZod(prop: Record<string, unknown>): z.ZodTypeAny {
+	let base: z.ZodTypeAny;
+	if (Array.isArray(prop.enum)) base = z.enum(prop.enum as [string, ...string[]]);
+	else switch (prop.type) {
+		case "string": base = z.string(); break;
+		case "number": case "integer": base = z.number(); break;
+		case "boolean": base = z.boolean(); break;
+		case "array": base = prop.items
+			? z.array(jsonSchemaPropertyToZod(prop.items as Record<string, unknown>))
+			: z.array(z.unknown()); break;
+		case "object": base = z.record(z.string(), z.unknown()); break;
+		default: base = z.unknown();
+	}
+	if (typeof prop.description === "string") base = base.describe(prop.description);
+	return base;
+}
+
+export function jsonSchemaToZodShape(schema: unknown): Record<string, z.ZodTypeAny> {
+	const s = schema as Record<string, unknown>;
+	if (!s || s.type !== "object" || !s.properties) return {};
+	const props = s.properties as Record<string, Record<string, unknown>>;
+	const required = new Set(Array.isArray(s.required) ? s.required as string[] : []);
+	const shape: Record<string, z.ZodTypeAny> = {};
+	for (const [key, prop] of Object.entries(props)) {
+		const zodProp = jsonSchemaPropertyToZod(prop);
+		shape[key] = required.has(key) ? zodProp : zodProp.optional();
+	}
+	return shape;
+}