@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/main.ts

@@ -22,7 +22,7 @@ import { selectSession } from "./cli/session-picker";
 import { findConfigFile } from "./config";
 import { ModelRegistry, ModelsConfigFile } from "./config/model-registry";
 import { resolveCliModel, resolveModelRoleValue, resolveModelScope, type ScopedModel } from "./config/model-resolver";
-import { Settings, settings } from "./config/settings";
+import { getDefault, type SettingPath, Settings, settings } from "./config/settings";
 import { initializeWithSettings } from "./discovery";
 import {
 	clearClaudePluginRootsCache,
@@ -47,7 +47,9 @@ import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage
 import type { AgentSession } from "./session/agent-session";
 import { resolveResumableSession, type SessionInfo, SessionManager } from "./session/session-manager";
 import { resolvePromptInput } from "./system-prompt";
+import type { LspStartupServerInfo } from "./tools";
 import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
+import type { EventBus } from "./utils/event-bus";
 
 async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
 	if (!settings.get("startup.checkUpdate")) {
@@ -70,6 +72,29 @@ async function checkForNewVersion(currentVersion: string): Promise<string | unde
 	}
 }
 
+const RPC_DEFAULTED_SETTING_PATHS: SettingPath[] = [
+	"todo.enabled",
+	"todo.reminders",
+	"todo.reminders.max",
+	"todo.eager",
+	"async.enabled",
+	"async.maxJobs",
+	"task.isolation.mode",
+	"task.isolation.merge",
+	"task.isolation.commits",
+	"task.eager",
+	"task.maxConcurrency",
+	"task.maxRecursionDepth",
+	"task.disabledAgents",
+	"task.agentModelOverrides",
+];
+
+function applyRpcDefaultSettingOverrides(): void {
+	for (const settingPath of RPC_DEFAULTED_SETTING_PATHS) {
+		settings.override(settingPath, getDefault(settingPath));
+	}
+}
+
 async function readPipedInput(): Promise<string | undefined> {
 	if (process.stdin.isTTY !== false) return undefined;
 	try {
@@ -117,12 +142,21 @@ async function runInteractiveMode(
 	versionCheckPromise: Promise<string | undefined>,
 	initialMessages: string[],
 	setExtensionUIContext: (uiContext: ExtensionUIContext, hasUI: boolean) => void,
-	lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[]; error?: string }> | undefined,
+	lspServers: LspStartupServerInfo[] | undefined,
 	mcpManager: MCPManager | undefined,
+	eventBus?: EventBus,
 	initialMessage?: string,
 	initialImages?: ImageContent[],
 ): Promise<void> {
-	const mode = new InteractiveMode(session, version, changelogMarkdown, setExtensionUIContext, lspServers, mcpManager);
+	const mode = new InteractiveMode(
+		session,
+		version,
+		changelogMarkdown,
+		setExtensionUIContext,
+		lspServers,
+		mcpManager,
+		eventBus,
+	);
 
 	await mode.init();
 
@@ -273,6 +307,17 @@ async function createSessionManager(parsed: Args, cwd: string): Promise<SessionM
 	if (parsed.sessionDir) {
 		return SessionManager.create(cwd, parsed.sessionDir);
 	}
+	// Auto-resume: behave like --continue if the setting is enabled and a prior
+	// session exists. When a prior session is resumed, mark parsed.continue so
+	// buildSessionOptions restores the session's model/thinking instead of
+	// overriding them with CLI defaults.
+	if (settings.get("autoResume")) {
+		const manager = await SessionManager.continueRecent(cwd, parsed.sessionDir);
+		if (manager.getEntries().length > 0) {
+			parsed.continue = true;
+		}
+		return manager;
+	}
 	// Default case (new session) returns undefined, SDK will create one
 	return undefined;
 }
@@ -521,19 +566,16 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 
 	// Initialize theme early with defaults (CLI commands need symbols)
 	// Will be re-initialized with user preferences later
-	await logger.timeAsync("initTheme:initial", () => initTheme());
+	await logger.time("initTheme:initial", initTheme);
 
 	const parsedArgs = parsed;
-	await logger.timeAsync("maybeAutoChdir", () => maybeAutoChdir(parsedArgs));
+	await logger.time("maybeAutoChdir", maybeAutoChdir, parsedArgs);
 
 	const notifs: (InteractiveModeNotify | null)[] = [];
 
 	// Create AuthStorage and ModelRegistry upfront
-	const { authStorage, modelRegistry } = await logger.timeAsync("discoverModels", async () => {
-		const authStorage = await discoverAuthStorage();
-		const modelRegistry = new ModelRegistry(authStorage);
-		return { authStorage, modelRegistry };
-	});
+	const authStorage = await logger.time("discoverModels", discoverAuthStorage);
+	const modelRegistry = new ModelRegistry(authStorage);
 
 	if (parsedArgs.version) {
 		process.stdout.write(`${VERSION}\n`);
@@ -541,7 +583,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	}
 
 	if (parsedArgs.listModels !== undefined) {
-		await logger.timeAsync("settings:init:list-models", () => Settings.init({ cwd: getProjectDir() }));
+		await logger.time("settings:init:list-models", Settings.init, { cwd: getProjectDir() });
 		await modelRegistry.refresh("online");
 		const searchPattern = typeof parsedArgs.listModels === "string" ? parsedArgs.listModels : undefined;
 		await listModels(modelRegistry, searchPattern);
@@ -568,24 +610,25 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	}
 
 	const cwd = getProjectDir();
-	await logger.timeAsync("settings:init", () => Settings.init({ cwd }));
+	await logger.time("settings:init", Settings.init, { cwd });
+	if (parsedArgs.mode === "rpc") {
+		applyRpcDefaultSettingOverrides();
+	}
 	if (parsedArgs.noPty) {
 		Bun.env.PI_NO_PTY = "1";
 	}
-	const { pipedInput, fileText, fileImages } = await logger.timeAsync("prepareInitialMessage", async () => {
+	if (parsedArgs.noTitle || parsedArgs.mode === "rpc") {
+		Bun.env.PI_NO_TITLE = "1";
+	}
+	const { pipedInput, fileText, fileImages } = await logger.time("prepareInitialMessage", async () => {
 		const pipedInput = await readPipedInput();
 		if (parsedArgs.fileArgs.length === 0) {
-			return { pipedInput };
+			return { pipedInput, fileText: undefined, fileImages: undefined };
 		}
-
-		const { text, images } = await processFileArguments(parsedArgs.fileArgs, {
+		const processed = await processFileArguments(parsedArgs.fileArgs, {
 			autoResizeImages: settings.get("images.autoResize"),
 		});
-		return {
-			pipedInput,
-			fileText: text,
-			fileImages: images,
-		};
+		return { pipedInput, fileText: processed.text, fileImages: processed.images };
 	});
 	const { initialMessage, initialImages } = buildInitialMessage({
 		parsed: parsedArgs,
@@ -598,7 +641,8 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	const mode = parsedArgs.mode || "text";
 
 	// Initialize discovery system with settings for provider persistence
-	logger.time("initializeWithSettings", () => initializeWithSettings(settings));
+	logger.time("initializeWithSettings");
+	initializeWithSettings(settings);
 	modelRegistry.refreshInBackground();
 
 	// Apply model role overrides from CLI args or env vars (ephemeral, not persisted)
@@ -613,14 +657,14 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		});
 	}
 
-	await logger.timeAsync("initTheme:final", () =>
-		initTheme(
-			isInteractive,
-			settings.get("symbolPreset"),
-			settings.get("colorBlindMode"),
-			settings.get("theme.dark"),
-			settings.get("theme.light"),
-		),
+	await logger.time(
+		"initTheme:final",
+		initTheme,
+		isInteractive,
+		settings.get("symbolPreset"),
+		settings.get("colorBlindMode"),
+		settings.get("theme.dark"),
+		settings.get("theme.light"),
 	);
 
 	let scopedModels: ScopedModel[] = [];
@@ -629,24 +673,26 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		usageOrder: settings.getStorage()?.getModelUsageOrder(),
 	};
 	if (modelPatterns && modelPatterns.length > 0) {
-		scopedModels = await logger.timeAsync("resolveModelScope", () =>
-			resolveModelScope(modelPatterns, modelRegistry, modelMatchPreferences),
+		scopedModels = await logger.time(
+			"resolveModelScope",
+			resolveModelScope,
+			modelPatterns,
+			modelRegistry,
+			modelMatchPreferences,
 		);
 	}
 
 	// Create session manager based on CLI flags
-	let sessionManager = await logger.timeAsync("createSessionManager", () => createSessionManager(parsedArgs, cwd));
+	let sessionManager = await logger.time("createSessionManager", createSessionManager, parsedArgs, cwd);
 
 	// Handle --resume (no value): show session picker
 	if (parsedArgs.resume === true && !parsedArgs.fork) {
-		const sessions = await logger.timeAsync("SessionManager.list", () =>
-			SessionManager.list(cwd, parsedArgs.sessionDir),
-		);
+		const sessions = await logger.time("SessionManager.list", SessionManager.list, cwd, parsedArgs.sessionDir);
 		if (sessions.length === 0) {
 			process.stdout.write(`${chalk.dim("No sessions found")}\n`);
 			return;
 		}
-		const selectedPath = await logger.timeAsync("selectSession", () => selectSession(sessions));
+		const selectedPath = await logger.time("selectSession", selectSession, sessions);
 		if (!selectedPath) {
 			process.stdout.write(`${chalk.dim("No session selected")}\n`);
 			return;
@@ -657,11 +703,9 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 	// Wire --plugin-dir and preload plugin roots for sync consumers (LSP config)
 	const home = os.homedir();
 	if (parsedArgs.pluginDirs && parsedArgs.pluginDirs.length > 0) {
-		await logger.timeAsync("injectPluginDirRoots", () =>
-			injectPluginDirRoots(home, parsedArgs.pluginDirs!, getProjectDir()),
-		);
+		await logger.time("injectPluginDirRoots", injectPluginDirRoots, home, parsedArgs.pluginDirs!, getProjectDir());
 	} else {
-		await logger.timeAsync("preloadPluginRoots", () => preloadPluginRoots(home, getProjectDir()));
+		await logger.time("preloadPluginRoots", preloadPluginRoots, home, getProjectDir());
 	}
 
 	// Background marketplace auto-update — never blocks startup.
@@ -698,8 +742,13 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		})();
 	}
 
-	const { options: sessionOptions } = await logger.timeAsync("buildSessionOptions", () =>
-		buildSessionOptions(parsedArgs, scopedModels, sessionManager, modelRegistry),
+	const { options: sessionOptions } = await logger.time(
+		"buildSessionOptions",
+		buildSessionOptions,
+		parsedArgs,
+		scopedModels,
+		sessionManager,
+		modelRegistry,
 	);
 	sessionOptions.authStorage = authStorage;
 	sessionOptions.modelRegistry = modelRegistry;
@@ -718,10 +767,12 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		}
 	}
 
-	const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager } = await logger.timeAsync(
+	const { session, setToolUIContext, modelFallbackMessage, lspServers, mcpManager, eventBus } = await logger.time(
 		"createAgentSession",
-		() => createAgentSession(sessionOptions),
+		createAgentSession,
+		sessionOptions,
 	);
+	logger.time("main:afterCreateSession");
 	if (parsedArgs.apiKey && !sessionOptions.model && session.model) {
 		authStorage.setRuntimeApiKey(session.model.provider, parsedArgs.apiKey);
 	}
@@ -772,12 +823,35 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 		process.exit(1);
 	}
 
+	const extensionFlagValues = session.extensionRunner?.getFlagValues() ?? new Map<string, boolean | string>();
+	const createAcpSession = async (cwd: string) => {
+		const nextSettings = await session.settings.cloneForCwd(cwd);
+		const nextSessionManager = SessionManager.create(cwd, parsedArgs.sessionDir);
+		const { session: nextSession } = await createAgentSession({
+			...sessionOptions,
+			cwd,
+			sessionManager: nextSessionManager,
+			settings: nextSettings,
+			authStorage,
+			modelRegistry,
+			searchDb: session.searchDb,
+			hasUI: false,
+		});
+		if (nextSession.extensionRunner) {
+			for (const [flagName, value] of extensionFlagValues) {
+				nextSession.extensionRunner.setFlagValue(flagName, value);
+			}
+		}
+		return nextSession;
+	};
+
 	if (mode === "rpc") {
 		await runRpcMode(session);
 	} else if (mode === "acp") {
-		await runAcpMode(session);
+		await runAcpMode(session, createAcpSession);
 	} else if (isInteractive) {
 		const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
+		logger.time("main:getChangelogForDisplay");
 		const changelogMarkdown = await getChangelogForDisplay(parsedArgs);
 
 		const scopedModelsForDisplay = sessionOptions.scopedModels ?? scopedModels;
@@ -791,8 +865,11 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 			process.stdout.write(`${chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`)}\n`);
 		}
 
-		if ($env.PI_TIMING === "1") {
+		if ($env.PI_TIMING) {
 			logger.printTimings();
+			if ($env.PI_TIMING === "x") {
+				process.exit(0);
+			}
 		}
 
 		logger.endTiming();
@@ -806,6 +883,7 @@ export async function runRootCommand(parsed: Args, rawArgs: string[]): Promise<v
 			setToolUIContext,
 			lspServers,
 			mcpManager,
+			eventBus,
 			initialMessage,
 			initialImages,
 		);

package/src/memories/index.ts

@@ -4,10 +4,9 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { completeSimple, Effort, type Model } from "@oh-my-pi/pi-ai";
-import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient } from "@oh-my-pi/pi-utils";
+import { getAgentDbPath, getMemoriesDir, logger, parseJsonlLenient, prompt } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../config/model-registry";
 import { parseModelString } from "../config/model-resolver";
-import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Settings } from "../config/settings";
 import consolidationTemplate from "../prompts/memories/consolidation.md" with { type: "text" };
 import readPathTemplate from "../prompts/memories/read-path.md" with { type: "text" };
@@ -166,7 +165,7 @@ export async function buildMemoryToolDeveloperInstructions(
 	const truncated = truncateByApproxTokens(summary, cfg.summaryInjectionTokenLimit);
 	if (!truncated.trim()) return undefined;
 
-	return renderPromptTemplate(readPathTemplate, {
+	return prompt.render(readPathTemplate, {
 		memory_summary: truncated,
 	});
 }
@@ -585,7 +584,7 @@ async function runStage1Job(options: {
 		const serializedItems = JSON.stringify(persisted);
 		const budgetTokens = Math.floor(modelMaxTokens * config.rolloutPayloadPercent);
 		const truncatedItems = truncateByApproxTokens(serializedItems, budgetTokens);
-		const inputPrompt = renderPromptTemplate(stageOneInputTemplate, {
+		const inputPrompt = prompt.render(stageOneInputTemplate, {
 			thread_id: claim.threadId,
 			response_items_json: truncatedItems,
 		});
@@ -716,7 +715,7 @@ async function runConsolidationModel(options: { memoryRoot: string; model: Model
 	const { memoryRoot, model, apiKey } = options;
 	const rawMemories = await Bun.file(path.join(memoryRoot, "raw_memories.md")).text();
 	const rolloutSummaries = await readRolloutSummaries(memoryRoot);
-	const input = renderPromptTemplate(consolidationTemplate, {
+	const input = prompt.render(consolidationTemplate, {
 		raw_memories: truncateByApproxTokens(rawMemories, 20_000),
 		rollout_summaries: truncateByApproxTokens(rolloutSummaries, 12_000),
 	});