@oh-my-pi/pi-coding-agent 1.338.0 → 1.341.0

package/src/core/tools/lsp/index.ts

@@ -3,9 +3,17 @@ import path from "node:path";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
 import type { Theme } from "../../../modes/interactive/theme/theme.js";
 import { resolveToCwd } from "../path-utils.js";
-import { ensureFileOpen, getOrCreateClient, refreshFile, sendRequest } from "./client.js";
-import { getServerForFile, hasCapability, type LspConfig, loadConfig } from "./config.js";
-import { applyWorkspaceEdit } from "./edits.js";
+import {
+	ensureFileOpen,
+	getActiveClients,
+	getOrCreateClient,
+	type LspServerStatus,
+	refreshFile,
+	sendRequest,
+	setIdleTimeout,
+} from "./client.js";
+import { getServerForFile, getServersForFile, hasCapability, type LspConfig, loadConfig } from "./config.js";
+import { applyTextEdits, applyWorkspaceEdit } from "./edits.js";
 import { renderCall, renderResult } from "./render.js";
 import * as rustAnalyzer from "./rust-analyzer.js";
 import {
@@ -25,6 +33,7 @@ import {
 	lspSchema,
 	type ServerConfig,
 	type SymbolInformation,
+	type TextEdit,
 	type WorkspaceEdit,
 } from "./types.js";
 import {
@@ -41,8 +50,68 @@ import {
 	uriToFile,
 } from "./utils.js";
 
+export type { LspServerStatus } from "./client.js";
 export type { LspToolDetails } from "./types.js";
 
+/** Result from warming up LSP servers */
+export interface LspWarmupResult {
+	servers: Array<{
+		name: string;
+		status: "ready" | "error";
+		fileTypes: string[];
+		error?: string;
+	}>;
+}
+
+/**
+ * Warm up LSP servers for a directory by connecting to all detected servers.
+ * This should be called at startup to avoid cold-start delays.
+ *
+ * @param cwd - Working directory to detect and start servers for
+ * @returns Status of each server that was started
+ */
+export async function warmupLspServers(cwd: string): Promise<LspWarmupResult> {
+	const config = loadConfig(cwd);
+	setIdleTimeout(config.idleTimeoutMs);
+	const servers: LspWarmupResult["servers"] = [];
+
+	// Start all detected servers in parallel
+	const results = await Promise.allSettled(
+		Object.entries(config.servers).map(async ([name, serverConfig]) => {
+			const client = await getOrCreateClient(serverConfig, cwd);
+			return { name, client, fileTypes: serverConfig.fileTypes };
+		}),
+	);
+
+	for (const result of results) {
+		if (result.status === "fulfilled") {
+			servers.push({
+				name: result.value.name,
+				status: "ready",
+				fileTypes: result.value.fileTypes,
+			});
+		} else {
+			// Extract server name from error if possible
+			const errorMsg = result.reason?.message ?? String(result.reason);
+			servers.push({
+				name: "unknown",
+				status: "error",
+				fileTypes: [],
+				error: errorMsg,
+			});
+		}
+	}
+
+	return { servers };
+}
+
+/**
+ * Get status of currently active LSP servers.
+ */
+export function getLspStatus(): LspServerStatus[] {
+	return getActiveClients();
+}
+
 // Cache config per cwd to avoid repeated file I/O
 const configCache = new Map<string, LspConfig>();
 
@@ -50,6 +119,7 @@ function getConfig(cwd: string): LspConfig {
 	let config = configCache.get(cwd);
 	if (!config) {
 		config = loadConfig(cwd);
+		setIdleTimeout(config.idleTimeoutMs);
 		configCache.set(cwd, config);
 	}
 	return config;
@@ -139,6 +209,303 @@ async function waitForDiagnostics(client: LspClient, uri: string, timeoutMs = 30
 	return client.diagnostics.get(uri) ?? [];
 }
 
+/** Project type detection result */
+interface ProjectType {
+	type: "rust" | "typescript" | "go" | "python" | "unknown";
+	command?: string[];
+	description: string;
+}
+
+/** Detect project type from root markers */
+function detectProjectType(cwd: string): ProjectType {
+	// Check for Rust (Cargo.toml)
+	if (fs.existsSync(path.join(cwd, "Cargo.toml"))) {
+		return { type: "rust", command: ["cargo", "check", "--message-format=short"], description: "Rust (cargo check)" };
+	}
+
+	// Check for TypeScript (tsconfig.json)
+	if (fs.existsSync(path.join(cwd, "tsconfig.json"))) {
+		return { type: "typescript", command: ["npx", "tsc", "--noEmit"], description: "TypeScript (tsc --noEmit)" };
+	}
+
+	// Check for Go (go.mod)
+	if (fs.existsSync(path.join(cwd, "go.mod"))) {
+		return { type: "go", command: ["go", "build", "./..."], description: "Go (go build)" };
+	}
+
+	// Check for Python (pyproject.toml or pyrightconfig.json)
+	if (fs.existsSync(path.join(cwd, "pyproject.toml")) || fs.existsSync(path.join(cwd, "pyrightconfig.json"))) {
+		return { type: "python", command: ["pyright"], description: "Python (pyright)" };
+	}
+
+	return { type: "unknown", description: "Unknown project type" };
+}
+
+/** Run workspace diagnostics command and parse output */
+async function runWorkspaceDiagnostics(
+	cwd: string,
+	config: LspConfig,
+): Promise<{ output: string; projectType: ProjectType }> {
+	const projectType = detectProjectType(cwd);
+
+	// For Rust, use flycheck via rust-analyzer if available
+	if (projectType.type === "rust") {
+		const rustServer = getRustServer(config);
+		if (rustServer && hasCapability(rustServer[1], "flycheck")) {
+			const [_serverName, serverConfig] = rustServer;
+			try {
+				const client = await getOrCreateClient(serverConfig, cwd);
+				await rustAnalyzer.flycheck(client);
+
+				const collected: Array<{ filePath: string; diagnostic: Diagnostic }> = [];
+				for (const [diagUri, diags] of client.diagnostics.entries()) {
+					const relPath = path.relative(cwd, uriToFile(diagUri));
+					for (const diag of diags) {
+						collected.push({ filePath: relPath, diagnostic: diag });
+					}
+				}
+
+				if (collected.length === 0) {
+					return { output: "No issues found", projectType };
+				}
+
+				const summary = formatDiagnosticsSummary(collected.map((d) => d.diagnostic));
+				const formatted = collected.slice(0, 50).map((d) => formatDiagnostic(d.diagnostic, d.filePath));
+				const more = collected.length > 50 ? `\n  ... and ${collected.length - 50} more` : "";
+				return { output: `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}${more}`, projectType };
+			} catch (e) {
+				// Fall through to shell command
+			}
+		}
+	}
+
+	// Fall back to shell command
+	if (!projectType.command) {
+		return {
+			output: `Cannot detect project type. Supported: Rust (Cargo.toml), TypeScript (tsconfig.json), Go (go.mod), Python (pyproject.toml)`,
+			projectType,
+		};
+	}
+
+	try {
+		const proc = Bun.spawn(projectType.command, {
+			cwd,
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+
+		const [stdout, stderr] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()]);
+		await proc.exited;
+
+		const combined = (stdout + stderr).trim();
+		if (!combined) {
+			return { output: "No issues found", projectType };
+		}
+
+		// Limit output length
+		const lines = combined.split("\n");
+		if (lines.length > 50) {
+			return { output: lines.slice(0, 50).join("\n") + `\n... and ${lines.length - 50} more lines`, projectType };
+		}
+
+		return { output: combined, projectType };
+	} catch (e) {
+		return { output: `Failed to run ${projectType.command.join(" ")}: ${e}`, projectType };
+	}
+}
+
+/** Result from getDiagnosticsForFile */
+export interface FileDiagnosticsResult {
+	/** Whether an LSP server was available for the file type */
+	available: boolean;
+	/** Name of the LSP server used (if available) */
+	serverName?: string;
+	/** Formatted diagnostic messages */
+	diagnostics: string[];
+	/** Summary string (e.g., "2 error(s), 1 warning(s)") */
+	summary: string;
+	/** Whether there are any errors (severity 1) */
+	hasErrors: boolean;
+	/** Whether there are any warnings (severity 2) */
+	hasWarnings: boolean;
+}
+
+/**
+ * Get LSP diagnostics for a file after it has been written.
+ * Queries all applicable language servers (e.g., TypeScript + Biome) and merges results.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param cwd - Working directory for LSP config resolution
+ * @param timeoutMs - Timeout for waiting for diagnostics (default: 5000ms)
+ * @returns Diagnostic results or null if no LSP server available
+ */
+export async function getDiagnosticsForFile(
+	absolutePath: string,
+	cwd: string,
+	timeoutMs = 5000,
+): Promise<FileDiagnosticsResult> {
+	const config = getConfig(cwd);
+	const servers = getServersForFile(config, absolutePath);
+
+	if (servers.length === 0) {
+		return {
+			available: false,
+			diagnostics: [],
+			summary: "",
+			hasErrors: false,
+			hasWarnings: false,
+		};
+	}
+
+	const uri = fileToUri(absolutePath);
+	const relPath = path.relative(cwd, absolutePath);
+	const allDiagnostics: Diagnostic[] = [];
+	const serverNames: string[] = [];
+
+	// Query all applicable servers in parallel
+	const results = await Promise.allSettled(
+		servers.map(async ([serverName, serverConfig]) => {
+			const client = await getOrCreateClient(serverConfig, cwd);
+			await refreshFile(client, absolutePath);
+			const diagnostics = await waitForDiagnostics(client, uri, timeoutMs);
+			return { serverName, diagnostics };
+		}),
+	);
+
+	for (const result of results) {
+		if (result.status === "fulfilled") {
+			serverNames.push(result.value.serverName);
+			allDiagnostics.push(...result.value.diagnostics);
+		}
+	}
+
+	if (serverNames.length === 0) {
+		// All servers failed
+		return {
+			available: false,
+			diagnostics: [],
+			summary: "",
+			hasErrors: false,
+			hasWarnings: false,
+		};
+	}
+
+	if (allDiagnostics.length === 0) {
+		return {
+			available: true,
+			serverName: serverNames.join(", "),
+			diagnostics: [],
+			summary: "No issues",
+			hasErrors: false,
+			hasWarnings: false,
+		};
+	}
+
+	// Deduplicate diagnostics by range + message (different servers might report similar issues)
+	const seen = new Set<string>();
+	const uniqueDiagnostics: Diagnostic[] = [];
+	for (const d of allDiagnostics) {
+		const key = `${d.range.start.line}:${d.range.start.character}:${d.range.end.line}:${d.range.end.character}:${d.message}`;
+		if (!seen.has(key)) {
+			seen.add(key);
+			uniqueDiagnostics.push(d);
+		}
+	}
+
+	const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
+	const summary = formatDiagnosticsSummary(uniqueDiagnostics);
+	const hasErrors = uniqueDiagnostics.some((d) => d.severity === 1);
+	const hasWarnings = uniqueDiagnostics.some((d) => d.severity === 2);
+
+	return {
+		available: true,
+		serverName: serverNames.join(", "),
+		diagnostics: formatted,
+		summary,
+		hasErrors,
+		hasWarnings,
+	};
+}
+
+/** Result from formatFile */
+export interface FileFormatResult {
+	/** Whether an LSP server with formatting support was available */
+	available: boolean;
+	/** Name of the LSP server used (if available) */
+	serverName?: string;
+	/** Whether formatting was applied */
+	formatted: boolean;
+	/** Error message if formatting failed */
+	error?: string;
+}
+
+/** Default formatting options for LSP */
+const DEFAULT_FORMAT_OPTIONS = {
+	tabSize: 3,
+	insertSpaces: true,
+	trimTrailingWhitespace: true,
+	insertFinalNewline: true,
+	trimFinalNewlines: true,
+};
+
+/**
+ * Format a file using LSP.
+ * Uses the first available server that supports formatting.
+ *
+ * @param absolutePath - Absolute path to the file
+ * @param cwd - Working directory for LSP config resolution
+ * @returns Format result indicating success/failure
+ */
+export async function formatFile(absolutePath: string, cwd: string): Promise<FileFormatResult> {
+	const config = getConfig(cwd);
+	const servers = getServersForFile(config, absolutePath);
+
+	if (servers.length === 0) {
+		return { available: false, formatted: false };
+	}
+
+	const uri = fileToUri(absolutePath);
+
+	// Try each server until one successfully formats
+	for (const [serverName, serverConfig] of servers) {
+		try {
+			const client = await getOrCreateClient(serverConfig, cwd);
+
+			// Check if server supports formatting
+			const caps = client.serverCapabilities;
+			if (!caps?.documentFormattingProvider) {
+				continue;
+			}
+
+			// Ensure file is open and synced
+			await ensureFileOpen(client, absolutePath);
+			await refreshFile(client, absolutePath);
+
+			// Request formatting
+			const edits = (await sendRequest(client, "textDocument/formatting", {
+				textDocument: { uri },
+				options: DEFAULT_FORMAT_OPTIONS,
+			})) as TextEdit[] | null;
+
+			if (!edits || edits.length === 0) {
+				// No changes needed - file already formatted
+				return { available: true, serverName, formatted: false };
+			}
+
+			// Apply the formatting edits
+			await applyTextEdits(absolutePath, edits);
+
+			// Notify LSP of the change so diagnostics update
+			await refreshFile(client, absolutePath);
+
+			return { available: true, serverName, formatted: true };
+		} catch {}
+	}
+
+	// No server could format
+	return { available: false, formatted: false };
+}
+
 export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolDetails, Theme> {
 	return {
 		name: "lsp",
@@ -147,6 +514,7 @@ export function createLspTool(cwd: string): AgentTool<typeof lspSchema, LspToolD
 
 Standard operations:
 - diagnostics: Get errors/warnings for a file
+- workspace_diagnostics: Check entire project for errors (uses tsc, cargo check, go build, etc.)
 - definition: Go to symbol definition
 - references: Find all references to a symbol
 - hover: Get type info and documentation
@@ -201,7 +569,21 @@ Rust-analyzer specific (require rust-analyzer):
 				};
 			}
 
-			// Diagnostics can be batch or single-file
+			// Workspace diagnostics - check entire project
+			if (action === "workspace_diagnostics") {
+				const result = await runWorkspaceDiagnostics(cwd, config);
+				return {
+					content: [
+						{
+							type: "text",
+							text: `Workspace diagnostics (${result.projectType.description}):\n${result.output}`,
+						},
+					],
+					details: { action, success: true },
+				};
+			}
+
+			// Diagnostics can be batch or single-file - queries all applicable servers
 			if (action === "diagnostics") {
 				const targets = files?.length ? files : file ? [file] : null;
 				if (!targets) {
@@ -213,49 +595,67 @@ Rust-analyzer specific (require rust-analyzer):
 
 				const detailed = Boolean(files?.length);
 				const results: string[] = [];
-				let lastServerName: string | undefined;
+				const allServerNames = new Set<string>();
 
 				for (const target of targets) {
 					const resolved = resolveToCwd(target, cwd);
-					const serverInfo = getServerForFile(config, resolved);
-					if (!serverInfo) {
+					const servers = getServersForFile(config, resolved);
+					if (servers.length === 0) {
 						results.push(`✗ ${target}: No language server found`);
 						continue;
 					}
 
-					const [serverName, serverConfig] = serverInfo;
-					lastServerName = serverName;
-
-					const client = await getOrCreateClient(serverConfig, cwd);
-					await refreshFile(client, resolved);
-
 					const uri = fileToUri(resolved);
-					const diagnostics = await waitForDiagnostics(client, uri);
 					const relPath = path.relative(cwd, resolved);
+					const allDiagnostics: Diagnostic[] = [];
+
+					// Query all applicable servers for this file
+					for (const [serverName, serverConfig] of servers) {
+						allServerNames.add(serverName);
+						try {
+							const client = await getOrCreateClient(serverConfig, cwd);
+							await refreshFile(client, resolved);
+							const diagnostics = await waitForDiagnostics(client, uri);
+							allDiagnostics.push(...diagnostics);
+						} catch {
+							// Server failed, continue with others
+						}
+					}
+
+					// Deduplicate diagnostics
+					const seen = new Set<string>();
+					const uniqueDiagnostics: Diagnostic[] = [];
+					for (const d of allDiagnostics) {
+						const key = `${d.range.start.line}:${d.range.start.character}:${d.range.end.line}:${d.range.end.character}:${d.message}`;
+						if (!seen.has(key)) {
+							seen.add(key);
+							uniqueDiagnostics.push(d);
+						}
+					}
 
 					if (!detailed && targets.length === 1) {
-						if (diagnostics.length === 0) {
+						if (uniqueDiagnostics.length === 0) {
 							return {
 								content: [{ type: "text", text: "No diagnostics" }],
-								details: { action, serverName, success: true },
+								details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 							};
 						}
 
-						const summary = formatDiagnosticsSummary(diagnostics);
-						const formatted = diagnostics.map((d) => formatDiagnostic(d, relPath));
+						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
+						const formatted = uniqueDiagnostics.map((d) => formatDiagnostic(d, relPath));
 						const output = `${summary}:\n${formatted.map((f) => `  ${f}`).join("\n")}`;
 						return {
 							content: [{ type: "text", text: output }],
-							details: { action, serverName, success: true },
+							details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 						};
 					}
 
-					if (diagnostics.length === 0) {
+					if (uniqueDiagnostics.length === 0) {
 						results.push(`✓ ${relPath}: no issues`);
 					} else {
-						const summary = formatDiagnosticsSummary(diagnostics);
+						const summary = formatDiagnosticsSummary(uniqueDiagnostics);
 						results.push(`✗ ${relPath}: ${summary}`);
-						for (const diag of diagnostics) {
+						for (const diag of uniqueDiagnostics) {
 							results.push(`  ${formatDiagnostic(diag, relPath)}`);
 						}
 					}
@@ -263,7 +663,7 @@ Rust-analyzer specific (require rust-analyzer):
 
 				return {
 					content: [{ type: "text", text: results.join("\n") }],
-					details: { action, serverName: lastServerName, success: true },
+					details: { action, serverName: Array.from(allServerNames).join(", "), success: true },
 				};
 			}
 

package/src/core/tools/lsp/types.ts

@@ -10,6 +10,7 @@ export const lspSchema = Type.Object({
 		[
 			// Standard LSP operations
 			Type.Literal("diagnostics"),
+			Type.Literal("workspace_diagnostics"),
 			Type.Literal("references"),
 			Type.Literal("definition"),
 			Type.Literal("hover"),
@@ -336,6 +337,10 @@ export interface ServerConfig {
 	settings?: Record<string, unknown>;
 	disabled?: boolean;
 	capabilities?: ServerCapabilities;
+	/** If true, this is a linter/formatter server (e.g., Biome) - used only for diagnostics/actions, not type intelligence */
+	isLinter?: boolean;
+	/** Resolved absolute path to the command binary (set during config loading) */
+	resolvedCommand?: string;
 }
 
 // =============================================================================

package/src/core/tools/task/bundled-agents/explore.md

@@ -2,7 +2,7 @@
 name: explore
 description: Fast read-only codebase scout that returns compressed context for handoff
 tools: read, grep, glob, ls, bash
-model: claude-haiku-4-5, haiku, flash, mini
+model: pi/smol, haiku, flash, mini
 ---
 
 You are a file search specialist and codebase scout. Quickly investigate a codebase and return structured findings that another agent can use without re-reading everything.

package/src/core/tools/task/bundled-agents/reviewer.md

@@ -2,7 +2,7 @@
 name: reviewer
 description: Expert code reviewer for PRs and implementation changes
 tools: read, grep, glob, ls, bash
-model: gpt-5.2-codex, gpt-5.2, codex, gpt
+model: pi/slow, gpt-5.2-codex, gpt-5.2, codex, gpt
 ---
 
 You are an expert code reviewer. Analyze code changes and provide thorough reviews.

package/src/core/tools/task/model-resolver.ts

@@ -6,9 +6,14 @@
  *   - Fuzzy match: "opus" → "claude-opus-4-5"
  *   - Comma fallback: "gpt, opus" → tries gpt first, then opus
  *   - "default" → undefined (use system default)
+ *   - "pi/default" → configured default model from settings
+ *   - "pi/smol" → configured smol model from settings
  */
 
 import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 
 /** pi command: 'pi.cmd' on Windows, 'pi' elsewhere */
 const PI_CMD = process.platform === "win32" ? "pi.cmd" : "pi";
@@ -74,6 +79,42 @@ export function clearModelCache(): void {
 	cacheExpiry = 0;
 }
 
+/**
+ * Load model roles from settings file.
+ */
+function loadModelRoles(): Record<string, string> {
+	try {
+		const settingsPath = join(homedir(), ".pi", "agent", "settings.json");
+		if (!existsSync(settingsPath)) return {};
+		const content = readFileSync(settingsPath, "utf-8");
+		const settings = JSON.parse(content);
+		return settings.modelRoles ?? {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Resolve a pi/<role> alias to a model string.
+ * Looks up the role in settings.modelRoles and returns the configured model.
+ * Returns undefined if the role isn't configured.
+ */
+function resolvePiAlias(role: string, availableModels: string[]): string | undefined {
+	const roles = loadModelRoles();
+
+	// Look up role in settings (case-insensitive)
+	const configured = roles[role] || roles[role.toLowerCase()];
+	if (!configured) return undefined;
+
+	// configured is in "provider/modelId" format, extract just the modelId for matching
+	const slashIdx = configured.indexOf("/");
+	if (slashIdx <= 0) return undefined;
+
+	const modelId = configured.slice(slashIdx + 1);
+	// Find in available models
+	return availableModels.find((m) => m.toLowerCase() === modelId.toLowerCase());
+}
+
 /**
  * Resolve a fuzzy model pattern to an actual model name.
  *
@@ -97,16 +138,24 @@ export function resolveModelPattern(pattern: string | undefined, availableModels
 	// Split by comma, try each pattern in order
 	const patterns = pattern
 		.split(",")
-		.map((p) => p.trim().toLowerCase())
+		.map((p) => p.trim())
 		.filter(Boolean);
 
 	for (const p of patterns) {
+		// Handle pi/<role> aliases - looks up role in settings.modelRoles
+		if (p.toLowerCase().startsWith("pi/")) {
+			const role = p.slice(3); // Remove "pi/" prefix
+			const resolved = resolvePiAlias(role, models);
+			if (resolved) return resolved;
+			continue; // Role not configured, try next pattern
+		}
+
 		// Try exact match first
-		const exactMatch = models.find((m) => m.toLowerCase() === p);
+		const exactMatch = models.find((m) => m.toLowerCase() === p.toLowerCase());
 		if (exactMatch) return exactMatch;
 
 		// Try fuzzy match (substring)
-		const fuzzyMatch = models.find((m) => m.toLowerCase().includes(p));
+		const fuzzyMatch = models.find((m) => m.toLowerCase().includes(p.toLowerCase()));
 		if (fuzzyMatch) return fuzzyMatch;
 	}