@oh-my-pi/pi-coding-agent 4.1.0 → 4.2.1

package/src/core/settings-manager.ts

@@ -1,9 +1,11 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { existsSync, readFileSync, renameSync } from "node:fs";
+import { join } from "node:path";
 import { type Settings as SettingsItem, settingsCapability } from "../capability/settings";
-import { getAgentDir } from "../config";
+import { getAgentDbPath, getAgentDir } from "../config";
 import { loadSync } from "../discovery";
 import type { SymbolPreset } from "../modes/interactive/theme/theme";
+import { AgentStorage } from "./agent-storage";
+import { logger } from "./logger";
 
 export interface CompactionSettings {
 	enabled?: boolean; // default: true
@@ -337,10 +339,36 @@ function normalizeBashInterceptorSettings(
 	return { enabled, simpleLs, patterns };
 }
 
+let cachedNerdFonts: boolean | null = null;
+
+function hasNerdFonts(): boolean {
+	if (cachedNerdFonts !== null) {
+		return cachedNerdFonts;
+	}
+
+	const envOverride = process.env.NERD_FONTS;
+	if (envOverride === "1") {
+		cachedNerdFonts = true;
+		return true;
+	}
+	if (envOverride === "0") {
+		cachedNerdFonts = false;
+		return false;
+	}
+
+	const termProgram = (process.env.TERM_PROGRAM || "").toLowerCase();
+	const term = (process.env.TERM || "").toLowerCase();
+	const nerdTerms = ["iterm", "wezterm", "kitty", "ghostty", "alacritty"];
+	cachedNerdFonts = nerdTerms.some((candidate) => termProgram.includes(candidate) || term.includes(candidate));
+	return cachedNerdFonts;
+}
+
 function normalizeSettings(settings: Settings): Settings {
 	const merged = deepMergeSettings(DEFAULT_SETTINGS, settings);
+	const symbolPreset = merged.symbolPreset ?? (hasNerdFonts() ? "nerd" : "unicode");
 	return {
 		...merged,
+		symbolPreset,
 		bashInterceptor: normalizeBashInterceptorSettings(merged.bashInterceptor),
 	};
 }
@@ -377,15 +405,23 @@ function deepMergeSettings(base: Settings, overrides: Settings): Settings {
 }
 
 export class SettingsManager {
-	private settingsPath: string | null;
+	/** SQLite storage for persisted settings (null for in-memory mode) */
+	private storage: AgentStorage | null;
 	private cwd: string | null;
 	private globalSettings: Settings;
 	private overrides: Settings;
 	private settings!: Settings;
 	private persist: boolean;
 
-	private constructor(settingsPath: string | null, cwd: string | null, initialSettings: Settings, persist: boolean) {
-		this.settingsPath = settingsPath;
+	/**
+	 * Private constructor - use static factory methods instead.
+	 * @param storage - SQLite storage instance for persistence, or null for in-memory mode
+	 * @param cwd - Current working directory for project settings discovery
+	 * @param initialSettings - Initial global settings to use
+	 * @param persist - Whether to persist settings changes to storage
+	 */
+	private constructor(storage: AgentStorage | null, cwd: string | null, initialSettings: Settings, persist: boolean) {
+		this.storage = storage;
 		this.cwd = cwd;
 		this.persist = persist;
 		this.globalSettings = initialSettings;
@@ -416,9 +452,15 @@ export class SettingsManager {
 		}
 	}
 
-	/** Create a SettingsManager that loads from files */
+	/**
+	 * Create a SettingsManager that loads from persistent SQLite storage.
+	 * @param cwd - Current working directory for project settings discovery
+	 * @param agentDir - Agent directory containing agent.db
+	 * @returns Configured SettingsManager with merged global and user settings
+	 */
 	static create(cwd: string = process.cwd(), agentDir: string = getAgentDir()): SettingsManager {
-		const settingsPath = join(agentDir, "settings.json");
+		const storage = AgentStorage.open(getAgentDbPath(agentDir));
+		SettingsManager.migrateLegacySettingsFile(storage, agentDir);
 
 		// Use capability API to load user-level settings from all providers
 		const result = loadSync(settingsCapability.id, { cwd });
@@ -431,29 +473,58 @@ export class SettingsManager {
 			}
 		}
 
-		// Also load from agentDir for backward compatibility (if not covered by providers)
-		const legacySettings = SettingsManager.loadFromFile(settingsPath);
-		globalSettings = deepMergeSettings(globalSettings, legacySettings);
+		// Load persisted settings from agent.db (legacy settings.json is migrated separately)
+		const storedSettings = SettingsManager.loadFromStorage(storage);
+		globalSettings = deepMergeSettings(globalSettings, storedSettings);
 
-		return new SettingsManager(settingsPath, cwd, globalSettings, true);
+		return new SettingsManager(storage, cwd, globalSettings, true);
 	}
 
-	/** Create an in-memory SettingsManager (no file I/O) */
+	/**
+	 * Create an in-memory SettingsManager without persistence.
+	 * @param settings - Initial settings to use
+	 * @returns SettingsManager that won't persist changes to disk
+	 */
 	static inMemory(settings: Partial<Settings> = {}): SettingsManager {
 		return new SettingsManager(null, null, settings, false);
 	}
 
-	private static loadFromFile(path: string): Settings {
-		if (!existsSync(path)) {
+	/**
+	 * Load settings from SQLite storage, applying any schema migrations.
+	 * @param storage - AgentStorage instance, or null for in-memory mode
+	 * @returns Parsed and migrated settings, or empty object if storage is null/empty
+	 */
+	private static loadFromStorage(storage: AgentStorage | null): Settings {
+		if (!storage) {
 			return {};
 		}
+		const settings = storage.getSettings();
+		if (!settings) {
+			return {};
+		}
+		return SettingsManager.migrateSettings(settings as Record<string, unknown>);
+	}
+
+	private static migrateLegacySettingsFile(storage: AgentStorage, agentDir: string): void {
+		const settingsPath = join(agentDir, "settings.json");
+		if (!existsSync(settingsPath)) return;
+		if (storage.getSettings() !== null) return;
+
 		try {
-			const content = readFileSync(path, "utf-8");
-			const settings = JSON.parse(content);
-			return SettingsManager.migrateSettings(settings as Record<string, unknown>);
+			const content = readFileSync(settingsPath, "utf-8");
+			const parsed = JSON.parse(content);
+			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+				return;
+			}
+			const migrated = SettingsManager.migrateSettings(parsed as Record<string, unknown>);
+			storage.saveSettings(migrated);
+			try {
+				renameSync(settingsPath, `${settingsPath}.bak`);
+			} catch (error) {
+				logger.warn("SettingsManager failed to backup settings.json", { error: String(error) });
+			}
 		} catch (error) {
-			console.error(`Warning: Could not read settings file ${path}: ${error}`);
-			return {};
+			logger.warn("SettingsManager failed to migrate settings.json", { error: String(error) });
 		}
 	}
 
@@ -497,24 +568,19 @@ export class SettingsManager {
 		this.rebuildSettings();
 	}
 
+	/**
+	 * Persist current global settings to SQLite storage and rebuild merged settings.
+	 * Merges with any concurrent changes in storage before saving.
+	 */
 	private save(): void {
-		if (this.persist && this.settingsPath) {
+		if (this.persist && this.storage) {
 			try {
-				const dir = dirname(this.settingsPath);
-				if (!existsSync(dir)) {
-					mkdirSync(dir, { recursive: true });
-				}
-
-				// Re-read current file to preserve any settings added externally while running
-				const currentFileSettings = SettingsManager.loadFromFile(this.settingsPath);
-				// Merge: file settings as base, globalSettings (in-memory changes) as overrides
-				const mergedSettings = deepMergeSettings(currentFileSettings, this.globalSettings);
+				const currentSettings = this.storage.getSettings() ?? {};
+				const mergedSettings = deepMergeSettings(currentSettings, this.globalSettings);
 				this.globalSettings = mergedSettings;
-
-				// Save merged settings (project settings are read-only)
-				writeFileSync(this.settingsPath, JSON.stringify(this.globalSettings, null, 2), "utf-8");
+				this.storage.saveSettings(this.globalSettings);
 			} catch (error) {
-				console.error(`Warning: Could not save settings file: ${error}`);
+				logger.warn("SettingsManager save failed", { error: String(error) });
 			}
 		}
 

package/src/core/slash-commands.ts

@@ -2,6 +2,7 @@ import { slashCommandCapability } from "../capability/slash-command";
 import type { SlashCommand } from "../discovery";
 import { loadSync } from "../discovery";
 import { parseFrontmatter } from "../discovery/helpers";
+import { renderPromptTemplate } from "./prompt-templates";
 import { EMBEDDED_COMMAND_TEMPLATES } from "./tools/task/commands";
 
 /**
@@ -158,7 +159,9 @@ export function expandSlashCommand(text: string, fileCommands: FileSlashCommand[
 	const fileCommand = fileCommands.find((cmd) => cmd.name === commandName);
 	if (fileCommand) {
 		const args = parseCommandArgs(argsString);
-		return substituteArgs(fileCommand.content, args);
+		const argsText = args.join(" ");
+		const substituted = substituteArgs(fileCommand.content, args);
+		return renderPromptTemplate(substituted, { args, ARGUMENTS: argsText, arguments: argsText });
 	}
 
 	return text;

package/src/core/storage-migration.ts

@@ -0,0 +1,215 @@
+/**
+ * Migrates legacy JSON storage (settings.json, auth.json) to SQLite-based agent.db.
+ * Settings migrate only when the DB has no settings; auth merges per-provider when missing.
+ * Original JSON files are backed up to .bak and removed after successful migration.
+ */
+
+import { getAgentDbPath } from "../config";
+import { AgentStorage } from "./agent-storage";
+import type { AuthCredential, AuthCredentialEntry, AuthStorageData } from "./auth-storage";
+import { logger } from "./logger";
+import type { Settings } from "./settings-manager";
+
+/** Paths configuration for the storage migration process. */
+type MigrationPaths = {
+	/** Directory containing agent.db */
+	agentDir: string;
+	/** Path to legacy settings.json file */
+	settingsPath: string;
+	/** Candidate paths to search for auth.json (checked in order) */
+	authPaths: string[];
+};
+
+/** Result of the JSON-to-SQLite storage migration. */
+export interface StorageMigrationResult {
+	/** Whether settings.json was migrated to agent.db */
+	migratedSettings: boolean;
+	/** Whether auth.json was migrated to agent.db */
+	migratedAuth: boolean;
+	/** Non-fatal issues encountered during migration */
+	warnings: string[];
+}
+
+/**
+ * Type guard for plain objects.
+ * @param value - Value to check
+ * @returns True if value is a non-null, non-array object
+ */
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Transforms legacy settings to current schema (e.g., queueMode -> steeringMode).
+ * @param settings - Settings object potentially containing deprecated keys
+ * @returns Settings with deprecated keys renamed to current equivalents
+ */
+function migrateLegacySettings(settings: Settings): Settings {
+	const migrated = { ...settings } as Record<string, unknown>;
+	if ("queueMode" in migrated && !("steeringMode" in migrated)) {
+		migrated.steeringMode = migrated.queueMode;
+		delete migrated.queueMode;
+	}
+	return migrated as Settings;
+}
+
+/**
+ * Normalizes credential entries to array format (legacy stored single credentials).
+ * @param entry - Single credential or array of credentials
+ * @returns Array of credentials (empty if entry is undefined)
+ */
+function normalizeCredentialEntry(entry: AuthCredentialEntry | undefined): AuthCredential[] {
+	if (!entry) return [];
+	return Array.isArray(entry) ? entry : [entry];
+}
+
+/**
+ * Reads and parses a JSON file.
+ * @param path - Path to the JSON file
+ * @returns Parsed JSON content, or null if file doesn't exist or parsing fails
+ */
+async function readJsonFile<T>(path: string): Promise<T | null> {
+	try {
+		const file = Bun.file(path);
+		if (!(await file.exists())) return null;
+		const content = await file.text();
+		return JSON.parse(content) as T;
+	} catch (error) {
+		logger.warn("Storage migration failed to read JSON", { path, error: String(error) });
+		return null;
+	}
+}
+
+/**
+ * Backs up a JSON file to .bak and removes the original.
+ * Prevents re-migration on subsequent runs.
+ * @param path - Path to the JSON file to backup
+ */
+async function backupJson(path: string): Promise<void> {
+	const file = Bun.file(path);
+	if (!(await file.exists())) return;
+
+	const backupPath = `${path}.bak`;
+	try {
+		const content = await file.arrayBuffer();
+		await Bun.write(backupPath, content);
+		await file.unlink();
+	} catch (error) {
+		logger.warn("Storage migration failed to backup JSON", { path, error: String(error) });
+	}
+}
+
+/**
+ * Migrates settings.json to SQLite storage if DB is empty.
+ * @param storage - AgentStorage instance to migrate into
+ * @param settingsPath - Path to legacy settings.json
+ * @param warnings - Array to collect non-fatal warnings
+ * @returns True if migration was performed
+ */
+async function migrateSettings(storage: AgentStorage, settingsPath: string, warnings: string[]): Promise<boolean> {
+	const settingsFile = Bun.file(settingsPath);
+	const settingsExists = await settingsFile.exists();
+	const hasDbSettings = storage.getSettings() !== null;
+
+	if (!settingsExists) return false;
+	if (hasDbSettings) {
+		warnings.push(`settings.json exists but agent.db is authoritative: ${settingsPath}`);
+		return false;
+	}
+
+	const settingsJson = await readJsonFile<Settings>(settingsPath);
+	if (!settingsJson) return false;
+
+	storage.saveSettings(migrateLegacySettings(settingsJson));
+	await backupJson(settingsPath);
+	return true;
+}
+
+/**
+ * Finds the first valid auth.json from candidate paths (checked in priority order).
+ * @param authPaths - Candidate paths to search (e.g., project-local before global)
+ * @returns First valid auth file with its path and parsed data, or null if none found
+ */
+async function findFirstAuthJson(authPaths: string[]): Promise<{ path: string; data: AuthStorageData } | null> {
+	for (const authPath of authPaths) {
+		const data = await readJsonFile<AuthStorageData>(authPath);
+		if (data && isRecord(data)) {
+			return { path: authPath, data };
+		}
+	}
+	return null;
+}
+
+/**
+ * Validates that a credential has a recognized type.
+ * @param entry - Credential to validate
+ * @returns True if credential type is api_key or oauth
+ */
+function isValidCredential(entry: AuthCredential): boolean {
+	return entry.type === "api_key" || entry.type === "oauth";
+}
+
+/**
+ * Migrates auth.json to SQLite storage for providers missing in agent.db.
+ * @param storage - AgentStorage instance to migrate into
+ * @param authPaths - Candidate paths to search for auth.json
+ * @param warnings - Array to collect non-fatal warnings
+ * @returns True if migration was performed
+ */
+async function migrateAuth(storage: AgentStorage, authPaths: string[], warnings: string[]): Promise<boolean> {
+	const authJson = await findFirstAuthJson(authPaths);
+	if (!authJson) return false;
+
+	let sawValid = false;
+	let migratedAny = false;
+
+	for (const [provider, entry] of Object.entries(authJson.data)) {
+		const credentials = normalizeCredentialEntry(entry)
+			.filter(isValidCredential)
+			.map((credential) => credential);
+
+		if (credentials.length === 0) continue;
+		sawValid = true;
+
+		if (storage.listAuthCredentials(provider).length > 0) {
+			continue;
+		}
+
+		storage.replaceAuthCredentialsForProvider(provider, credentials);
+		migratedAny = true;
+	}
+
+	if (sawValid) {
+		await backupJson(authJson.path);
+	}
+
+	if (!migratedAny && sawValid) {
+		warnings.push(`auth.json entries already present in agent.db: ${authJson.path}`);
+	}
+
+	return migratedAny;
+}
+
+/**
+ * Migrates legacy JSON files (settings.json, auth.json) to SQLite-based agent.db.
+ * Settings migrate only when the DB has no settings; auth merges per-provider when missing.
+ * @param paths - Configuration specifying locations of legacy files and target DB
+ * @returns Result indicating what was migrated and any warnings encountered
+ */
+export async function migrateJsonStorage(paths: MigrationPaths): Promise<StorageMigrationResult> {
+	const storage = AgentStorage.open(getAgentDbPath(paths.agentDir));
+	const warnings: string[] = [];
+
+	const [migratedSettings, migratedAuth] = await Promise.all([
+		migrateSettings(storage, paths.settingsPath, warnings),
+		migrateAuth(storage, paths.authPaths, warnings),
+	]);
+
+	if (warnings.length > 0) {
+		for (const warning of warnings) {
+			logger.warn("Storage migration warning", { warning });
+		}
+	}
+
+	return { migratedSettings, migratedAuth, warnings };
+}