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

package/src/core/session-manager.ts

@@ -28,6 +28,7 @@ export interface SessionHeader {
 	type: "session";
 	version?: number; // v1 sessions don't have this
 	id: string;
+	title?: string; // Auto-generated title from first message
 	timestamp: string;
 	cwd: string;
 	parentSession?: string;
@@ -56,8 +57,10 @@ export interface ThinkingLevelChangeEntry extends SessionEntryBase {
 
 export interface ModelChangeEntry extends SessionEntryBase {
 	type: "model_change";
-	provider: string;
-	modelId: string;
+	/** Model in "provider/modelId" format */
+	model: string;
+	/** Role: "default", "smol", "slow", etc. Undefined treated as "default" */
+	role?: string;
 }
 
 export interface CompactionEntry<T = unknown> extends SessionEntryBase {
@@ -149,12 +152,14 @@ export interface SessionTreeNode {
 export interface SessionContext {
 	messages: AgentMessage[];
 	thinkingLevel: string;
-	model: { provider: string; modelId: string } | null;
+	/** Model roles: { default: "provider/modelId", small: "provider/modelId", ... } */
+	models: Record<string, string>;
 }
 
 export interface SessionInfo {
 	path: string;
 	id: string;
+	title?: string;
 	created: Date;
 	modified: Date;
 	messageCount: number;
@@ -290,7 +295,7 @@ export function buildSessionContext(
 	let leaf: SessionEntry | undefined;
 	if (leafId === null) {
 		// Explicitly null - return no messages (navigated to before first entry)
-		return { messages: [], thinkingLevel: "off", model: null };
+		return { messages: [], thinkingLevel: "off", models: {} };
 	}
 	if (leafId) {
 		leaf = byId.get(leafId);
@@ -301,7 +306,7 @@ export function buildSessionContext(
 	}
 
 	if (!leaf) {
-		return { messages: [], thinkingLevel: "off", model: null };
+		return { messages: [], thinkingLevel: "off", models: {} };
 	}
 
 	// Walk from leaf to root, collecting path
@@ -314,16 +319,21 @@ export function buildSessionContext(
 
 	// Extract settings and find compaction
 	let thinkingLevel = "off";
-	let model: { provider: string; modelId: string } | null = null;
+	const models: Record<string, string> = {};
 	let compaction: CompactionEntry | null = null;
 
 	for (const entry of path) {
 		if (entry.type === "thinking_level_change") {
 			thinkingLevel = entry.thinkingLevel;
 		} else if (entry.type === "model_change") {
-			model = { provider: entry.provider, modelId: entry.modelId };
+			// New format: { model: "provider/id", role?: string }
+			if (entry.model) {
+				const role = entry.role ?? "default";
+				models[role] = entry.model;
+			}
 		} else if (entry.type === "message" && entry.message.role === "assistant") {
-			model = { provider: entry.message.provider, modelId: entry.message.model };
+			// Infer default model from assistant messages
+			models.default = `${entry.message.provider}/${entry.message.model}`;
 		} else if (entry.type === "compaction") {
 			compaction = entry;
 		}
@@ -379,7 +389,7 @@ export function buildSessionContext(
 		}
 	}
 
-	return { messages, thinkingLevel, model };
+	return { messages, thinkingLevel, models };
 }
 
 /**
@@ -454,6 +464,67 @@ export function findMostRecentSession(sessionDir: string): string | null {
 	}
 }
 
+/** Recent session info for display */
+export interface RecentSessionInfo {
+	name: string;
+	path: string;
+	timeAgo: string;
+}
+
+/** Format a time difference as a human-readable string */
+function formatTimeAgo(date: Date): string {
+	const now = Date.now();
+	const diffMs = now - date.getTime();
+	const diffMins = Math.floor(diffMs / 60000);
+	const diffHours = Math.floor(diffMs / 3600000);
+	const diffDays = Math.floor(diffMs / 86400000);
+
+	if (diffMins < 1) return "just now";
+	if (diffMins < 60) return `${diffMins}m ago`;
+	if (diffHours < 24) return `${diffHours}h ago`;
+	if (diffDays < 7) return `${diffDays}d ago`;
+	return date.toLocaleDateString();
+}
+
+/** Get recent sessions for display in welcome screen */
+export function getRecentSessions(sessionDir: string, limit = 3): RecentSessionInfo[] {
+	try {
+		const files = readdirSync(sessionDir)
+			.filter((f) => f.endsWith(".jsonl"))
+			.map((f) => join(sessionDir, f))
+			.filter(isValidSessionFile)
+			.map((path) => {
+				const stat = statSync(path);
+				// Try to get session title or id from first line
+				let name = path.split("/").pop()?.replace(".jsonl", "") ?? "Unknown";
+				try {
+					const content = readFileSync(path, "utf-8");
+					const firstLine = content.split("\n")[0];
+					if (firstLine) {
+						const header = JSON.parse(firstLine) as SessionHeader;
+						if (header.type === "session") {
+							// Prefer title over id
+							name = header.title ?? header.id ?? name;
+						}
+					}
+				} catch {
+					// Use filename as fallback
+				}
+				return { path, name, mtime: stat.mtime };
+			})
+			.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())
+			.slice(0, limit);
+
+		return files.map((f) => ({
+			name: f.name.length > 40 ? `${f.name.slice(0, 37)}...` : f.name,
+			path: f.path,
+			timeAgo: formatTimeAgo(f.mtime),
+		}));
+	} catch {
+		return [];
+	}
+}
+
 /**
  * Manages conversation sessions as append-only trees stored in JSONL files.
  *
@@ -467,6 +538,7 @@ export function findMostRecentSession(sessionDir: string): string | null {
  */
 export class SessionManager {
 	private sessionId: string = "";
+	private sessionTitle: string | undefined;
 	private sessionFile: string | undefined;
 	private sessionDir: string;
 	private cwd: string;
@@ -499,6 +571,7 @@ export class SessionManager {
 			this.fileEntries = loadEntriesFromFile(this.sessionFile);
 			const header = this.fileEntries.find((e) => e.type === "session") as SessionHeader | undefined;
 			this.sessionId = header?.id ?? crypto.randomUUID();
+			this.sessionTitle = header?.title;
 
 			if (migrateToCurrentVersion(this.fileEntries)) {
 				this._rewriteFile();
@@ -579,6 +652,31 @@ export class SessionManager {
 		return this.sessionFile;
 	}
 
+	getSessionTitle(): string | undefined {
+		return this.sessionTitle;
+	}
+
+	setSessionTitle(title: string): void {
+		this.sessionTitle = title;
+		// Update the session file header with the title
+		if (this.persist && this.sessionFile && existsSync(this.sessionFile)) {
+			try {
+				const content = readFileSync(this.sessionFile, "utf-8");
+				const lines = content.split("\n");
+				if (lines.length > 0) {
+					const header = JSON.parse(lines[0]) as SessionHeader;
+					if (header.type === "session") {
+						header.title = title;
+						lines[0] = JSON.stringify(header);
+						writeFileSync(this.sessionFile, lines.join("\n"));
+					}
+				}
+			} catch {
+				// Ignore errors updating title
+			}
+		}
+	}
+
 	_persist(entry: SessionEntry): void {
 		if (!this.persist || !this.sessionFile) return;
 
@@ -633,15 +731,19 @@ export class SessionManager {
 		return entry.id;
 	}
 
-	/** Append a model change as child of current leaf, then advance leaf. Returns entry id. */
-	appendModelChange(provider: string, modelId: string): string {
+	/**
+	 * Append a model change as child of current leaf, then advance leaf. Returns entry id.
+	 * @param model Model in "provider/modelId" format
+	 * @param role Optional role (default: "default")
+	 */
+	appendModelChange(model: string, role?: string): string {
 		const entry: ModelChangeEntry = {
 			type: "model_change",
 			id: generateId(this.byId),
 			parentId: this.leafId,
 			timestamp: new Date().toISOString(),
-			provider,
-			modelId,
+			model,
+			role,
 		};
 		this._appendEntry(entry);
 		return entry.id;
@@ -1061,7 +1163,7 @@ export class SessionManager {
 					if (lines.length === 0) continue;
 
 					// Check first line for valid session header
-					let header: { type: string; id: string; timestamp: string } | null = null;
+					let header: { type: string; id: string; title?: string; timestamp: string } | null = null;
 					try {
 						const first = JSON.parse(lines[0]);
 						if (first.type === "session" && first.id) {
@@ -1107,6 +1209,7 @@ export class SessionManager {
 					sessions.push({
 						path: file,
 						id: header.id,
+						title: header.title,
 						created: new Date(header.timestamp),
 						modified: stats.mtime,
 						messageCount,

package/src/core/settings-manager.ts

@@ -47,12 +47,27 @@ 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 LspSettings {
+	formatOnWrite?: boolean; // default: true (format files using LSP after write tool writes code files)
+	diagnosticsOnWrite?: boolean; // default: true (return LSP diagnostics after write tool writes code files)
+	diagnosticsOnEdit?: boolean; // default: false (return LSP diagnostics after edit tool edits code files)
+}
+
+export interface EditSettings {
+	fuzzyMatch?: boolean; // default: true (accept high-confidence fuzzy matches for whitespace/indentation)
+}
+
 export interface Settings {
 	lastChangelogVersion?: string;
-	defaultProvider?: string;
-	defaultModel?: string;
+	/** Model roles map: { default: "provider/modelId", small: "provider/modelId", ... } */
+	modelRoles?: Record<string, string>;
 	defaultThinkingLevel?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 	queueMode?: "all" | "one-at-a-time";
+	interruptMode?: "immediate" | "wait";
 	theme?: string;
 	compaction?: CompactionSettings;
 	branchSummary?: BranchSummarySettings;
@@ -67,6 +82,9 @@ export interface Settings {
 	enabledModels?: string[]; // Model patterns for cycling (same format as --models CLI flag)
 	exa?: ExaSettings;
 	bashInterceptor?: BashInterceptorSettings;
+	mcp?: MCPSettings;
+	lsp?: LspSettings;
+	edit?: EditSettings;
 }
 
 /** Deep merge settings: project/overrides take precedence, nested objects merge recursively */
@@ -195,28 +213,29 @@ export class SettingsManager {
 		this.save();
 	}
 
-	getDefaultProvider(): string | undefined {
-		return this.settings.defaultProvider;
+	/**
+	 * Get model for a role. Returns "provider/modelId" string or undefined.
+	 */
+	getModelRole(role: string): string | undefined {
+		return this.settings.modelRoles?.[role];
 	}
 
-	getDefaultModel(): string | undefined {
-		return this.settings.defaultModel;
-	}
-
-	setDefaultProvider(provider: string): void {
-		this.globalSettings.defaultProvider = provider;
-		this.save();
-	}
-
-	setDefaultModel(modelId: string): void {
-		this.globalSettings.defaultModel = modelId;
+	/**
+	 * Set model for a role. Model should be "provider/modelId" format.
+	 */
+	setModelRole(role: string, model: string): void {
+		if (!this.globalSettings.modelRoles) {
+			this.globalSettings.modelRoles = {};
+		}
+		this.globalSettings.modelRoles[role] = model;
 		this.save();
 	}
 
-	setDefaultModelAndProvider(provider: string, modelId: string): void {
-		this.globalSettings.defaultProvider = provider;
-		this.globalSettings.defaultModel = modelId;
-		this.save();
+	/**
+	 * Get all model roles.
+	 */
+	getModelRoles(): Record<string, string> {
+		return { ...this.settings.modelRoles };
 	}
 
 	getQueueMode(): "all" | "one-at-a-time" {
@@ -228,6 +247,15 @@ export class SettingsManager {
 		this.save();
 	}
 
+	getInterruptMode(): "immediate" | "wait" {
+		return this.settings.interruptMode || "immediate";
+	}
+
+	setInterruptMode(mode: "immediate" | "wait"): void {
+		this.globalSettings.interruptMode = mode;
+		this.save();
+	}
+
 	getTheme(): string | undefined {
 		return this.settings.theme;
 	}
@@ -457,4 +485,64 @@ export class SettingsManager {
 		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();
+	}
+
+	getLspFormatOnWrite(): boolean {
+		return this.settings.lsp?.formatOnWrite ?? true;
+	}
+
+	setLspFormatOnWrite(enabled: boolean): void {
+		if (!this.globalSettings.lsp) {
+			this.globalSettings.lsp = {};
+		}
+		this.globalSettings.lsp.formatOnWrite = enabled;
+		this.save();
+	}
+
+	getLspDiagnosticsOnWrite(): boolean {
+		return this.settings.lsp?.diagnosticsOnWrite ?? true;
+	}
+
+	setLspDiagnosticsOnWrite(enabled: boolean): void {
+		if (!this.globalSettings.lsp) {
+			this.globalSettings.lsp = {};
+		}
+		this.globalSettings.lsp.diagnosticsOnWrite = enabled;
+		this.save();
+	}
+
+	getLspDiagnosticsOnEdit(): boolean {
+		return this.settings.lsp?.diagnosticsOnEdit ?? false;
+	}
+
+	setLspDiagnosticsOnEdit(enabled: boolean): void {
+		if (!this.globalSettings.lsp) {
+			this.globalSettings.lsp = {};
+		}
+		this.globalSettings.lsp.diagnosticsOnEdit = enabled;
+		this.save();
+	}
+
+	getEditFuzzyMatch(): boolean {
+		return this.settings.edit?.fuzzyMatch ?? true;
+	}
+
+	setEditFuzzyMatch(enabled: boolean): void {
+		if (!this.globalSettings.edit) {
+			this.globalSettings.edit = {};
+		}
+		this.globalSettings.edit.fuzzyMatch = enabled;
+		this.save();
+	}
 }

package/src/core/title-generator.ts

@@ -0,0 +1,94 @@
+/**
+ * Generate session titles using a smol, fast model.
+ */
+
+import type { Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
+import type { ModelRegistry } from "./model-registry.js";
+import { findSmolModel } from "./model-resolver.js";
+
+const TITLE_SYSTEM_PROMPT = `Generate a very short title (3-6 words) for a coding session based on the user's first message. The title should capture the main task or topic. Output ONLY the title, nothing else. No quotes, no punctuation at the end.
+
+Examples:
+- "Fix TypeScript compilation errors"
+- "Add user authentication"
+- "Refactor database queries"
+- "Debug payment webhook"
+- "Update React components"`;
+
+const MAX_INPUT_CHARS = 2000;
+
+/**
+ * Find the best available model for title generation.
+ * Uses the configured smol model if set, otherwise auto-discovers using priority chain.
+ *
+ * @param registry Model registry
+ * @param savedSmolModel Optional saved smol model from settings (provider/modelId format)
+ */
+export async function findTitleModel(registry: ModelRegistry, savedSmolModel?: string): Promise<Model<any> | null> {
+	const model = await findSmolModel(registry, savedSmolModel);
+	return model ?? null;
+}
+
+/**
+ * Generate a title for a session based on the first user message.
+ *
+ * @param firstMessage The first user message
+ * @param registry Model registry
+ * @param savedSmolModel Optional saved smol model from settings (provider/modelId format)
+ */
+export async function generateSessionTitle(
+	firstMessage: string,
+	registry: ModelRegistry,
+	savedSmolModel?: string,
+): Promise<string | null> {
+	const model = await findTitleModel(registry, savedSmolModel);
+	if (!model) return null;
+
+	const apiKey = await registry.getApiKey(model);
+	if (!apiKey) return null;
+
+	// Truncate message if too long
+	const truncatedMessage =
+		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}...` : firstMessage;
+
+	try {
+		const response = await completeSimple(
+			model,
+			{
+				systemPrompt: TITLE_SYSTEM_PROMPT,
+				messages: [{ role: "user", content: truncatedMessage, timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				maxTokens: 30,
+			},
+		);
+
+		// Extract title from response text content
+		let title = "";
+		for (const content of response.content) {
+			if (content.type === "text") {
+				title += content.text;
+			}
+		}
+		title = title.trim();
+
+		if (!title || title.length > 60) {
+			return null;
+		}
+
+		// Clean up: remove quotes, trailing punctuation
+		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Set the terminal title using ANSI escape sequences.
+ */
+export function setTerminalTitle(title: string): void {
+	// OSC 2 sets the window title
+	process.stdout.write(`\x1b]2;${title}\x07`);
+}

package/src/core/tools/bash.ts

@@ -66,8 +66,7 @@ Usage notes:
     - If the commands are independent and can run in parallel, make multiple bash tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two bash tool calls in parallel.
     - If the commands depend on each other and must run sequentially, use a single bash call with '&&' to chain them together (e.g., \`git add . && git commit -m "message" && git push\`). For instance, if one operation must complete before another starts (like mkdir before cp, Write before Bash for git operations, or git add before git commit), run these operations sequentially instead.
     - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
-    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)
-  - Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it.`,
+    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)`,
 		parameters: bashSchema,
 		execute: async (
 			_toolCallId: string,

package/src/core/tools/edit-diff.ts

@@ -271,7 +271,7 @@ export function formatEditMatchError(
 		? options.fuzzyMatches && options.fuzzyMatches > 1
 			? `Found ${options.fuzzyMatches} high-confidence matches. Provide more context to make it unique.`
 			: `Closest match was below the ${thresholdPercent}% similarity threshold.`
-		: "Hint: Use fuzzy=true to accept high-confidence matches.";
+		: "Fuzzy matching is disabled. Enable 'Edit fuzzy match' in settings to accept high-confidence matches.";
 
 	return [
 		options.allowFuzzy
@@ -409,7 +409,7 @@ export async function computeEditDiff(
 	oldText: string,
 	newText: string,
 	cwd: string,
-	fuzzy = false,
+	fuzzy = true,
 ): Promise<EditDiffResult | EditDiffError> {
 	const absolutePath = resolveToCwd(path, cwd);
 

package/src/core/tools/edit.ts

@@ -12,6 +12,7 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "./edit-diff.js";
+import type { FileDiagnosticsResult } from "./lsp/index.js";
 import { resolveToCwd } from "./path-utils.js";
 
 const editSchema = Type.Object({
@@ -27,9 +28,21 @@ export interface EditToolDetails {
 	diff: string;
 	/** Line number of the first change in the new file (for editor navigation) */
 	firstChangedLine?: number;
+	/** Whether LSP diagnostics were retrieved */
+	hasDiagnostics?: boolean;
+	/** Diagnostic result (if available) */
+	diagnostics?: FileDiagnosticsResult;
 }
 
-export function createEditTool(cwd: string): AgentTool<typeof editSchema> {
+export interface EditToolOptions {
+	/** Whether to accept high-confidence fuzzy matches for whitespace/indentation (default: true) */
+	fuzzyMatch?: boolean;
+	/** Callback to get LSP diagnostics after editing a file */
+	getDiagnostics?: (absolutePath: string) => Promise<FileDiagnosticsResult>;
+}
+
+export function createEditTool(cwd: string, options: EditToolOptions = {}): AgentTool<typeof editSchema> {
+	const allowFuzzy = options.fuzzyMatch ?? true;
 	return {
 		name: "edit",
 		label: "Edit",
@@ -108,7 +121,7 @@ Usage:
 						const normalizedNewText = normalizeToLF(newText);
 
 						const matchOutcome = findEditMatch(normalizedContent, normalizedOldText, {
-							allowFuzzy: true,
+							allowFuzzy,
 							similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
 						});
 
@@ -131,7 +144,7 @@ Usage:
 							reject(
 								new Error(
 									formatEditMatchError(path, normalizedOldText, matchOutcome.closest, {
-										allowFuzzy: true,
+										allowFuzzy,
 										similarityThreshold: DEFAULT_FUZZY_THRESHOLD,
 										fuzzyMatches: matchOutcome.fuzzyMatches,
 									}),
@@ -179,14 +192,39 @@ Usage:
 						}
 
 						const diffResult = generateDiffString(normalizedContent, normalizedNewContent);
+
+						// Get LSP diagnostics if callback provided
+						let diagnosticsResult: FileDiagnosticsResult | undefined;
+						if (options.getDiagnostics) {
+							try {
+								diagnosticsResult = await options.getDiagnostics(absolutePath);
+							} catch {
+								// Ignore diagnostics errors - don't fail the edit
+							}
+						}
+
+						// Build result text
+						let resultText = `Successfully replaced text in ${path}.`;
+
+						// Append diagnostics if available and there are issues
+						if (diagnosticsResult?.available && diagnosticsResult.diagnostics.length > 0) {
+							resultText += `\n\nLSP Diagnostics (${diagnosticsResult.summary}):\n`;
+							resultText += diagnosticsResult.diagnostics.map((d) => `  ${d}`).join("\n");
+						}
+
 						resolve({
 							content: [
 								{
 									type: "text",
-									text: `Successfully replaced text in ${path}.`,
+									text: resultText,
 								},
 							],
-							details: { diff: diffResult.diff, firstChangedLine: diffResult.firstChangedLine },
+							details: {
+								diff: diffResult.diff,
+								firstChangedLine: diffResult.firstChangedLine,
+								hasDiagnostics: diagnosticsResult?.available ?? false,
+								diagnostics: diagnosticsResult,
+							},
 						});
 					} catch (error: any) {
 						// Clean up abort handler

package/src/core/tools/grep.ts

@@ -68,10 +68,11 @@ export function createGrepTool(cwd: string): AgentTool<typeof grepSchema> {
 
 Usage:
 - ALWAYS use grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a bash command. The grep tool has been optimized for correct permissions and access.
+- Searches recursively by default - no need for -r flag
 - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
-- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+- Filter files with glob parameter (e.g., "*.ts", "**/*.spec.ts") or type parameter (e.g., "ts", "py", "rust") - equivalent to grep's --include
 - Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
-- Use task tool for open-ended searches requiring multiple rounds
+- Pagination: Use headLimit to limit results (like \`| head -N\`), offset to skip first N results
 - Pattern syntax: Uses ripgrep (not grep) - literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
 - Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\``,
 		parameters: grepSchema,