@oh-my-pi/pi-coding-agent 0.1.0

package/src/main.ts

@@ -0,0 +1,507 @@
+/**
+ * Main entry point for the coding agent CLI.
+ *
+ * This file handles CLI argument parsing and translates them into
+ * createAgentSession() options. The SDK does the heavy lifting.
+ */
+
+import { type ImageContent, supportsXhigh } from "@oh-my-pi/pi-ai";
+import chalk from "chalk";
+import { type Args, parseArgs, printHelp } from "./cli/args";
+import { processFileArguments } from "./cli/file-processor";
+import { listModels } from "./cli/list-models";
+import { parsePluginArgs, printPluginHelp, runPluginCommand } from "./cli/plugin-cli";
+import { selectSession } from "./cli/session-picker";
+import { parseUpdateArgs, printUpdateHelp, runUpdateCommand } from "./cli/update-cli";
+import { findConfigFile, getModelsPath, VERSION } from "./config";
+import type { AgentSession } from "./core/agent-session";
+import type { LoadedCustomTool } from "./core/custom-tools/index";
+import { exportFromFile } from "./core/export-html/index";
+import type { HookUIContext } from "./core/index";
+import type { ModelRegistry } from "./core/model-registry";
+import { parseModelPattern, resolveModelScope, type ScopedModel } from "./core/model-resolver";
+import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage, discoverModels } from "./core/sdk";
+import { SessionManager } from "./core/session-manager";
+import { SettingsManager } from "./core/settings-manager";
+import { resolvePromptInput } from "./core/system-prompt";
+import { printTimings, time } from "./core/timings";
+import { allTools } from "./core/tools/index";
+import { runMigrations } from "./migrations";
+import { InteractiveMode, installTerminalCrashHandlers, runPrintMode, runRpcMode } from "./modes/index";
+import { initTheme, stopThemeWatcher } from "./modes/interactive/theme/theme";
+import { getChangelogPath, getNewEntries, parseChangelog } from "./utils/changelog";
+import { ensureTool } from "./utils/tools-manager";
+
+async function checkForNewVersion(currentVersion: string): Promise<string | undefined> {
+	try {
+		const response = await fetch("https://registry.npmjs.org/@oh-my-pi/pi-coding-agent/latest");
+		if (!response.ok) return undefined;
+
+		const data = (await response.json()) as { version?: string };
+		const latestVersion = data.version;
+
+		if (latestVersion && latestVersion !== currentVersion) {
+			return latestVersion;
+		}
+
+		return undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+async function runInteractiveMode(
+	session: AgentSession,
+	version: string,
+	changelogMarkdown: string | undefined,
+	modelFallbackMessage: string | undefined,
+	modelsJsonError: string | undefined,
+	migratedProviders: string[],
+	versionCheckPromise: Promise<string | undefined>,
+	initialMessages: string[],
+	customTools: LoadedCustomTool[],
+	setToolUIContext: (uiContext: HookUIContext, hasUI: boolean) => void,
+	lspServers: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }> | undefined,
+	initialMessage?: string,
+	initialImages?: ImageContent[],
+	fdPath: string | undefined = undefined,
+): Promise<void> {
+	const mode = new InteractiveMode(
+		session,
+		version,
+		changelogMarkdown,
+		customTools,
+		setToolUIContext,
+		lspServers,
+		fdPath,
+	);
+
+	await mode.init();
+
+	versionCheckPromise.then((newVersion) => {
+		if (newVersion) {
+			mode.showNewVersionNotification(newVersion);
+		}
+	});
+
+	mode.renderInitialMessages();
+
+	if (migratedProviders.length > 0) {
+		mode.showWarning(`Migrated credentials to auth.json: ${migratedProviders.join(", ")}`);
+	}
+
+	if (modelsJsonError) {
+		mode.showError(`models.json error: ${modelsJsonError}`);
+	}
+
+	if (modelFallbackMessage) {
+		mode.showWarning(modelFallbackMessage);
+	}
+
+	if (initialMessage) {
+		try {
+			await session.prompt(initialMessage, { images: initialImages });
+		} catch (error: unknown) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			mode.showError(errorMessage);
+		}
+	}
+
+	for (const message of initialMessages) {
+		try {
+			await session.prompt(message);
+		} catch (error: unknown) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			mode.showError(errorMessage);
+		}
+	}
+
+	while (true) {
+		const { text, images } = await mode.getUserInput();
+		try {
+			await session.prompt(text, { images });
+		} catch (error: unknown) {
+			const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
+			mode.showError(errorMessage);
+		}
+	}
+}
+
+async function prepareInitialMessage(parsed: Args): Promise<{
+	initialMessage?: string;
+	initialImages?: ImageContent[];
+}> {
+	if (parsed.fileArgs.length === 0) {
+		return {};
+	}
+
+	const { text, images } = await processFileArguments(parsed.fileArgs);
+
+	let initialMessage: string;
+	if (parsed.messages.length > 0) {
+		initialMessage = text + parsed.messages[0];
+		parsed.messages.shift();
+	} else {
+		initialMessage = text;
+	}
+
+	return {
+		initialMessage,
+		initialImages: images.length > 0 ? images : undefined,
+	};
+}
+
+function getChangelogForDisplay(parsed: Args, settingsManager: SettingsManager): string | undefined {
+	if (parsed.continue || parsed.resume) {
+		return undefined;
+	}
+
+	const lastVersion = settingsManager.getLastChangelogVersion();
+	const changelogPath = getChangelogPath();
+	const entries = parseChangelog(changelogPath);
+
+	if (!lastVersion) {
+		if (entries.length > 0) {
+			settingsManager.setLastChangelogVersion(VERSION);
+			return entries.map((e) => e.content).join("\n\n");
+		}
+	} else {
+		const newEntries = getNewEntries(entries, lastVersion);
+		if (newEntries.length > 0) {
+			settingsManager.setLastChangelogVersion(VERSION);
+			return newEntries.map((e) => e.content).join("\n\n");
+		}
+	}
+
+	return undefined;
+}
+
+async function createSessionManager(parsed: Args, cwd: string): Promise<SessionManager | undefined> {
+	if (parsed.noSession) {
+		return SessionManager.inMemory();
+	}
+	if (parsed.session) {
+		return await SessionManager.open(parsed.session, parsed.sessionDir);
+	}
+	if (parsed.continue) {
+		return await SessionManager.continueRecent(cwd, parsed.sessionDir);
+	}
+	// --resume is handled separately (needs picker UI)
+	// If --session-dir provided without --continue/--resume, create new session there
+	if (parsed.sessionDir) {
+		return SessionManager.create(cwd, parsed.sessionDir);
+	}
+	// Default case (new session) returns undefined, SDK will create one
+	return undefined;
+}
+
+/** Discover SYSTEM.md file if no CLI system prompt was provided */
+function discoverSystemPromptFile(): string | undefined {
+	// Check project-local first (.omp/SYSTEM.md, .pi/SYSTEM.md legacy)
+	const projectPath = findConfigFile("SYSTEM.md", { user: false });
+	if (projectPath) {
+		return projectPath;
+	}
+	// If not found, check SYSTEM.md file in the global directory.
+	const globalPath = findConfigFile("SYSTEM.md", { user: true });
+	if (globalPath) {
+		return globalPath;
+	}
+	return undefined;
+}
+
+async function buildSessionOptions(
+	parsed: Args,
+	scopedModels: ScopedModel[],
+	sessionManager: SessionManager | undefined,
+	modelRegistry: ModelRegistry,
+): Promise<CreateAgentSessionOptions> {
+	const options: CreateAgentSessionOptions = {};
+
+	// Auto-discover SYSTEM.md if no CLI system prompt provided
+	const systemPromptSource = parsed.systemPrompt ?? discoverSystemPromptFile();
+	const resolvedSystemPrompt = resolvePromptInput(systemPromptSource, "system prompt");
+	const resolvedAppendPrompt = resolvePromptInput(parsed.appendSystemPrompt, "append system prompt");
+
+	if (sessionManager) {
+		options.sessionManager = sessionManager;
+	}
+
+	// Model from CLI (--model) - uses same fuzzy matching as --models
+	if (parsed.model) {
+		const available = await modelRegistry.getAvailable();
+		const { model, warning } = parseModelPattern(parsed.model, available);
+		if (warning) {
+			console.warn(chalk.yellow(`Warning: ${warning}`));
+		}
+		if (!model) {
+			console.error(chalk.red(`Model "${parsed.model}" not found`));
+			process.exit(1);
+		}
+		options.model = model;
+	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+		options.model = scopedModels[0].model;
+	}
+
+	// Thinking level
+	if (parsed.thinking) {
+		options.thinkingLevel = parsed.thinking;
+	} else if (scopedModels.length > 0 && !parsed.continue && !parsed.resume) {
+		options.thinkingLevel = scopedModels[0].thinkingLevel;
+	}
+
+	// Scoped models for Ctrl+P cycling
+	if (scopedModels.length > 0) {
+		options.scopedModels = scopedModels;
+	}
+
+	// API key from CLI - set in authStorage
+	// (handled by caller before createAgentSession)
+
+	// System prompt
+	if (resolvedSystemPrompt && resolvedAppendPrompt) {
+		options.systemPrompt = `${resolvedSystemPrompt}\n\n${resolvedAppendPrompt}`;
+	} else if (resolvedSystemPrompt) {
+		options.systemPrompt = resolvedSystemPrompt;
+	} else if (resolvedAppendPrompt) {
+		options.systemPrompt = (defaultPrompt) => `${defaultPrompt}\n\n${resolvedAppendPrompt}`;
+	}
+
+	// Tools
+	if (parsed.tools) {
+		options.tools = parsed.tools.map((name) => allTools[name]);
+		options.explicitTools = parsed.tools;
+	}
+
+	// Skills
+	if (parsed.noSkills) {
+		options.skills = [];
+	}
+
+	// Additional hook paths from CLI
+	if (parsed.hooks && parsed.hooks.length > 0) {
+		options.additionalHookPaths = parsed.hooks;
+	}
+
+	// Additional custom tool paths from CLI
+	if (parsed.customTools && parsed.customTools.length > 0) {
+		options.additionalCustomToolPaths = parsed.customTools;
+	}
+
+	return options;
+}
+
+export async function main(args: string[]) {
+	time("start");
+
+	// Initialize theme early with defaults (CLI commands need symbols)
+	// Will be re-initialized with user preferences later
+	initTheme();
+
+	// Handle plugin subcommand before regular parsing
+	const pluginCmd = parsePluginArgs(args);
+	if (pluginCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printPluginHelp();
+			return;
+		}
+		await runPluginCommand(pluginCmd);
+		return;
+	}
+
+	// Handle update subcommand
+	const updateCmd = parseUpdateArgs(args);
+	if (updateCmd) {
+		if (args.includes("--help") || args.includes("-h")) {
+			printUpdateHelp();
+			return;
+		}
+		await runUpdateCommand(updateCmd);
+		return;
+	}
+
+	// Run migrations
+	const { migratedAuthProviders: migratedProviders } = runMigrations();
+
+	// Create AuthStorage and ModelRegistry upfront
+	const authStorage = discoverAuthStorage();
+	const modelRegistry = discoverModels(authStorage);
+	time("discoverModels");
+
+	const parsed = parseArgs(args);
+	time("parseArgs");
+
+	if (parsed.version) {
+		console.log(VERSION);
+		return;
+	}
+
+	if (parsed.help) {
+		printHelp();
+		return;
+	}
+
+	if (parsed.listModels !== undefined) {
+		const searchPattern = typeof parsed.listModels === "string" ? parsed.listModels : undefined;
+		await listModels(modelRegistry, searchPattern);
+		return;
+	}
+
+	if (parsed.export) {
+		try {
+			const outputPath = parsed.messages.length > 0 ? parsed.messages[0] : undefined;
+			const result = await exportFromFile(parsed.export, outputPath);
+			console.log(`Exported to: ${result}`);
+			return;
+		} catch (error: unknown) {
+			const message = error instanceof Error ? error.message : "Failed to export session";
+			console.error(chalk.red(`Error: ${message}`));
+			process.exit(1);
+		}
+	}
+
+	if (parsed.mode === "rpc" && parsed.fileArgs.length > 0) {
+		console.error(chalk.red("Error: @file arguments are not supported in RPC mode"));
+		process.exit(1);
+	}
+
+	const cwd = process.cwd();
+	const { initialMessage, initialImages } = await prepareInitialMessage(parsed);
+	time("prepareInitialMessage");
+	const isInteractive = !parsed.print && parsed.mode === undefined;
+	const mode = parsed.mode || "text";
+
+	const settingsManager = SettingsManager.create(cwd);
+	time("SettingsManager.create");
+
+	// Initialize discovery system with settings for provider persistence
+	const { initializeWithSettings } = await import("./discovery");
+	initializeWithSettings(settingsManager);
+	time("initializeWithSettings");
+
+	// Apply model role overrides from CLI args or env vars (ephemeral, not persisted)
+	const smolModel = parsed.smol ?? process.env.OMP_SMOL_MODEL;
+	const slowModel = parsed.slow ?? process.env.OMP_SLOW_MODEL;
+	if (smolModel || slowModel) {
+		const roleOverrides: Record<string, string> = {};
+		if (smolModel) roleOverrides.smol = smolModel;
+		if (slowModel) roleOverrides.slow = slowModel;
+		settingsManager.applyOverrides({ modelRoles: roleOverrides });
+	}
+
+	initTheme(settingsManager.getTheme(), isInteractive, settingsManager.getSymbolPreset());
+	time("initTheme");
+
+	let scopedModels: ScopedModel[] = [];
+	const modelPatterns = parsed.models ?? settingsManager.getEnabledModels();
+	if (modelPatterns && modelPatterns.length > 0) {
+		scopedModels = await resolveModelScope(modelPatterns, modelRegistry);
+		time("resolveModelScope");
+	}
+
+	// Create session manager based on CLI flags
+	let sessionManager = await createSessionManager(parsed, cwd);
+	time("createSessionManager");
+
+	// Handle --resume: show session picker
+	if (parsed.resume) {
+		const sessions = SessionManager.list(cwd, parsed.sessionDir);
+		time("SessionManager.list");
+		if (sessions.length === 0) {
+			console.log(chalk.dim("No sessions found"));
+			return;
+		}
+		const selectedPath = await selectSession(sessions);
+		time("selectSession");
+		if (!selectedPath) {
+			console.log(chalk.dim("No session selected"));
+			return;
+		}
+		sessionManager = await SessionManager.open(selectedPath);
+	}
+
+	const sessionOptions = await buildSessionOptions(parsed, scopedModels, sessionManager, modelRegistry);
+	sessionOptions.authStorage = authStorage;
+	sessionOptions.modelRegistry = modelRegistry;
+	sessionOptions.hasUI = isInteractive;
+
+	// Handle CLI --api-key as runtime override (not persisted)
+	if (parsed.apiKey) {
+		if (!sessionOptions.model) {
+			console.error(chalk.red("--api-key requires a model to be specified via --provider/--model or -m/--models"));
+			process.exit(1);
+		}
+		authStorage.setRuntimeApiKey(sessionOptions.model.provider, parsed.apiKey);
+	}
+
+	time("buildSessionOptions");
+	const { session, customToolsResult, modelFallbackMessage, lspServers } = await createAgentSession(sessionOptions);
+	time("createAgentSession");
+
+	if (!isInteractive && !session.model) {
+		console.error(chalk.red("No models available."));
+		console.error(chalk.yellow("\nSet an API key environment variable:"));
+		console.error("  ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, etc.");
+		console.error(chalk.yellow(`\nOr create ${getModelsPath()}`));
+		process.exit(1);
+	}
+
+	// Clamp thinking level to model capabilities (for CLI override case)
+	if (session.model && parsed.thinking) {
+		let effectiveThinking = parsed.thinking;
+		if (!session.model.reasoning) {
+			effectiveThinking = "off";
+		} else if (effectiveThinking === "xhigh" && !supportsXhigh(session.model)) {
+			effectiveThinking = "high";
+		}
+		if (effectiveThinking !== session.thinkingLevel) {
+			session.setThinkingLevel(effectiveThinking);
+		}
+	}
+
+	if (mode === "rpc") {
+		await runRpcMode(session);
+	} else if (isInteractive) {
+		const versionCheckPromise = checkForNewVersion(VERSION).catch(() => undefined);
+		const changelogMarkdown = getChangelogForDisplay(parsed, settingsManager);
+
+		if (scopedModels.length > 0) {
+			const modelList = scopedModels
+				.map((sm) => {
+					const thinkingStr = sm.thinkingLevel !== "off" ? `:${sm.thinkingLevel}` : "";
+					return `${sm.model.id}${thinkingStr}`;
+				})
+				.join(", ");
+			console.log(chalk.dim(`Model scope: ${modelList} ${chalk.gray("(Ctrl+P to cycle)")}`));
+		}
+
+		const fdPath = await ensureTool("fd");
+		time("ensureTool(fd)");
+
+		installTerminalCrashHandlers();
+		printTimings();
+		await runInteractiveMode(
+			session,
+			VERSION,
+			changelogMarkdown,
+			modelFallbackMessage,
+			modelRegistry.getError(),
+			migratedProviders,
+			versionCheckPromise,
+			parsed.messages,
+			customToolsResult.tools,
+			customToolsResult.setUIContext,
+			lspServers,
+			initialMessage,
+			initialImages,
+			fdPath,
+		);
+	} else {
+		await runPrintMode(session, mode, parsed.messages, initialMessage, initialImages);
+		stopThemeWatcher();
+		if (process.stdout.writableLength > 0) {
+			await new Promise<void>((resolve) => process.stdout.once("drain", resolve));
+		}
+		process.exit(0);
+	}
+}

package/src/migrations.ts

@@ -0,0 +1,156 @@
+/**
+ * One-time migrations that run on startup.
+ */
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getAgentDir } from "./config";
+
+/**
+ * Migrate PI_* environment variables to OMP_* equivalents.
+ * If PI_XX is set and OMP_XX is not, set OMP_XX to PI_XX's value.
+ * This provides backwards compatibility for users with existing PI_* env vars.
+ */
+export function migrateEnvVars(): void {
+	for (const [key, value] of Object.entries(process.env)) {
+		if (key.startsWith("PI_") && value !== undefined) {
+			const ompKey = `OMP_${key.slice(3)}`; // PI_FOO -> OMP_FOO
+			if (process.env[ompKey] === undefined) {
+				process.env[ompKey] = value;
+			}
+		}
+	}
+}
+
+/**
+ * Migrate legacy oauth.json and settings.json apiKeys to auth.json.
+ *
+ * @returns Array of provider names that were migrated
+ */
+export function migrateAuthToAuthJson(): string[] {
+	const agentDir = getAgentDir();
+	const authPath = join(agentDir, "auth.json");
+	const oauthPath = join(agentDir, "oauth.json");
+	const settingsPath = join(agentDir, "settings.json");
+
+	// Skip if auth.json already exists
+	if (existsSync(authPath)) return [];
+
+	const migrated: Record<string, unknown> = {};
+	const providers: string[] = [];
+
+	// Migrate oauth.json
+	if (existsSync(oauthPath)) {
+		try {
+			const oauth = JSON.parse(readFileSync(oauthPath, "utf-8"));
+			for (const [provider, cred] of Object.entries(oauth)) {
+				migrated[provider] = { type: "oauth", ...(cred as object) };
+				providers.push(provider);
+			}
+			renameSync(oauthPath, `${oauthPath}.migrated`);
+		} catch {
+			// Skip on error
+		}
+	}
+
+	// Migrate settings.json apiKeys
+	if (existsSync(settingsPath)) {
+		try {
+			const content = readFileSync(settingsPath, "utf-8");
+			const settings = JSON.parse(content);
+			if (settings.apiKeys && typeof settings.apiKeys === "object") {
+				for (const [provider, key] of Object.entries(settings.apiKeys)) {
+					if (!migrated[provider] && typeof key === "string") {
+						migrated[provider] = { type: "api_key", key };
+						providers.push(provider);
+					}
+				}
+				delete settings.apiKeys;
+				writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+			}
+		} catch {
+			// Skip on error
+		}
+	}
+
+	if (Object.keys(migrated).length > 0) {
+		mkdirSync(dirname(authPath), { recursive: true });
+		writeFileSync(authPath, JSON.stringify(migrated, null, 2), { mode: 0o600 });
+	}
+
+	return providers;
+}
+
+/**
+ * Migrate sessions from ~/.omp/agent/*.jsonl to proper session directories.
+ *
+ * Bug in v0.30.0: Sessions were saved to ~/.omp/agent/ instead of
+ * ~/.omp/agent/sessions/<encoded-cwd>/. This migration moves them
+ * to the correct location based on the cwd in their session header.
+ *
+ * See: https://github.com/badlogic/pi-mono/issues/320
+ */
+export function migrateSessionsFromAgentRoot(): void {
+	const agentDir = getAgentDir();
+
+	// Find all .jsonl files directly in agentDir (not in subdirectories)
+	let files: string[];
+	try {
+		files = readdirSync(agentDir)
+			.filter((f) => f.endsWith(".jsonl"))
+			.map((f) => join(agentDir, f));
+	} catch {
+		return;
+	}
+
+	if (files.length === 0) return;
+
+	for (const file of files) {
+		try {
+			// Read first line to get session header
+			const content = readFileSync(file, "utf8");
+			const firstLine = content.split("\n")[0];
+			if (!firstLine?.trim()) continue;
+
+			const header = JSON.parse(firstLine);
+			if (header.type !== "session" || !header.cwd) continue;
+
+			const cwd: string = header.cwd;
+
+			// Compute the correct session directory (same encoding as session-manager.ts)
+			const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
+			const correctDir = join(agentDir, "sessions", safePath);
+
+			// Create directory if needed
+			if (!existsSync(correctDir)) {
+				mkdirSync(correctDir, { recursive: true });
+			}
+
+			// Move the file
+			const fileName = file.split("/").pop() || file.split("\\").pop();
+			const newPath = join(correctDir, fileName!);
+
+			if (existsSync(newPath)) continue; // Skip if target exists
+
+			renameSync(file, newPath);
+		} catch {
+			// Skip files that can't be migrated
+		}
+	}
+}
+
+/**
+ * Run all migrations. Called once on startup.
+ *
+ * @returns Object with migration results
+ */
+export function runMigrations(): { migratedAuthProviders: string[] } {
+	// First: migrate env vars (before anything else reads them)
+	migrateEnvVars();
+
+	// Then: run data migrations
+	const migratedAuthProviders = migrateAuthToAuthJson();
+	migrateSessionsFromAgentRoot();
+
+	return { migratedAuthProviders };
+}

package/src/modes/cleanup.ts

@@ -0,0 +1,23 @@
+/**
+ * Async cleanup registry for graceful shutdown on signals.
+ */
+
+/** Registry of async cleanup callbacks to run on shutdown/signals */
+const asyncCleanupCallbacks: (() => Promise<void>)[] = [];
+
+/**
+ * Register an async cleanup callback to be run on process signals (SIGINT, SIGTERM, SIGHUP).
+ * Returns an unsubscribe function.
+ */
+export function registerAsyncCleanup(callback: () => Promise<void>): () => void {
+	asyncCleanupCallbacks.push(callback);
+	return () => {
+		const index = asyncCleanupCallbacks.indexOf(callback);
+		if (index >= 0) asyncCleanupCallbacks.splice(index, 1);
+	};
+}
+
+/** Run all registered async cleanup callbacks, settling all promises */
+export async function runAsyncCleanup(): Promise<void> {
+	await Promise.allSettled(asyncCleanupCallbacks.map((cb) => cb()));
+}