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

package/src/core/model-resolver.ts

@@ -6,8 +6,8 @@ import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { type Api, type KnownProvider, type Model, modelsAreEqual } from "@oh-my-pi/pi-ai";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
-import { isValidThinkingLevel } from "../cli/args.js";
-import type { ModelRegistry } from "./model-registry.js";
+import { isValidThinkingLevel } from "../cli/args";
+import type { ModelRegistry } from "./model-registry";
 
 /** Default model IDs for each known provider */
 export const defaultModelPerProvider: Record<KnownProvider, string> = {
@@ -30,6 +30,29 @@ export interface ScopedModel {
 	thinkingLevel: ThinkingLevel;
 }
 
+/** Priority chain for auto-discovering smol/fast models */
+export const SMOL_MODEL_PRIORITY = ["claude-haiku-4-5", "haiku", "flash", "mini"];
+
+/** Priority chain for auto-discovering slow/comprehensive models (reasoning, codex) */
+export const SLOW_MODEL_PRIORITY = ["gpt-5.2-codex", "gpt-5.2", "codex", "gpt", "opus", "pro"];
+
+/**
+ * Parse a model string in "provider/modelId" format.
+ * Returns undefined if the format is invalid.
+ */
+export function parseModelString(modelStr: string): { provider: string; id: string } | undefined {
+	const slashIdx = modelStr.indexOf("/");
+	if (slashIdx <= 0) return undefined;
+	return { provider: modelStr.slice(0, slashIdx), id: modelStr.slice(slashIdx + 1) };
+}
+
+/**
+ * Format a model as "provider/modelId" string.
+ */
+export function formatModelString(model: Model<Api>): string {
+	return `${model.provider}/${model.id}`;
+}
+
 /**
  * Helper to check if a model ID looks like an alias (no date suffix)
  * Dates are typically in format: -20241022 or -20250929
@@ -391,3 +414,81 @@ export async function restoreModelFromSession(
 	// No models available
 	return { model: undefined, fallbackMessage: undefined };
 }
+
+/**
+ * Find a smol/fast model using the priority chain.
+ * Tries exact matches first, then fuzzy matches.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available smol model, or undefined if none found
+ */
+export async function findSmolModel(
+	modelRegistry: ModelRegistry,
+	savedModel?: string,
+): Promise<Model<Api> | undefined> {
+	const availableModels = await modelRegistry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	// 1. Try saved model from settings
+	if (savedModel) {
+		const parsed = parseModelString(savedModel);
+		if (parsed) {
+			const match = availableModels.find((m) => m.provider === parsed.provider && m.id === parsed.id);
+			if (match) return match;
+		}
+	}
+
+	// 2. Try priority chain
+	for (const pattern of SMOL_MODEL_PRIORITY) {
+		// Try exact match first
+		const exactMatch = availableModels.find((m) => m.id.toLowerCase() === pattern.toLowerCase());
+		if (exactMatch) return exactMatch;
+
+		// Try fuzzy match (substring)
+		const fuzzyMatch = availableModels.find((m) => m.id.toLowerCase().includes(pattern.toLowerCase()));
+		if (fuzzyMatch) return fuzzyMatch;
+	}
+
+	// 3. Fallback to first available (same as default)
+	return availableModels[0];
+}
+
+/**
+ * Find a slow/comprehensive model using the priority chain.
+ * Prioritizes reasoning and codex models for thorough analysis.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available slow model, or undefined if none found
+ */
+export async function findSlowModel(
+	modelRegistry: ModelRegistry,
+	savedModel?: string,
+): Promise<Model<Api> | undefined> {
+	const availableModels = await modelRegistry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	// 1. Try saved model from settings
+	if (savedModel) {
+		const parsed = parseModelString(savedModel);
+		if (parsed) {
+			const match = availableModels.find((m) => m.provider === parsed.provider && m.id === parsed.id);
+			if (match) return match;
+		}
+	}
+
+	// 2. Try priority chain
+	for (const pattern of SLOW_MODEL_PRIORITY) {
+		// Try exact match first
+		const exactMatch = availableModels.find((m) => m.id.toLowerCase() === pattern.toLowerCase());
+		if (exactMatch) return exactMatch;
+
+		// Try fuzzy match (substring)
+		const fuzzyMatch = availableModels.find((m) => m.id.toLowerCase().includes(pattern.toLowerCase()));
+		if (fuzzyMatch) return fuzzyMatch;
+	}
+
+	// 3. Fallback to first available (same as default)
+	return availableModels[0];
+}

package/src/core/plugins/doctor.ts

@@ -1,4 +1,4 @@
-import type { DoctorCheck } from "./types.js";
+import type { DoctorCheck } from "./types";
 
 export async function runDoctorChecks(): Promise<DoctorCheck[]> {
 	const checks: DoctorCheck[] = [];

package/src/core/plugins/index.ts

@@ -1,5 +1,5 @@
 // Plugin system exports
-export { formatDoctorResults, runDoctorChecks } from "./doctor.js";
+export { formatDoctorResults, runDoctorChecks } from "./doctor";
 export {
 	getAllPluginCommandPaths,
 	getAllPluginHookPaths,
@@ -9,16 +9,16 @@ export {
 	resolvePluginCommandPaths,
 	resolvePluginHookPaths,
 	resolvePluginToolPaths,
-} from "./loader.js";
-export { PluginManager, parseSettingValue, validateSetting } from "./manager.js";
-export { extractPackageName, formatPluginSpec, parsePluginSpec } from "./parser.js";
+} from "./loader";
+export { PluginManager, parseSettingValue, validateSetting } from "./manager";
+export { extractPackageName, formatPluginSpec, parsePluginSpec } from "./parser";
 export {
 	getPluginsDir,
 	getPluginsLockfile,
 	getPluginsNodeModules,
 	getPluginsPackageJson,
 	getProjectPluginOverrides,
-} from "./paths.js";
+} from "./paths";
 export type {
 	BooleanSetting,
 	DoctorCheck,
@@ -35,4 +35,4 @@ export type {
 	PluginSettingType,
 	ProjectPluginOverrides,
 	StringSetting,
-} from "./types.js";
+} from "./types";

package/src/core/plugins/installer.ts

@@ -1,7 +1,7 @@
-import { mkdir } from "fs/promises";
-import { join, resolve } from "path";
-import { getAgentDir } from "../../config.js";
-import type { InstalledPlugin } from "./types.js";
+import { mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { getAgentDir } from "../../config";
+import type { InstalledPlugin } from "./types";
 
 const PLUGINS_DIR = join(getAgentDir(), "plugins");
 

package/src/core/plugins/loader.ts

@@ -5,15 +5,10 @@
  * based on manifest entries and enabled features.
  */
 
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import {
-	getPluginsLockfile,
-	getPluginsNodeModules,
-	getPluginsPackageJson,
-	getProjectPluginOverrides,
-} from "./paths.js";
-import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types.js";
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getPluginsLockfile, getPluginsNodeModules, getPluginsPackageJson, getProjectPluginOverrides } from "./paths";
+import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
 
 // =============================================================================
 // Runtime Config Loading

package/src/core/plugins/manager.ts

@@ -1,13 +1,13 @@
-import { existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
-import { extractPackageName, parsePluginSpec } from "./parser.js";
+import { existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { extractPackageName, parsePluginSpec } from "./parser";
 import {
 	getPluginsDir,
 	getPluginsLockfile,
 	getPluginsNodeModules,
 	getPluginsPackageJson,
 	getProjectPluginOverrides,
-} from "./paths.js";
+} from "./paths";
 import type {
 	DoctorCheck,
 	DoctorOptions,
@@ -17,7 +17,7 @@ import type {
 	PluginRuntimeConfig,
 	PluginSettingSchema,
 	ProjectPluginOverrides,
-} from "./types.js";
+} from "./types";
 
 // =============================================================================
 // Validation

package/src/core/plugins/paths.ts

@@ -1,6 +1,6 @@
-import { homedir } from "os";
-import { join } from "path";
-import { CONFIG_DIR_NAME } from "../../config.js";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "../../config";
 
 // =============================================================================
 // Plugin Directory Paths

package/src/core/sdk.ts

@@ -29,34 +29,38 @@
  * ```
  */
 
+import { join } from "node:path";
 import { Agent, type ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import type { Model } from "@oh-my-pi/pi-ai";
-import { join } from "path";
-import { getAgentDir } from "../config.js";
-import { AgentSession } from "./agent-session.js";
-import { AuthStorage } from "./auth-storage.js";
+import { getAgentDir } from "../config";
+import { AgentSession } from "./agent-session";
+import { AuthStorage } from "./auth-storage";
+import {
+	type CustomCommandsLoadResult,
+	loadCustomCommands as loadCustomCommandsInternal,
+} from "./custom-commands/index";
 import {
 	type CustomToolsLoadResult,
 	discoverAndLoadCustomTools,
 	type LoadedCustomTool,
 	wrapCustomTools,
-} from "./custom-tools/index.js";
-import type { CustomTool } from "./custom-tools/types.js";
-import { discoverAndLoadHooks, HookRunner, type LoadedHook, wrapToolsWithHooks } from "./hooks/index.js";
-import type { HookFactory } from "./hooks/types.js";
-import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp/index.js";
-import { convertToLlm } from "./messages.js";
-import { ModelRegistry } from "./model-registry.js";
-import { SessionManager } from "./session-manager.js";
-import { type Settings, SettingsManager, type SkillsSettings } from "./settings-manager.js";
-import { loadSkills as loadSkillsInternal, type Skill } from "./skills.js";
-import { type FileSlashCommand, loadSlashCommands as loadSlashCommandsInternal } from "./slash-commands.js";
+} from "./custom-tools/index";
+import type { CustomTool } from "./custom-tools/types";
+import { discoverAndLoadHooks, HookRunner, type LoadedHook, wrapToolsWithHooks } from "./hooks/index";
+import type { HookFactory } from "./hooks/types";
+import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp/index";
+import { convertToLlm } from "./messages";
+import { ModelRegistry } from "./model-registry";
+import { SessionManager } from "./session-manager";
+import { type CommandsSettings, type Settings, SettingsManager, type SkillsSettings } from "./settings-manager";
+import { loadSkills as loadSkillsInternal, type Skill } from "./skills";
+import { type FileSlashCommand, loadSlashCommands as loadSlashCommandsInternal } from "./slash-commands";
 import {
 	buildSystemPrompt as buildSystemPromptInternal,
 	loadProjectContextFiles as loadContextFilesInternal,
-} from "./system-prompt.js";
-import { time } from "./timings.js";
-import { createToolContextStore } from "./tools/context.js";
+} from "./system-prompt";
+import { time } from "./timings";
+import { createToolContextStore } from "./tools/context";
 import {
 	allTools,
 	applyBashInterception,
@@ -78,8 +82,9 @@ import {
 	readOnlyTools,
 	readTool,
 	type Tool,
+	warmupLspServers,
 	writeTool,
-} from "./tools/index.js";
+} from "./tools/index";
 
 // Types
 
@@ -126,6 +131,9 @@ export interface CreateAgentSessionOptions {
 	/** Enable MCP server discovery from .mcp.json files. Default: true */
 	enableMCP?: boolean;
 
+	/** Tool names explicitly requested (enables disabled-by-default tools) */
+	explicitTools?: string[];
+
 	/** Session manager. Default: SessionManager.create(cwd) */
 	sessionManager?: SessionManager;
 
@@ -146,17 +154,20 @@ export interface CreateAgentSessionResult {
 	mcpManager?: MCPManager;
 	/** Warning if session was restored with a different model than saved */
 	modelFallbackMessage?: string;
+	/** LSP servers that were warmed up at startup */
+	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }>;
 }
 
 // Re-exports
 
-export type { CustomTool } from "./custom-tools/types.js";
-export type { HookAPI, HookCommandContext, HookContext, HookFactory } from "./hooks/types.js";
-export type { MCPManager, MCPServerConfig, MCPServerConnection, MCPToolsLoadResult } from "./mcp/index.js";
-export type { Settings, SkillsSettings } from "./settings-manager.js";
-export type { Skill } from "./skills.js";
-export type { FileSlashCommand } from "./slash-commands.js";
-export type { Tool } from "./tools/index.js";
+export type { CustomCommand, CustomCommandFactory } from "./custom-commands/types";
+export type { CustomTool } from "./custom-tools/types";
+export type { HookAPI, HookCommandContext, HookContext, HookFactory } from "./hooks/types";
+export type { MCPManager, MCPServerConfig, MCPServerConnection, MCPToolsLoadResult } from "./mcp/index";
+export type { Settings, SkillsSettings } from "./settings-manager";
+export type { Skill } from "./skills";
+export type { FileSlashCommand } from "./slash-commands";
+export type { Tool } from "./tools/index";
 
 export {
 	// Pre-built tools (use process.cwd())
@@ -275,10 +286,29 @@ export function discoverContextFiles(cwd?: string, agentDir?: string): Array<{ p
 /**
  * Discover slash commands from cwd and agentDir.
  */
-export function discoverSlashCommands(cwd?: string, agentDir?: string): FileSlashCommand[] {
+export function discoverSlashCommands(
+	cwd?: string,
+	agentDir?: string,
+	settings?: CommandsSettings,
+): FileSlashCommand[] {
 	return loadSlashCommandsInternal({
 		cwd: cwd ?? process.cwd(),
 		agentDir: agentDir ?? getDefaultAgentDir(),
+		enableClaudeUser: settings?.enableClaudeUser,
+		enableClaudeProject: settings?.enableClaudeProject,
+	});
+}
+
+/**
+ * Discover custom commands (TypeScript slash commands) from cwd and agentDir.
+ */
+export async function discoverCustomTSCommands(cwd?: string, agentDir?: string): Promise<CustomCommandsLoadResult> {
+	const resolvedCwd = cwd ?? process.cwd();
+	const resolvedAgentDir = agentDir ?? getDefaultAgentDir();
+
+	return loadCustomCommandsInternal({
+		cwd: resolvedCwd,
+		agentDir: resolvedAgentDir,
 	});
 }
 
@@ -323,8 +353,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 export function loadSettings(cwd?: string, agentDir?: string): Settings {
 	const manager = SettingsManager.create(cwd ?? process.cwd(), agentDir ?? getDefaultAgentDir());
 	return {
-		defaultProvider: manager.getDefaultProvider(),
-		defaultModel: manager.getDefaultModel(),
+		modelRoles: manager.getModelRoles(),
 		defaultThinkingLevel: manager.getDefaultThinkingLevel(),
 		queueMode: manager.getQueueMode(),
 		theme: manager.getTheme(),
@@ -479,24 +508,34 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let modelFallbackMessage: string | undefined;
 
 	// If session has data, try to restore model from it
-	if (!model && hasExistingSession && existingSession.model) {
-		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
-		if (!model) {
-			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
+	const defaultModelStr = existingSession.models.default;
+	if (!model && hasExistingSession && defaultModelStr) {
+		const slashIdx = defaultModelStr.indexOf("/");
+		if (slashIdx > 0) {
+			const provider = defaultModelStr.slice(0, slashIdx);
+			const modelId = defaultModelStr.slice(slashIdx + 1);
+			const restoredModel = modelRegistry.find(provider, modelId);
+			if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
+				model = restoredModel;
+			}
+			if (!model) {
+				modelFallbackMessage = `Could not restore model ${defaultModelStr}`;
+			}
 		}
 	}
 
 	// If still no model, try settings default
 	if (!model) {
-		const defaultProvider = settingsManager.getDefaultProvider();
-		const defaultModelId = settingsManager.getDefaultModel();
-		if (defaultProvider && defaultModelId) {
-			const settingsModel = modelRegistry.find(defaultProvider, defaultModelId);
-			if (settingsModel && (await modelRegistry.getApiKey(settingsModel))) {
-				model = settingsModel;
+		const settingsDefaultModel = settingsManager.getModelRole("default");
+		if (settingsDefaultModel) {
+			const slashIdx = settingsDefaultModel.indexOf("/");
+			if (slashIdx > 0) {
+				const provider = settingsDefaultModel.slice(0, slashIdx);
+				const modelId = settingsDefaultModel.slice(slashIdx + 1);
+				const settingsModel = modelRegistry.find(provider, modelId);
+				if (settingsModel && (await modelRegistry.getApiKey(settingsModel))) {
+					model = settingsModel;
+				}
 			}
 		}
 	}
@@ -543,12 +582,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
 	time("discoverContextFiles");
 
-	// Hook runner - created early for hooks
-	let hookRunner: HookRunner | undefined;
+	// Hook runner - always created (needed for custom command context even without hooks)
+	let loadedHooks: LoadedHook[] = [];
 	if (options.hooks !== undefined) {
 		if (options.hooks.length > 0) {
-			const loadedHooks = createLoadedHooksFromDefinitions(options.hooks);
-			hookRunner = new HookRunner(loadedHooks, cwd, sessionManager, modelRegistry);
+			loadedHooks = createLoadedHooksFromDefinitions(options.hooks);
 		}
 	} else {
 		// Discover hooks, merging with additional paths
@@ -558,15 +596,21 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		for (const { path, error } of errors) {
 			console.error(`Failed to load hook "${path}": ${error}`);
 		}
-		if (hooks.length > 0) {
-			hookRunner = new HookRunner(hooks, cwd, sessionManager, modelRegistry);
-		}
+		loadedHooks = hooks;
 	}
+	const hookRunner = new HookRunner(loadedHooks, cwd, sessionManager, modelRegistry);
 
 	const sessionContext = {
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
 	};
-	const builtInTools = options.tools ?? createCodingTools(cwd, options.hasUI ?? false, sessionContext);
+	const builtInTools =
+		options.tools ??
+		createCodingTools(cwd, options.hasUI ?? false, sessionContext, {
+			lspFormatOnWrite: settingsManager.getLspFormatOnWrite(),
+			lspDiagnosticsOnWrite: settingsManager.getLspDiagnosticsOnWrite(),
+			lspDiagnosticsOnEdit: settingsManager.getLspDiagnosticsOnEdit(),
+			editFuzzyMatch: settingsManager.getEditFuzzyMatch(),
+		});
 	time("createCodingTools");
 
 	let customToolsResult: CustomToolsLoadResult;
@@ -676,6 +720,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	};
 
 	let allToolsArray: Tool[] = [...builtInTools, ...wrappedCustomTools];
+
+	// Filter out hidden tools unless explicitly requested
+	if (options.explicitTools) {
+		const explicitSet = new Set(options.explicitTools);
+		allToolsArray = allToolsArray.filter((tool) => !tool.hidden || explicitSet.has(tool.name));
+	} else {
+		allToolsArray = allToolsArray.filter((tool) => !tool.hidden);
+	}
 	time("combineTools");
 
 	// Apply bash interception to redirect common shell patterns to proper tools (if enabled)
@@ -711,9 +763,17 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		systemPrompt = options.systemPrompt(defaultPrompt);
 	}
 
-	const slashCommands = options.slashCommands ?? discoverSlashCommands(cwd, agentDir);
+	const commandsSettings = settingsManager.getCommandsSettings();
+	const slashCommands = options.slashCommands ?? discoverSlashCommands(cwd, agentDir, commandsSettings);
 	time("discoverSlashCommands");
 
+	// Discover custom commands (TypeScript slash commands)
+	const customCommandsResult = await loadCustomCommandsInternal({ cwd, agentDir });
+	time("discoverCustomCommands");
+	for (const { path, error } of customCommandsResult.errors) {
+		console.error(`Failed to load custom command "${path}": ${error}`);
+	}
+
 	agent = new Agent({
 		initialState: {
 			systemPrompt,
@@ -728,6 +788,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				}
 			: undefined,
 		queueMode: settingsManager.getQueueMode(),
+		interruptMode: settingsManager.getInterruptMode(),
 		getToolContext: toolContextStore.getContext,
 		getApiKey: async () => {
 			const currentModel = agent.state.model;
@@ -749,7 +810,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	} else {
 		// Save initial model and thinking level for new sessions so they can be restored on resume
 		if (model) {
-			sessionManager.appendModelChange(model.provider, model.id);
+			sessionManager.appendModelChange(`${model.provider}/${model.id}`);
 		}
 		sessionManager.appendThinkingLevelChange(thinkingLevel);
 	}
@@ -762,15 +823,29 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		fileCommands: slashCommands,
 		hookRunner,
 		customTools: customToolsResult.tools,
+		customCommands: customCommandsResult.commands,
 		skillsSettings: settingsManager.getSkillsSettings(),
 		modelRegistry,
 	});
 	time("createAgentSession");
 
+	// Warm up LSP servers (connects to detected servers)
+	let lspServers: CreateAgentSessionResult["lspServers"];
+	if (settingsManager.getLspDiagnosticsOnWrite()) {
+		try {
+			const result = await warmupLspServers(cwd);
+			lspServers = result.servers;
+			time("warmupLspServers");
+		} catch {
+			// Ignore warmup errors
+		}
+	}
+
 	return {
 		session,
 		customToolsResult,
 		mcpManager,
 		modelFallbackMessage,
+		lspServers,
 	};
 }