hob-bot 1.0.3 → 1.1.0

package/vendor/claude-bridge/src/attachments.ts

@@ -0,0 +1,135 @@
+// Carrying Claude Code's own attachments across a session rebuild.
+//
+// CC expands an `@file` mention itself — pi passes `@` through untouched — and
+// writes the expansion as a `type: "attachment"` record in its session file. pi
+// never sees it, so rebuilding a session from pi's history drops the file while
+// keeping the prompt text that referred to it: the model silently loses
+// something it was reasoning about, with nothing logged.
+//
+// Extracted from index.ts so tests can import it without activating the extension.
+
+import type { JsonlRecord, ImportAttachment } from "cc-session-io";
+import { messageContentToText } from "./convert.js";
+
+// Only `@file` expansions are carried. They are the one thing pi genuinely never
+// sees, so a rebuild is the only chance to keep them.
+//
+// `edited_text_file` is deliberately excluded even though it also carries file
+// content. CC writes one after editing a file, and the edit itself is already in
+// pi's history as a tool call and its result, so the attachment duplicates context
+// the rebuild reproduces anyway. It also usually hangs off a *tool result* record
+// rather than a prompt, which has no position in the ordinal scheme below — on
+// real sessions that left 81 of them unresolvable (see
+// diag/attachment-coverage.mjs). Half-carrying a kind is worse than not claiming
+// it: the ones that slipped through would be an arbitrary subset.
+//
+// Everything else CC rewrites every turn (`skill_listing`, `task_reminder`,
+// `agent_listing_delta`, `mcp_instructions_delta`, …) and loses nothing.
+const CONTENT_BEARING = new Set(["file"]);
+
+export type CarriedAttachment = {
+	attachment: { type: string; [key: string]: unknown };
+	/** Position of the parent among the session's text-bearing user records. */
+	userOrdinal: number;
+	/** That record's text, to verify the ordinal still points at the same turn. */
+	parentText: string;
+};
+
+type Rec = Record<string, unknown>;
+
+/** A user record holding a prompt, as opposed to one holding tool results. */
+function userPromptText(record: Rec): string | undefined {
+	if (record.type !== "user") return undefined;
+	const content = (record.message as Rec | undefined)?.content;
+	if (Array.isArray(content) && content.some((b) => (b as Rec)?.type === "tool_result")) return undefined;
+	const text = messageContentToText(content as never);
+	return text ? text : undefined;
+}
+
+/**
+ * Content-bearing attachments in a session, each tagged with where its parent
+ * sits among the text-bearing user records.
+ *
+ * The ordinal is the mapping key rather than the record index: a rebuild does not
+ * reproduce the old record list one-for-one — `importMessages` splits a message
+ * carrying tool results into two records, and CC appends records of its own — but
+ * the sequence of user prompts is the same conversation either way.
+ *
+ * Attachments also chain to one another, so an ordinal is resolved transitively up
+ * the parent links until it reaches a prompt. Most real attachments are
+ * `edited_text_file` records CC writes after editing a file, which have nothing to
+ * do with at-mentions; only their position in the conversation matters here.
+ */
+export function collectCarriedAttachments(records: readonly JsonlRecord[]): CarriedAttachment[] {
+	const ordinalOf = new Map<string, number>();
+	const textOf = new Map<string, string>();
+	let ordinal = 0;
+	const carried: CarriedAttachment[] = [];
+
+	for (const raw of records) {
+		const record = raw as Rec;
+		const prompt = userPromptText(record);
+		if (prompt !== undefined) {
+			ordinalOf.set(record.uuid as string, ordinal++);
+			textOf.set(record.uuid as string, prompt);
+			continue;
+		}
+		if (record.type !== "attachment") continue;
+		const parent = record.parentUuid as string | null;
+		// Attachments chain to each other — a run of them hangs off one prompt, and
+		// 63 of 179 in real sessions parent to another attachment rather than to a
+		// message. Inherit the ordinal so the whole run keys to the prompt that
+		// caused it. Recorded for every attachment, not just the ones carried, since
+		// a content-bearing one can chain off a `skill_listing` we ignore.
+		if (parent === null || !ordinalOf.has(parent)) continue;
+		const inherited = ordinalOf.get(parent)!;
+		ordinalOf.set(record.uuid as string, inherited);
+		textOf.set(record.uuid as string, textOf.get(parent)!);
+
+		const attachment = record.attachment as { type: string; [key: string]: unknown } | undefined;
+		if (!attachment || !CONTENT_BEARING.has(attachment.type)) continue;
+		carried.push({ attachment, userOrdinal: inherited, parentText: textOf.get(parent)! });
+	}
+	return carried;
+}
+
+/**
+ * Resolve each carried attachment to a position in the array about to be
+ * imported — the messages *after* conversion and repair, since that is the index
+ * space `importMessages` reads. Repair is idempotent, so an already-repaired array
+ * passes through its second run unchanged and the indices stay valid.
+ *
+ * Deliberately conservative: attaching a file to the wrong turn tells the model it
+ * saw something at a point it did not, which is worse than the loss this exists to
+ * prevent. So the ordinal has to land on a prompt whose text still matches; any
+ * disagreement is reported and dropped rather than approximated.
+ */
+export function placeCarriedAttachments(
+	carried: readonly CarriedAttachment[],
+	messages: readonly { role: string; content: unknown }[],
+): { attachments: ImportAttachment[]; skipped: string[] } {
+	const prompts: { index: number; text: string }[] = [];
+	messages.forEach((msg, index) => {
+		if (msg.role !== "user") return;
+		if (Array.isArray(msg.content) && msg.content.some((b) => (b as Rec)?.type === "tool_result")) return;
+		const text = messageContentToText(msg.content as never);
+		if (text) prompts.push({ index, text });
+	});
+
+	const attachments: ImportAttachment[] = [];
+	const skipped: string[] = [];
+	for (const item of carried) {
+		const name = String(item.attachment.filename ?? item.attachment.type);
+		const candidate = prompts[item.userOrdinal];
+		if (!candidate) {
+			skipped.push(`${name}: prompt #${item.userOrdinal} is no longer in history`);
+			continue;
+		}
+		if (candidate.text !== item.parentText) {
+			skipped.push(`${name}: prompt #${item.userOrdinal} changed`);
+			continue;
+		}
+		attachments.push({ afterIndex: candidate.index, attachment: item.attachment });
+	}
+	return { attachments, skipped };
+}

package/vendor/claude-bridge/src/config.ts

@@ -0,0 +1,105 @@
+// Hob loads only the bridge configuration written in its own engine directory.
+// Missing or unparseable files are reported and treated as an empty object.
+
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+
+export interface Config {
+	/** Date (YYYY-MM-DD) the one-time startup notice was shown. Written by the extension, not the user. */
+	startupNoticeShown?: string;
+	/** Date (YYYY-MM-DD) the AskClaude deprecation notice was shown. Written by the extension, not the user. */
+	askClaudeDeprecationShown?: string;
+	askClaude?: {
+		enabled?: boolean;
+		name?: string;
+		label?: string;
+		description?: string;
+		defaultMode?: "full" | "read" | "none";
+		defaultIsolated?: boolean;
+		allowFullMode?: boolean;
+		appendSkills?: boolean;
+	};
+	/** Low-level Claude Agent SDK plumbing. Most users won't need these. */
+	provider?: {
+		strictMcpConfig?: boolean;
+		autoMemoryEnabled?: boolean;
+		pathToClaudeCodeExecutable?: string;
+		// Subscription plan tier. Setting to "max" enables Opus 4.6 at 1M context
+		plan?: "pro" | "max";
+		// Set to true to opt into metered 1M context usage ("extra usage" in
+		// Anthropic billing). Enables Sonnet 4.6 [1m] on every plan and Opus 4.6
+		// [1m] on Pro.
+		longContextExtraUsage?: boolean;
+		// Model ids (e.g. "claude-future-9") whose declared 1M context Claude Code
+		// does not actually serve; pins them to the bare id at 200K.
+		forceTwoHundredK?: string[];
+	};
+}
+
+export function tryParseJson(path: string): Partial<Config> {
+	if (!existsSync(path)) return {};
+	try {
+		return JSON.parse(readFileSync(path, "utf-8"));
+	} catch (e) {
+		console.error(`claude-bridge: failed to parse ${path}: ${e}`);
+		return {};
+	}
+}
+
+export function claudeCodeSettings(provider: Config["provider"] = {}): { autoMemoryEnabled: boolean } {
+	return { autoMemoryEnabled: provider.autoMemoryEnabled ?? false };
+}
+
+export function globalConfigPath(): string {
+	return join(getAgentDir(), "claude-bridge.json");
+}
+
+/** Record today's date in the global config so the startup notice shows once, preserving every
+ *  other field. Returns the config path for display either way.
+ *
+ *  Parses directly rather than through tryParseJson, which reports an unparseable file as `{}`:
+ *  spreading that would replace a user's whole config with just this marker the first time they
+ *  leave a trailing comma in it. Losing the notice is the cheaper failure, so the write is
+ *  skipped and the notice simply shows again next session. */
+export function markStartupNoticeShown(): string {
+	const path = globalConfigPath();
+	let existing: Partial<Config> = {};
+	if (existsSync(path)) {
+		try {
+			existing = JSON.parse(readFileSync(path, "utf-8"));
+		} catch (e) {
+			console.error(`claude-bridge: leaving ${path} alone, it does not parse: ${e}`);
+			return path;
+		}
+	}
+	// en-CA renders YYYY-MM-DD in local time; toISOString() would report UTC.
+	const next = { ...existing, startupNoticeShown: new Date().toLocaleDateString("en-CA") };
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+	return path;
+}
+
+/** Record when the AskClaude deprecation notice was shown in the global config, preserving every
+ *  other field. Returns the config path either way. */
+export function markAskClaudeDeprecationNoticeShown(): string {
+	const path = globalConfigPath();
+	let existing: Partial<Config> = {};
+	if (existsSync(path)) {
+		try {
+			existing = JSON.parse(readFileSync(path, "utf-8"));
+		} catch (e) {
+			console.error(`claude-bridge: leaving ${path} alone, it does not parse: ${e}`);
+			return path;
+		}
+	}
+	// Match startupNoticeShown's local YYYY-MM-DD date format.
+	const next = { ...existing, askClaudeDeprecationShown: new Date().toLocaleDateString("en-CA") };
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
+	return path;
+}
+
+export function loadConfig(_cwd: string): Config {
+	return tryParseJson(globalConfigPath());
+}

package/vendor/claude-bridge/src/convert.ts

@@ -0,0 +1,222 @@
+// Pure pi→Anthropic message conversion helpers.
+// Extracted so they can be tested without pulling in the full extension runtime.
+
+import type { Message as PiMessage } from "@earendil-works/pi-ai";
+import type { Message as SessionMessage } from "cc-session-io";
+import { pascalCase } from "change-case";
+import { MCP_TOOL_PREFIX } from "./skills.js";
+
+export const PROVIDER_ID = "claude-bridge";
+
+// Pi tool names under Claude Code's builtin names. Only ever correct on the
+// AskClaude path, where CC runs its own tools — see mapPiToolNameToSdk.
+export const PI_TO_SDK_TOOL_NAME: Record<string, string> = {
+	read: "Read", write: "Write", edit: "Edit", bash: "Bash",
+};
+
+export function sanitizeToolId(id: string, cache: Map<string, string>): string {
+	const existing = cache.get(id);
+	if (existing) return existing;
+	const clean = id.replace(/[^a-zA-Z0-9_-]/g, "_");
+	cache.set(id, clean);
+	return clean;
+}
+
+/** A pi tool name as the name a rebuilt transcript has to call it by.
+ *
+ *  Whether a map is passed is what distinguishes the two query shapes, because
+ *  they need opposite answers:
+ *
+ *  - **With a map — the provider path.** The query runs `tools: []`, so every
+ *    tool Claude can call is a pi tool served over MCP, and its name is
+ *    `mcp__custom-tools__<pi name>` by construction (resolveMcpTools). The map
+ *    is consulted first only because it carries the served tool's exact casing.
+ *    A name it lacks is a tool pi ran that we do not serve now — AskClaude,
+ *    excluded on purpose, or an extension since disabled — and naming that after
+ *    a Claude Code builtin would tell the model a builtin it cannot call is
+ *    available and was already used. That is the prompt condition behind the
+ *    phantom-call deadlock fixed in 122914dd, and the read direction refuses the
+ *    same names for the same reason (piToolNameFor in index.ts).
+ *  - **Without a map — the AskClaude path.** CC runs its own tools there, so
+ *    builtin names are real, matching mapToolName in the other direction.
+ */
+export function mapPiToolNameToSdk(name: string, customToolNameToSdk?: Map<string, string>): string {
+	if (!name) return "";
+	const normalized = name.toLowerCase();
+	// Pi history holds pi tool names. Our own SDK prefix can only reach here by
+	// feeding already-converted names back through the conversion, and prefixing
+	// twice invents a tool nobody serves.
+	if (normalized.startsWith(MCP_TOOL_PREFIX)) {
+		throw new Error(`mapPiToolNameToSdk: "${name}" is already an SDK tool name — pi history holds pi tool names`);
+	}
+	if (!customToolNameToSdk) return PI_TO_SDK_TOOL_NAME[normalized] ?? pascalCase(name);
+	return customToolNameToSdk.get(name) ?? customToolNameToSdk.get(normalized) ?? `${MCP_TOOL_PREFIX}${name}`;
+}
+
+export function messageContentToText(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+	const parts = [];
+	let hasText = false;
+	for (const block of content) {
+		if (block.type === "text" && block.text) { parts.push(block.text); hasText = true; }
+		else if (block.type !== "text" && block.type !== "image") { parts.push(`[${block.type}]`); }
+	}
+	return hasText ? parts.join("\n") : "";
+}
+
+// Tool results are flattened to text, which is how Claude Code stores most of
+// them. Images are the exception: they have no text form, so a result carrying
+// one keeps the block array shape instead (also what CC writes for screenshots).
+function toolResultContent(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): string | Array<Record<string, unknown>> {
+	if (typeof content === "string" || !Array.isArray(content)) return messageContentToText(content) || "";
+	const images = content.filter((b) => b.type === "image" && b.data && b.mimeType);
+	if (!images.length) return messageContentToText(content) || "";
+	const blocks: Array<Record<string, unknown>> = [];
+	for (const block of content) {
+		if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+		else if (block.type === "image" && block.data && block.mimeType) {
+			blocks.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+		} else if (block.type !== "text" && block.type !== "image") {
+			// Same marker messageContentToText leaves for unrecognized blocks, so the
+			// text and image paths describe an extension's output the same way.
+			blocks.push({ type: "text", text: `[${block.type}]` });
+		}
+	}
+	return blocks;
+}
+
+/** What convertPiMessages discarded, for the debug line in index.ts. */
+export type DroppedContent = {
+	thinking: number;
+	abortedTurns: number;
+	providers: Set<string>;
+	other: Map<string, number>;
+};
+
+/** Convert pi message array to Anthropic API format. */
+export function convertPiMessages(
+	messages: PiMessage[],
+	customToolNameToSdk?: Map<string, string>,
+): { anthropicMessages: SessionMessage[]; sanitizedIds: Map<string, string>; dropped: DroppedContent } {
+	const anthropicMessages = [];
+	const sanitizedIds = new Map();
+	// What conversion discarded. Nothing downstream can tell: a stripped thinking
+	// block and a message that never carried one convert to the same thing, so
+	// without this the loss is invisible in the log and in a captured request.
+	const dropped: DroppedContent = { thinking: 0, abortedTurns: 0, providers: new Set(), other: new Map() };
+	// The user message collecting this assistant turn's tool results, if one has
+	// been emitted yet, and the index of the assistant message it belongs to. Both
+	// are cleared at every assistant message — see the toolResult branch.
+	let turnResults: { role: "user"; content: Array<Record<string, unknown>> } | null = null;
+	let turnAssistantIdx: number | null = null;
+
+	for (const msg of messages) {
+		if (msg.role === "user") {
+			if (typeof msg.content === "string") {
+				anthropicMessages.push({ role: "user", content: msg.content || "[empty]" });
+			} else if (Array.isArray(msg.content)) {
+				const parts = [];
+				for (const block of msg.content) {
+					if (block.type === "text" && block.text) parts.push({ type: "text", text: block.text });
+					else if (block.type === "image" && block.data && block.mimeType) {
+						parts.push({ type: "image", source: { type: "base64", media_type: block.mimeType, data: block.data } });
+					}
+				}
+				anthropicMessages.push({ role: "user", content: parts.length ? parts : "[image]" });
+			} else {
+				anthropicMessages.push({ role: "user", content: "[empty]" });
+			}
+		} else if (msg.role === "assistant") {
+			const content = Array.isArray(msg.content) ? msg.content : [];
+			const blocks = [];
+			for (const block of content) {
+				if (block.type === "text" && block.text) {
+					blocks.push({ type: "text", text: block.text });
+				} else if (block.type === "thinking") {
+					// Only replay thinking Claude Code itself produced. A signature minted
+					// by any other provider — including pi's own Anthropic provider — is
+					// not ours to hand back, and Anthropic rejects ones it can't verify.
+					const sig = block.thinkingSignature;
+					if (msg.provider === PROVIDER_ID && sig) {
+						blocks.push({ type: "thinking", thinking: block.thinking ?? "", signature: sig });
+					} else {
+						dropped.thinking++;
+						dropped.providers.add(msg.provider ?? "unknown");
+					}
+				} else if (block.type === "toolCall") {
+					const toolName = mapPiToolNameToSdk(block.name, customToolNameToSdk);
+					blocks.push({ type: "tool_use", id: sanitizeToolId(block.id, sanitizedIds), name: toolName, input: block.arguments ?? {} });
+				} else {
+					dropped.other.set(block.type, (dropped.other.get(block.type) ?? 0) + 1);
+				}
+			}
+			// A turn the user aborted before anything streamed carries no content at
+			// all. Standing a placeholder in its place invents a reply the assistant
+			// never made, and because it lands early in the prefix it costs the whole
+			// downstream prompt cache every time the session is rebuilt. Drop it:
+			// Session.importMessages imposes no alternation, and a turn with no blocks
+			// has no tool_use ids needing a synthetic result. Left before the turn
+			// bookkeeping so a stray result still attaches to the last assistant
+			// message actually emitted.
+			//
+			// Do NOT clear turnResults/turnAssistantIdx here. It looks like the tidy
+			// thing to do, but an abort between two parallel results — assistant[X,Y],
+			// R_X, aborted turn, R_Y — would then start a second results message for
+			// R_Y. repairToolPairing consumes both pending ids at the first one, stubs
+			// Y there and drops the real R_Y as unmatched, destroying the parallel
+			// result this merge exists to preserve. unit-import.mjs pins the shape.
+			if (!content.length) { dropped.abortedTurns++; continue; }
+			// Blocks were present but every one was filtered — content really was
+			// dropped here, so keep the slot and say so. Empty content is rejected by
+			// the API, and dropping the message would break tool pairing.
+			if (!blocks.length) blocks.push({ type: "text", text: "[incompatible content omitted]" });
+			turnResults = null;
+			turnAssistantIdx = anthropicMessages.length;
+			anthropicMessages.push({ role: "assistant", content: blocks });
+		} else if (msg.role === "toolResult") {
+			// Pi records one message per tool result, and repairToolPairing only
+			// pairs results that share the user message directly after their
+			// assistant message. Split across messages, the second and later results
+			// match no pending tool_use id: they are dropped and replaced with a
+			// synthetic "[no tool result recorded]", so every rebuild silently
+			// destroyed the output of parallel tool calls. Session.importMessages
+			// applies the repair itself, so this cannot be opted out of by skipping
+			// our own call. (Claude Code's live writer splits a turn across records
+			// — one per content block, one per result — so the single-message shape
+			// is repairToolPairing's requirement, not a copy of CC's own layout;
+			// tests/int-cc-contracts.mjs pins both facts.)
+			//
+			// Collecting into the turn's first result message rather than the
+			// immediately preceding one also handles a steer landing mid-execution,
+			// which pi records between the results (see extractAllToolResults).
+			// The results also have to sit *directly* after their assistant message:
+			// repairToolPairing consumes the turn's pending ids at the first user
+			// message that follows it, so a steer arriving before the first result —
+			// what any steer during a slow first tool looks like — would otherwise
+			// take the stubs and strand every real result behind it.
+			//
+			// Both hoists reorder the steer against wall-clock: Claude sees results
+			// that were still running when the steer arrived. Claude Code normalizes
+			// to the same order — it records a mid-turn steer as an `attachment`, and
+			// reorderAttachmentsForAPI (claude-code-rip src/utils/messages.ts:1481)
+			// bubbles attachments up to the nearest assistant or tool_result message
+			// and re-inserts them after it. The on-disk form differs, the order does not.
+			const block = { type: "tool_result", tool_use_id: sanitizeToolId(msg.toolCallId, sanitizedIds), content: toolResultContent(msg.content), is_error: msg.isError };
+			if (turnResults) {
+				turnResults.content.push(block);
+			} else {
+				turnResults = { role: "user", content: [block] };
+				// A result with no assistant message before it is malformed history;
+				// appending keeps it in order for repairToolPairing to discard.
+				anthropicMessages.splice(turnAssistantIdx === null ? anthropicMessages.length : turnAssistantIdx + 1, 0, turnResults);
+			}
+		}
+	}
+
+	return { anthropicMessages, sanitizedIds, dropped };
+}

package/vendor/claude-bridge/src/extract-tool-results.ts

@@ -0,0 +1,47 @@
+// Tool-result extraction: walks the context tail to collect this turn's
+// tool results. Pi appends results to context and calls the provider again;
+// this scrapes them back out. Walks past user messages (steer/followUp) that
+// pi may inject between toolResults. Stops at the nearest assistant message
+// (turn boundary).
+// Extracted from index.ts so tests can import without activating the extension.
+
+export type McpContent = Array<
+	| { type: "text"; text: string }
+	| { type: "image"; data: string; mimeType: string }
+>;
+
+export interface McpResult {
+	content: McpContent;
+	isError?: boolean;
+	toolCallId?: string;
+	[key: string]: unknown;
+}
+
+export function toolResultToMcpContent(
+	content: string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>,
+): McpContent {
+	if (typeof content === "string") return [{ type: "text", text: content || "" }];
+	if (!Array.isArray(content)) return [{ type: "text", text: "" }];
+	const blocks: McpContent = [];
+	for (const block of content) {
+		if (block.type === "text" && block.text) blocks.push({ type: "text", text: block.text });
+		else if (block.type === "image" && block.data && block.mimeType) blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+	}
+	return blocks.length ? blocks : [{ type: "text", text: "" }];
+}
+
+// Returns { results, stopIdx } so callers can log the walk boundary.
+export function extractAllToolResults(
+	messages: Array<{ role: string; content?: unknown; toolCallId?: string; isError?: boolean; [key: string]: unknown }>,
+): { results: McpResult[]; stopIdx: number } {
+	const results: McpResult[] = [];
+	let stopIdx = -1;
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const msg = messages[i];
+		if (msg.role === "toolResult") {
+			results.unshift({ content: toolResultToMcpContent(msg.content as string | Array<{ type: string; text?: string; data?: string; mimeType?: string }>), isError: msg.isError, toolCallId: msg.toolCallId });
+		} else if (msg.role === "assistant") { stopIdx = i; break; }
+		// user messages: skip (steer/followUp injected mid-tool-execution)
+	}
+	return { results, stopIdx };
+}