@oh-my-pi/pi-coding-agent 8.0.20 → 8.2.0

package/src/lsp/utils.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { type Theme, theme } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
+import { type Theme, theme } from "../modes/theme/theme";
 import type {
 	Diagnostic,
 	DiagnosticSeverity,
@@ -232,7 +232,7 @@ export function severityToIcon(severity?: DiagnosticSeverity): string {
 function stripDiagnosticNoise(message: string): string {
 	return message
 		.split("\n")
-		.filter((line) => {
+		.filter(line => {
 			const trimmed = line.trim();
 			// Skip "for further information visit <url>" lines
 			if (trimmed.startsWith("for further information visit")) return false;
@@ -491,7 +491,7 @@ export function extractHoverText(
 	}
 
 	if (Array.isArray(contents)) {
-		return contents.map((c) => extractHoverText(c as string | { kind: string; value: string })).join("\n\n");
+		return contents.map(c => extractHoverText(c as string | { kind: string; value: string })).join("\n\n");
 	}
 
 	if (typeof contents === "object" && contents !== null) {

package/src/main.ts

@@ -4,32 +4,35 @@
  * This file handles CLI argument parsing and translates them into
  * createAgentSession() options. The SDK does the heavy lifting.
  */
-
-import { homedir, tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
-import { initTheme, stopThemeWatcher } from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
 import { postmortem } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { type Args, parseArgs, printHelp } from "./cli/args";
 import { parseConfigArgs, printConfigHelp, runConfigCommand } from "./cli/config-cli";
 import { processFileArguments } from "./cli/file-processor";
+import { parseJupyterArgs, printJupyterHelp, runJupyterCommand } from "./cli/jupyter-cli";
 import { listModels } from "./cli/list-models";
 import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
 import { selectSession } from "./cli/session-picker";
 import { parseSetupArgs, printSetupHelp, runSetupCommand } from "./cli/setup-cli";
 import { parseStatsArgs, printStatsHelp, runStatsCommand } from "./cli/stats-cli";
 import { parseUpdateArgs, printUpdateHelp, runUpdateCommand } from "./cli/update-cli";
+import { runCommitCommand } from "./commit";
+import { parseCommitArgs, printCommitHelp } from "./commit/cli";
 import { findConfigFile, getModelsPath, VERSION } from "./config";
 import type { ModelRegistry } from "./config/model-registry";
 import { parseModelPattern, parseModelString, resolveModelScope, type ScopedModel } from "./config/model-resolver";
 import { SettingsManager } from "./config/settings-manager";
 import { initializeWithSettings } from "./discovery";
-import { exportFromFile } from "./export/html/index";
+import { exportFromFile } from "./export/html";
 import type { ExtensionUIContext } from "./extensibility/extensions/types";
 import { runMigrations, showDeprecationWarnings } from "./migrations";
-import { InteractiveMode, runPrintMode, runRpcMode } from "./modes/index";
+import { InteractiveMode, runPrintMode, runRpcMode } from "./modes";
+import { initTheme, stopThemeWatcher } from "./modes/theme/theme";
 import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage, discoverModels } from "./sdk";
 import type { AgentSession } from "./session/agent-session";
 import { type SessionInfo, SessionManager } from "./session/session-manager";
@@ -85,7 +88,7 @@ async function runInteractiveMode(
 	initialMessages: string[],
 	setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
 	lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }> | undefined,
-	mcpManager: import("./mcp/index").MCPManager | undefined,
+	mcpManager: import("./mcp").MCPManager | undefined,
 	initialMessage?: string,
 	initialImages?: ImageContent[],
 ): Promise<void> {
@@ -94,7 +97,7 @@ async function runInteractiveMode(
 	await mode.init();
 
 	versionCheckPromise
-		.then((newVersion) => {
+		.then(newVersion => {
 			if (newVersion) {
 				mode.showNewVersionNotification(newVersion);
 			}
@@ -174,13 +177,17 @@ async function prepareInitialMessage(
 /**
  * Resolve a session argument to a local or global session match.
  */
-function resolveSessionMatch(sessionArg: string, cwd: string, sessionDir?: string): SessionInfo | undefined {
-	const sessions = SessionManager.list(cwd, sessionDir);
-	let matches = sessions.filter((session) => session.id.startsWith(sessionArg));
+async function resolveSessionMatch(
+	sessionArg: string,
+	cwd: string,
+	sessionDir?: string,
+): Promise<SessionInfo | undefined> {
+	const sessions = await SessionManager.list(cwd, sessionDir);
+	let matches = sessions.filter(session => session.id.startsWith(sessionArg));
 
 	if (matches.length === 0 && !sessionDir) {
-		const globalSessions = SessionManager.listAll();
-		matches = globalSessions.filter((session) => session.id.startsWith(sessionArg));
+		const globalSessions = await SessionManager.listAll();
+		matches = globalSessions.filter(session => session.id.startsWith(sessionArg));
 	}
 
 	return matches[0];
@@ -200,25 +207,25 @@ async function promptForkSession(session: SessionInfo): Promise<boolean> {
 	}
 }
 
-function getChangelogForDisplay(parsed: Args, settingsManager: SettingsManager): string | undefined {
+async function getChangelogForDisplay(parsed: Args, settingsManager: SettingsManager): Promise<string | undefined> {
 	if (parsed.continue || parsed.resume) {
 		return undefined;
 	}
 
 	const lastVersion = settingsManager.getLastChangelogVersion();
 	const changelogPath = getChangelogPath();
-	const entries = parseChangelog(changelogPath);
+	const entries = await parseChangelog(changelogPath);
 
 	if (!lastVersion) {
 		if (entries.length > 0) {
 			settingsManager.setLastChangelogVersion(VERSION);
-			return entries.map((e) => e.content).join("\n\n");
+			return entries.map(e => e.content).join("\n\n");
 		}
 	} else {
 		const newEntries = getNewEntries(entries, lastVersion);
 		if (newEntries.length > 0) {
 			settingsManager.setLastChangelogVersion(VERSION);
-			return newEntries.map((e) => e.content).join("\n\n");
+			return newEntries.map(e => e.content).join("\n\n");
 		}
 	}
 
@@ -234,12 +241,12 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 		if (sessionArg.includes("/") || sessionArg.includes("\\") || sessionArg.endsWith(".jsonl")) {
 			return await SessionManager.open(sessionArg, parsed.sessionDir);
 		}
-		const match = resolveSessionMatch(sessionArg, cwd, parsed.sessionDir);
+		const match = await resolveSessionMatch(sessionArg, cwd, parsed.sessionDir);
 		if (!match) {
 			throw new Error(`Session "${sessionArg}" not found.`);
 		}
-		const normalizedCwd = resolve(cwd);
-		const normalizedMatchCwd = resolve(match.cwd || cwd);
+		const normalizedCwd = path.resolve(cwd);
+		const normalizedMatchCwd = path.resolve(match.cwd || cwd);
 		if (normalizedCwd !== normalizedMatchCwd) {
 			const shouldFork = await promptForkSession(match);
 			if (!shouldFork) {
@@ -266,13 +273,13 @@ async function maybeAutoChdir(parsed: Args): Promise<void> {
 		return;
 	}
 
-	const home = homedir();
+	const home = os.homedir();
 	if (!home) {
 		return;
 	}
 
 	const normalizePath = (value: string) => {
-		const resolved = resolve(value);
+		const resolved = path.resolve(value);
 		return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 	};
 
@@ -282,16 +289,16 @@ async function maybeAutoChdir(parsed: Args): Promise<void> {
 		return;
 	}
 
-	const isDirectory = async (path: string) => {
+	const isDirectory = async (p: string) => {
 		try {
-			const stat = await Bun.file(path).stat();
-			return stat.isDirectory();
+			const s = await fs.stat(p);
+			return s.isDirectory();
 		} catch {
 			return false;
 		}
 	};
 
-	const candidates = [join(home, "tmp"), "/tmp", "/var/tmp"];
+	const candidates = [path.join(home, "tmp"), "/tmp", "/var/tmp"];
 	for (const candidate of candidates) {
 		try {
 			if (!(await isDirectory(candidate))) {
@@ -305,7 +312,7 @@ async function maybeAutoChdir(parsed: Args): Promise<void> {
 	}
 
 	try {
-		const fallback = tmpdir();
+		const fallback = os.tmpdir();
 		if (fallback && normalizePath(fallback) !== cwd && (await isDirectory(fallback))) {
 			process.chdir(fallback);
 		}
@@ -384,10 +391,10 @@ async function buildSessionOptions(
 			const parsedModel = parseModelString(remembered);
 			const rememberedModel = parsedModel
 				? scopedModels.find(
-						(scopedModel) =>
+						scopedModel =>
 							scopedModel.model.provider === parsedModel.provider && scopedModel.model.id === parsedModel.id,
 					)
-				: scopedModels.find((scopedModel) => scopedModel.model.id.toLowerCase() === remembered.toLowerCase());
+				: scopedModels.find(scopedModel => scopedModel.model.id.toLowerCase() === remembered.toLowerCase());
 			if (rememberedModel) {
 				options.model = rememberedModel.model;
 			}
@@ -412,7 +419,7 @@ async function buildSessionOptions(
 	// Scoped models for Ctrl+P cycling - fill in default thinking levels when not explicit
 	if (scopedModels.length > 0) {
 		const defaultThinkingLevel = settingsManager.getDefaultThinkingLevel() ?? "off";
-		options.scopedModels = scopedModels.map((scopedModel) => ({
+		options.scopedModels = scopedModels.map(scopedModel => ({
 			model: scopedModel.model,
 			thinkingLevel: scopedModel.explicitThinkingLevel
 				? (scopedModel.thinkingLevel ?? defaultThinkingLevel)
@@ -429,7 +436,7 @@ async function buildSessionOptions(
 	} else if (resolvedSystemPrompt) {
 		options.systemPrompt = resolvedSystemPrompt;
 	} else if (resolvedAppendPrompt) {
-		options.systemPrompt = (defaultPrompt) => `${defaultPrompt}\n\n${resolvedAppendPrompt}`;
+		options.systemPrompt = defaultPrompt => `${defaultPrompt}\n\n${resolvedAppendPrompt}`;
 	}
 
 	// Tools
@@ -475,7 +482,7 @@ export async function main(args: string[]) {
 
 	// Initialize theme early with defaults (CLI commands need symbols)
 	// Will be re-initialized with user preferences later
-	initTheme();
+	await initTheme();
 
 	// Handle plugin subcommand before regular parsing
 	const pluginCmd = parsePluginArgs(args);
@@ -521,6 +528,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle jupyter subcommand
+	const jupyterCmd = parseJupyterArgs(args);
+	if (jupyterCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printJupyterHelp();
+			return;
+		}
+		await runJupyterCommand(jupyterCmd);
+		return;
+	}
+
 	// Handle stats subcommand
 	const statsCmd = parseStatsArgs(args);
 	if (statsCmd) {
@@ -532,6 +550,17 @@ export async function main(args: string[]) {
 		return;
 	}
 
+	// Handle commit subcommand
+	const commitCmd = parseCommitArgs(args);
+	if (commitCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printCommitHelp();
+			return;
+		}
+		await runCommitCommand(commitCmd);
+		process.exit(0);
+	}
+
 	const parsed = parseArgs(args);
 	time("parseArgs");
 	await maybeAutoChdir(parsed);
@@ -541,7 +570,7 @@ export async function main(args: string[]) {
 
 	// Create AuthStorage and ModelRegistry upfront
 	const authStorage = await discoverAuthStorage();
-	const modelRegistry = await discoverModels(authStorage);
+	const modelRegistry = discoverModels(authStorage);
 	time("discoverModels");
 
 	if (parsed.version) {
@@ -606,7 +635,12 @@ export async function main(args: string[]) {
 		settingsManager.applyOverrides({ modelRoles: roleOverrides });
 	}
 
-	initTheme(settingsManager.getTheme(), isInteractive, settingsManager.getSymbolPreset());
+	await initTheme(
+		settingsManager.getTheme(),
+		isInteractive,
+		settingsManager.getSymbolPreset(),
+		settingsManager.getColorBlindMode(),
+	);
 	time("initTheme");
 
 	// Show deprecation warnings in interactive mode
@@ -627,7 +661,7 @@ export async function main(args: string[]) {
 
 	// Handle --resume: show session picker
 	if (parsed.resume) {
-		const sessions = SessionManager.list(cwd, parsed.sessionDir);
+		const sessions = await SessionManager.list(cwd, parsed.sessionDir);
 		time("SessionManager.list");
 		if (sessions.length === 0) {
 			writeStdout(chalk.dim("No sessions found"));
@@ -709,12 +743,12 @@ export async function main(args: string[]) {
 		await runRpcMode(session);
 	} else if (isInteractive) {
 		const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
-		const changelogMarkdown = getChangelogForDisplay(parsed, settingsManager);
+		const changelogMarkdown = await getChangelogForDisplay(parsed, settingsManager);
 
 		const scopedModelsForDisplay = sessionOptions.scopedModels ?? scopedModels;
 		if (scopedModelsForDisplay.length > 0) {
 			const modelList = scopedModelsForDisplay
-				.map((scopedModel) => {
+				.map(scopedModel => {
 					const thinkingStr = scopedModel.thinkingLevel !== "off" ? `:${scopedModel.thinkingLevel}` : "";
 					return `${scopedModel.model.id}${thinkingStr}`;
 				})

package/src/mcp/client.ts

@@ -3,7 +3,6 @@
  *
  * Handles connection initialization, tool listing, and tool calling.
  */
-
 import { createHttpTransport } from "./transports/http";
 import { createStdioTransport } from "./transports/stdio";
 import type {
@@ -39,11 +38,11 @@ function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promi
 	const { promise: wrapped, resolve, reject } = Promise.withResolvers<T>();
 	const timer = setTimeout(() => reject(new Error(message)), ms);
 	promise.then(
-		(value) => {
+		value => {
 			clearTimeout(timer);
 			resolve(value);
 		},
-		(error) => {
+		error => {
 			clearTimeout(timer);
 			reject(error);
 		},

package/src/mcp/config.ts

@@ -3,10 +3,9 @@
  *
  * Uses the capability system to load MCP servers from multiple sources.
  */
-
-import { mcpCapability } from "@oh-my-pi/pi-coding-agent/capability/mcp";
-import type { MCPServer } from "@oh-my-pi/pi-coding-agent/discovery";
-import { loadCapability } from "@oh-my-pi/pi-coding-agent/discovery";
+import { mcpCapability } from "../capability/mcp";
+import type { MCPServer } from "../discovery";
+import { loadCapability } from "../discovery";
 import type { MCPServerConfig } from "./types";
 
 /** Options for loading MCP configs */
@@ -86,7 +85,7 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 	// Filter out project-level configs if disabled
 	const servers = enableProjectConfig
 		? result.items
-		: result.items.filter((server) => server._source.level !== "project");
+		: result.items.filter(server => server._source.level !== "project");
 
 	// Convert to legacy format and preserve source metadata
 	const configs: Record<string, MCPServerConfig> = {};
@@ -130,7 +129,7 @@ export function isExaMCPServer(name: string, config: MCPServerConfig): boolean {
 	// Check by args for stdio servers (e.g., mcp-remote to exa)
 	if (!config.type || config.type === "stdio") {
 		const stdioConfig = config as { args?: string[] };
-		if (stdioConfig.args?.some((arg) => EXA_MCP_URL_PATTERN.test(arg))) {
+		if (stdioConfig.args?.some(arg => EXA_MCP_URL_PATTERN.test(arg))) {
 			return true;
 		}
 	}

package/src/mcp/json-rpc.ts

@@ -4,7 +4,6 @@
  * Lightweight utilities for calling MCP servers directly via HTTP
  * without maintaining persistent connections.
  */
-
 import { logger } from "@oh-my-pi/pi-utils";
 
 /** Parse SSE response format (lines starting with "data: ") */

package/src/mcp/loader.ts

@@ -3,10 +3,9 @@
  *
  * Integrates MCP tool discovery with the custom tools system.
  */
-
-import type { LoadedCustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
-import { AgentStorage } from "@oh-my-pi/pi-coding-agent/session/agent-storage";
 import { logger } from "@oh-my-pi/pi-utils";
+import type { LoadedCustomTool } from "../extensibility/custom-tools/types";
+import { AgentStorage } from "../session/agent-storage";
 import { type MCPLoadResult, MCPManager } from "./manager";
 import { MCPToolCache } from "./tool-cache";
 
@@ -36,10 +35,10 @@ export interface MCPToolsLoadOptions {
 	cacheStorage?: AgentStorage | null;
 }
 
-function resolveToolCache(storage: AgentStorage | null | undefined): MCPToolCache | null {
+async function resolveToolCache(storage: AgentStorage | null | undefined): Promise<MCPToolCache | null> {
 	if (storage === null) return null;
 	try {
-		const resolved = storage ?? AgentStorage.open();
+		const resolved = storage ?? (await AgentStorage.open());
 		return new MCPToolCache(resolved);
 	} catch (error) {
 		logger.warn("MCP tool cache unavailable", { error: String(error) });
@@ -55,7 +54,7 @@ function resolveToolCache(storage: AgentStorage | null | undefined): MCPToolCach
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult> {
-	const toolCache = resolveToolCache(options?.cacheStorage);
+	const toolCache = await resolveToolCache(options?.cacheStorage);
 	const manager = new MCPManager(cwd, toolCache);
 
 	let result: MCPLoadResult;
@@ -78,7 +77,7 @@ export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoa
 	}
 
 	// Convert MCP tools to LoadedCustomTool format
-	const loadedTools: LoadedCustomTool[] = result.tools.map((tool) => {
+	const loadedTools: LoadedCustomTool[] = result.tools.map(tool => {
 		// MCPTool and DeferredMCPTool have these properties
 		const mcpTool = tool as { mcpServerName?: string };
 		const serverName = mcpTool.mcpServerName;

package/src/mcp/manager.ts

@@ -4,10 +4,9 @@
  * Discovers, connects to, and manages MCP servers.
  * Handles tool loading and lifecycle.
  */
-
-import type { CustomTool } from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
+import type { CustomTool } from "../extensibility/custom-tools/types";
 import { connectToServer, disconnectServer, listTools } from "./client";
 import { loadAllMCPConfigs, validateServerConfig } from "./config";
 import type { MCPToolDetails } from "./tool-bridge";
@@ -34,11 +33,11 @@ const STARTUP_TIMEOUT_MS = 250;
 function trackPromise<T>(promise: Promise<T>): TrackedPromise<T> {
 	const tracked: TrackedPromise<T> = { promise, status: "pending" };
 	promise.then(
-		(value) => {
+		value => {
 			tracked.status = "fulfilled";
 			tracked.value = value;
 		},
-		(reason) => {
+		reason => {
 			tracked.status = "rejected";
 			tracked.reason = reason;
 		},
@@ -156,7 +155,7 @@ export class MCPManager {
 			}
 
 			const connectionPromise = connectToServer(name, config).then(
-				(connection) => {
+				connection => {
 					if (sources[name]) {
 						connection._source = sources[name];
 					}
@@ -166,7 +165,7 @@ export class MCPManager {
 					}
 					return connection;
 				},
-				(error) => {
+				error => {
 					if (this.pendingConnections.get(name) === connectionPromise) {
 						this.pendingConnections.delete(name);
 					}
@@ -175,7 +174,7 @@ export class MCPManager {
 			);
 			this.pendingConnections.set(name, connectionPromise);
 
-			const toolsPromise = connectionPromise.then(async (connection) => {
+			const toolsPromise = connectionPromise.then(async connection => {
 				const serverTools = await listTools(connection);
 				return { connection, serverTools };
 			});
@@ -192,7 +191,7 @@ export class MCPManager {
 					this.replaceServerTools(name, customTools);
 					void this.toolCache?.set(name, config, serverTools);
 				})
-				.catch((error) => {
+				.catch(error => {
 					if (this.pendingToolLoads.get(name) !== toolsPromise) return;
 					this.pendingToolLoads.delete(name);
 					if (!allowBackgroundLogging || reportedErrors.has(name)) return;
@@ -203,22 +202,22 @@ export class MCPManager {
 
 		// Notify about servers we're connecting to
 		if (connectionTasks.length > 0 && onConnecting) {
-			onConnecting(connectionTasks.map((task) => task.name));
+			onConnecting(connectionTasks.map(task => task.name));
 		}
 
 		if (connectionTasks.length > 0) {
 			await Promise.race([
-				Promise.allSettled(connectionTasks.map((task) => task.tracked.promise)),
+				Promise.allSettled(connectionTasks.map(task => task.tracked.promise)),
 				delay(STARTUP_TIMEOUT_MS),
 			]);
 
 			const cachedTools = new Map<string, MCPToolDefinition[]>();
-			const pendingTasks = connectionTasks.filter((task) => task.tracked.status === "pending");
+			const pendingTasks = connectionTasks.filter(task => task.tracked.status === "pending");
 
 			if (pendingTasks.length > 0) {
 				if (this.toolCache) {
 					await Promise.all(
-						pendingTasks.map(async (task) => {
+						pendingTasks.map(async task => {
 							const cached = await this.toolCache?.get(task.name, task.config);
 							if (cached) {
 								cachedTools.set(task.name, cached);
@@ -227,9 +226,9 @@ export class MCPManager {
 					);
 				}
 
-				const pendingWithoutCache = pendingTasks.filter((task) => !cachedTools.has(task.name));
+				const pendingWithoutCache = pendingTasks.filter(task => !cachedTools.has(task.name));
 				if (pendingWithoutCache.length > 0) {
-					await Promise.allSettled(pendingWithoutCache.map((task) => task.tracked.promise));
+					await Promise.allSettled(pendingWithoutCache.map(task => task.tracked.promise));
 				}
 			}
 
@@ -269,7 +268,7 @@ export class MCPManager {
 	}
 
 	private replaceServerTools(name: string, tools: CustomTool<TSchema, MCPToolDetails>[]): void {
-		this.tools = this.tools.filter((t) => !t.name.startsWith(`mcp_${name}_`));
+		this.tools = this.tools.filter(t => !t.name.startsWith(`mcp_${name}_`));
 		this.tools.push(...tools);
 	}
 
@@ -327,14 +326,14 @@ export class MCPManager {
 		}
 
 		// Remove tools from this server
-		this.tools = this.tools.filter((t) => !t.name.startsWith(`mcp_${name}_`));
+		this.tools = this.tools.filter(t => !t.name.startsWith(`mcp_${name}_`));
 	}
 
 	/**
 	 * Disconnect from all servers.
 	 */
 	async disconnectAll(): Promise<void> {
-		const promises = Array.from(this.connections.values()).map((conn) => disconnectServer(conn));
+		const promises = Array.from(this.connections.values()).map(conn => disconnectServer(conn));
 		await Promise.allSettled(promises);
 
 		this.pendingConnections.clear();
@@ -367,7 +366,7 @@ export class MCPManager {
 	 * Refresh tools from all servers.
 	 */
 	async refreshAllTools(): Promise<void> {
-		const promises = Array.from(this.connections.keys()).map((name) => this.refreshServerTools(name));
+		const promises = Array.from(this.connections.keys()).map(name => this.refreshServerTools(name));
 		await Promise.allSettled(promises);
 	}
 }

package/src/mcp/tool-bridge.ts

@@ -3,15 +3,10 @@
  *
  * Converts MCP tool definitions to CustomTool format for the agent.
  */
-
 import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type { SourceMeta } from "@oh-my-pi/pi-coding-agent/capability/types";
-import type {
-	CustomTool,
-	CustomToolContext,
-	CustomToolResult,
-} from "@oh-my-pi/pi-coding-agent/extensibility/custom-tools/types";
 import type { TSchema } from "@sinclair/typebox";
+import type { SourceMeta } from "../capability/types";
+import type { CustomTool, CustomToolContext, CustomToolResult } from "../extensibility/custom-tools/types";
 import { callTool } from "./client";
 import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types";
 
@@ -125,7 +120,7 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 
 	/** Create MCPTool instances for all tools from an MCP server connection */
 	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[]): MCPTool[] {
-		return tools.map((tool) => new MCPTool(connection, tool));
+		return tools.map(tool => new MCPTool(connection, tool));
 	}
 
 	constructor(
@@ -209,7 +204,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		getConnection: () => Promise<MCPServerConnection>,
 		source?: SourceMeta,
 	): DeferredMCPTool[] {
-		return tools.map((tool) => new DeferredMCPTool(serverName, tool, getConnection, source));
+		return tools.map(tool => new DeferredMCPTool(serverName, tool, getConnection, source));
 	}
 
 	constructor(

package/src/mcp/tool-cache.ts

@@ -3,9 +3,8 @@
  *
  * Stores tool definitions per server in agent.db for fast startup.
  */
-
-import type { AgentStorage } from "@oh-my-pi/pi-coding-agent/session/agent-storage";
 import { logger } from "@oh-my-pi/pi-utils";
+import type { AgentStorage } from "../session/agent-storage";
 import type { MCPServerConfig, MCPToolDefinition } from "./types";
 
 const CACHE_VERSION = 1;
@@ -24,7 +23,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 function stableClone(value: unknown): unknown {
 	if (Array.isArray(value)) {
-		return value.map((item) => stableClone(item));
+		return value.map(item => stableClone(item));
 	}
 	if (isRecord(value)) {
 		const sorted: Record<string, unknown> = {};

package/src/mcp/transports/http.ts

@@ -4,22 +4,20 @@
  * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
  * Based on MCP spec 2025-03-26.
  */
-
+import { readSseEvents } from "@oh-my-pi/pi-utils";
 import type {
 	JsonRpcMessage,
 	JsonRpcResponse,
 	MCPHttpServerConfig,
 	MCPSseServerConfig,
 	MCPTransport,
-} from "@oh-my-pi/pi-coding-agent/mcp/types";
+} from "../../mcp/types";
 
 /** Generate unique request ID */
 function generateId(): string {
 	return Math.random().toString(36).slice(2) + Date.now().toString(36);
 }
 
-import { readSseEvents } from "@oh-my-pi/pi-utils";
-
 /**
  * HTTP transport for MCP servers.
  * Uses POST for requests, supports SSE responses.

package/src/mcp/transports/stdio.ts

@@ -4,9 +4,8 @@
  * Implements JSON-RPC 2.0 over subprocess stdin/stdout.
  * Messages are newline-delimited JSON.
  */
-
-import type { JsonRpcResponse, MCPStdioServerConfig, MCPTransport } from "@oh-my-pi/pi-coding-agent/mcp/types";
 import { type Subprocess, spawn } from "bun";
+import type { JsonRpcResponse, MCPStdioServerConfig, MCPTransport } from "../../mcp/types";
 
 /** Generate unique request ID */
 function generateId(): string {