@oh-my-pi/pi-coding-agent 1.337.1 → 1.340.0

package/src/core/mcp/types.ts

@@ -41,8 +41,14 @@ export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcRespo
 // MCP Server Configuration (.mcp.json format)
 // =============================================================================
 
+/** Base server config with shared options */
+interface MCPServerConfigBase {
+	/** Connection timeout in milliseconds (default: 30000) */
+	timeout?: number;
+}
+
 /** Stdio server configuration */
-export interface MCPStdioServerConfig {
+export interface MCPStdioServerConfig extends MCPServerConfigBase {
 	type?: "stdio"; // Default if not specified
 	command: string;
 	args?: string[];
@@ -51,14 +57,14 @@ export interface MCPStdioServerConfig {
 }
 
 /** HTTP server configuration (Streamable HTTP transport) */
-export interface MCPHttpServerConfig {
+export interface MCPHttpServerConfig extends MCPServerConfigBase {
 	type: "http";
 	url: string;
 	headers?: Record<string, string>;
 }
 
 /** SSE server configuration (deprecated, use HTTP) */
-export interface MCPSseServerConfig {
+export interface MCPSseServerConfig extends MCPServerConfigBase {
 	type: "sse";
 	url: string;
 	headers?: Record<string, string>;

package/src/core/sdk.ts

@@ -596,10 +596,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let mcpManager: MCPManager | undefined;
 	const enableMCP = options.enableMCP ?? true;
 	if (enableMCP) {
-		const mcpResult = await discoverAndLoadMCPTools(cwd);
+		const mcpResult = await discoverAndLoadMCPTools(cwd, {
+			onConnecting: (serverNames) => {
+				if (options.hasUI && serverNames.length > 0) {
+					process.stderr.write(`\x1b[90mConnecting to MCP servers: ${serverNames.join(", ")}...\x1b[0m\n`);
+				}
+			},
+			enableProjectConfig: settingsManager.getMCPProjectConfigEnabled(),
+			// Always filter Exa - we have native integration
+			filterExa: true,
+		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
 
+		// If we extracted Exa API keys from MCP configs and EXA_API_KEY isn't set, use the first one
+		if (mcpResult.exaApiKeys.length > 0 && !process.env.EXA_API_KEY) {
+			process.env.EXA_API_KEY = mcpResult.exaApiKeys[0];
+		}
+
 		// Log MCP errors
 		for (const { path, error } of mcpResult.errors) {
 			console.error(`MCP "${path}": ${error}`);
@@ -664,8 +678,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let allToolsArray: Tool[] = [...builtInTools, ...wrappedCustomTools];
 	time("combineTools");
 
-	// Apply bash interception to redirect common shell patterns to proper tools
-	allToolsArray = applyBashInterception(allToolsArray);
+	// Apply bash interception to redirect common shell patterns to proper tools (if enabled)
+	if (settingsManager.getBashInterceptorEnabled()) {
+		allToolsArray = applyBashInterception(allToolsArray);
+	}
 	time("applyBashInterception");
 
 	if (hookRunner) {

package/src/core/settings-manager.ts

@@ -43,6 +43,14 @@ export interface ExaSettings {
 	enableWebsets?: boolean; // default: false
 }
 
+export interface BashInterceptorSettings {
+	enabled?: boolean; // default: false (blocks shell commands that have dedicated tools)
+}
+
+export interface MCPSettings {
+	enableProjectConfig?: boolean; // default: true (load .mcp.json from project root)
+}
+
 export interface Settings {
 	lastChangelogVersion?: string;
 	defaultProvider?: string;
@@ -62,6 +70,8 @@ export interface Settings {
 	terminal?: TerminalSettings;
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
 	exa?: ExaSettings;
+	bashInterceptor?: BashInterceptorSettings;
+	mcp?: MCPSettings;
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -440,4 +450,28 @@ export class SettingsManager {
 		this.globalSettings.exa.enableWebsets = enabled;
 		this.save();
 	}
+
+	getBashInterceptorEnabled(): boolean {
+		return this.settings.bashInterceptor?.enabled ?? false;
+	}
+
+	setBashInterceptorEnabled(enabled: boolean): void {
+		if (!this.globalSettings.bashInterceptor) {
+			this.globalSettings.bashInterceptor = {};
+		}
+		this.globalSettings.bashInterceptor.enabled = enabled;
+		this.save();
+	}
+
+	getMCPProjectConfigEnabled(): boolean {
+		return this.settings.mcp?.enableProjectConfig ?? true;
+	}
+
+	setMCPProjectConfigEnabled(enabled: boolean): void {
+		if (!this.globalSettings.mcp) {
+			this.globalSettings.mcp = {};
+		}
+		this.globalSettings.mcp.enableProjectConfig = enabled;
+		this.save();
+	}
 }

package/src/modes/interactive/components/settings-defs.ts

@@ -0,0 +1,229 @@
+/**
+ * Declarative settings definitions.
+ *
+ * Each setting is defined once here and the UI is generated automatically.
+ * To add a new setting:
+ * 1. Add it to SettingsManager (getter/setter)
+ * 2. Add the definition here
+ * 3. Add the handler in interactive-mode.ts settingsHandlers
+ */
+
+import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import { getCapabilities } from "@oh-my-pi/pi-tui";
+import type { SettingsManager } from "../../../core/settings-manager.js";
+
+// Setting value types
+export type SettingValue = boolean | string;
+
+// Base definition for all settings
+interface BaseSettingDef {
+	id: string;
+	label: string;
+	description: string;
+	tab: "config" | "exa";
+}
+
+// Boolean toggle setting
+export interface BooleanSettingDef extends BaseSettingDef {
+	type: "boolean";
+	get: (sm: SettingsManager) => boolean;
+	set: (sm: SettingsManager, value: boolean) => void;
+	/** If provided, setting is only shown when this returns true */
+	condition?: () => boolean;
+}
+
+// Enum setting (inline toggle between values)
+export interface EnumSettingDef extends BaseSettingDef {
+	type: "enum";
+	values: readonly string[];
+	get: (sm: SettingsManager) => string;
+	set: (sm: SettingsManager, value: string) => void;
+}
+
+// Submenu setting (opens a selection list)
+export interface SubmenuSettingDef extends BaseSettingDef {
+	type: "submenu";
+	get: (sm: SettingsManager) => string;
+	set: (sm: SettingsManager, value: string) => void;
+	/** Get available options dynamically */
+	getOptions: (sm: SettingsManager) => Array<{ value: string; label: string; description?: string }>;
+	/** Called when selection changes (for preview) */
+	onPreview?: (value: string) => void;
+	/** Called when submenu is cancelled (to restore preview) */
+	onPreviewCancel?: (originalValue: string) => void;
+}
+
+export type SettingDef = BooleanSettingDef | EnumSettingDef | SubmenuSettingDef;
+
+const THINKING_DESCRIPTIONS: Record<ThinkingLevel, string> = {
+	off: "No reasoning",
+	minimal: "Very brief reasoning (~1k tokens)",
+	low: "Light reasoning (~2k tokens)",
+	medium: "Moderate reasoning (~8k tokens)",
+	high: "Deep reasoning (~16k tokens)",
+	xhigh: "Maximum reasoning (~32k tokens)",
+};
+
+/**
+ * All settings definitions.
+ * Order determines display order within each tab.
+ */
+export const SETTINGS_DEFS: SettingDef[] = [
+	// Config tab
+	{
+		id: "autoCompact",
+		tab: "config",
+		type: "boolean",
+		label: "Auto-compact",
+		description: "Automatically compact context when it gets too large",
+		get: (sm) => sm.getCompactionEnabled(),
+		set: (sm, v) => sm.setCompactionEnabled(v), // Also handled in session
+	},
+	{
+		id: "showImages",
+		tab: "config",
+		type: "boolean",
+		label: "Show images",
+		description: "Render images inline in terminal",
+		get: (sm) => sm.getShowImages(),
+		set: (sm, v) => sm.setShowImages(v),
+		condition: () => !!getCapabilities().images,
+	},
+	{
+		id: "queueMode",
+		tab: "config",
+		type: "enum",
+		label: "Queue mode",
+		description: "How to process queued messages while agent is working",
+		values: ["one-at-a-time", "all"],
+		get: (sm) => sm.getQueueMode(),
+		set: (sm, v) => sm.setQueueMode(v as "all" | "one-at-a-time"), // Also handled in session
+	},
+	{
+		id: "hideThinking",
+		tab: "config",
+		type: "boolean",
+		label: "Hide thinking",
+		description: "Hide thinking blocks in assistant responses",
+		get: (sm) => sm.getHideThinkingBlock(),
+		set: (sm, v) => sm.setHideThinkingBlock(v),
+	},
+	{
+		id: "collapseChangelog",
+		tab: "config",
+		type: "boolean",
+		label: "Collapse changelog",
+		description: "Show condensed changelog after updates",
+		get: (sm) => sm.getCollapseChangelog(),
+		set: (sm, v) => sm.setCollapseChangelog(v),
+	},
+	{
+		id: "bashInterceptor",
+		tab: "config",
+		type: "boolean",
+		label: "Bash interceptor",
+		description: "Block shell commands that have dedicated tools (grep, cat, etc.)",
+		get: (sm) => sm.getBashInterceptorEnabled(),
+		set: (sm, v) => sm.setBashInterceptorEnabled(v),
+	},
+	{
+		id: "mcpProjectConfig",
+		tab: "config",
+		type: "boolean",
+		label: "MCP project config",
+		description: "Load .mcp.json/mcp.json from project root",
+		get: (sm) => sm.getMCPProjectConfigEnabled(),
+		set: (sm, v) => sm.setMCPProjectConfigEnabled(v),
+	},
+	{
+		id: "thinkingLevel",
+		tab: "config",
+		type: "submenu",
+		label: "Thinking level",
+		description: "Reasoning depth for thinking-capable models",
+		get: (sm) => sm.getDefaultThinkingLevel() ?? "off",
+		set: (sm, v) => sm.setDefaultThinkingLevel(v as ThinkingLevel), // Also handled in session
+		getOptions: () =>
+			(["off", "minimal", "low", "medium", "high", "xhigh"] as ThinkingLevel[]).map((level) => ({
+				value: level,
+				label: level,
+				description: THINKING_DESCRIPTIONS[level],
+			})),
+	},
+	{
+		id: "theme",
+		tab: "config",
+		type: "submenu",
+		label: "Theme",
+		description: "Color theme for the interface",
+		get: (sm) => sm.getTheme() ?? "dark",
+		set: (sm, v) => sm.setTheme(v),
+		getOptions: () => [], // Filled dynamically from context
+	},
+
+	// Exa tab
+	{
+		id: "exaEnabled",
+		tab: "exa",
+		type: "boolean",
+		label: "Exa enabled",
+		description: "Master toggle for all Exa search tools",
+		get: (sm) => sm.getExaSettings().enabled,
+		set: (sm, v) => sm.setExaEnabled(v),
+	},
+	{
+		id: "exaSearch",
+		tab: "exa",
+		type: "boolean",
+		label: "Exa search",
+		description: "Basic search, deep search, code search, crawl",
+		get: (sm) => sm.getExaSettings().enableSearch,
+		set: (sm, v) => sm.setExaSearchEnabled(v),
+	},
+	{
+		id: "exaLinkedin",
+		tab: "exa",
+		type: "boolean",
+		label: "Exa LinkedIn",
+		description: "Search LinkedIn for people and companies",
+		get: (sm) => sm.getExaSettings().enableLinkedin,
+		set: (sm, v) => sm.setExaLinkedinEnabled(v),
+	},
+	{
+		id: "exaCompany",
+		tab: "exa",
+		type: "boolean",
+		label: "Exa company",
+		description: "Comprehensive company research tool",
+		get: (sm) => sm.getExaSettings().enableCompany,
+		set: (sm, v) => sm.setExaCompanyEnabled(v),
+	},
+	{
+		id: "exaResearcher",
+		tab: "exa",
+		type: "boolean",
+		label: "Exa researcher",
+		description: "AI-powered deep research tasks",
+		get: (sm) => sm.getExaSettings().enableResearcher,
+		set: (sm, v) => sm.setExaResearcherEnabled(v),
+	},
+	{
+		id: "exaWebsets",
+		tab: "exa",
+		type: "boolean",
+		label: "Exa websets",
+		description: "Webset management and enrichment tools",
+		get: (sm) => sm.getExaSettings().enableWebsets,
+		set: (sm, v) => sm.setExaWebsetsEnabled(v),
+	},
+];
+
+/** Get settings for a specific tab */
+export function getSettingsForTab(tab: "config" | "exa"): SettingDef[] {
+	return SETTINGS_DEFS.filter((def) => def.tab === tab);
+}
+
+/** Get a setting definition by id */
+export function getSettingDef(id: string): SettingDef | undefined {
+	return SETTINGS_DEFS.find((def) => def.id === id);
+}