@oh-my-pi/pi-coding-agent 15.13.0 → 15.13.1

package/src/cli/profile-alias.ts

@@ -0,0 +1,338 @@
+import * as os from "node:os";
+import * as path from "node:path";
+import { normalizeProfileName } from "@oh-my-pi/pi-utils/dirs";
+
+export type ProfileAliasShell = "bash" | "zsh" | "fish" | "powershell" | "pwsh";
+
+function quoteForShell(pathValue: string): string {
+	return `'${pathValue.replace(/'/g, `'"'"'`)}'`;
+}
+
+function quoteForPowerShell(pathValue: string): string {
+	return `'${pathValue.replace(/'/g, `''`)}'`;
+}
+
+export interface ProfileAliasCommand {
+	display: string;
+	posix: string;
+	fish: string;
+	powerShell: string;
+}
+
+const DEFAULT_ALIAS_COMMAND: ProfileAliasCommand = {
+	display: "omp",
+	posix: "omp",
+	fish: "omp",
+	powerShell: "omp",
+};
+
+export interface ProfileAliasInstallOptions {
+	profile: string;
+	aliasName: string;
+	shellPath?: string;
+	platform?: NodeJS.Platform;
+	homeDir?: string;
+	env?: NodeJS.ProcessEnv;
+	readFile?: (filePath: string) => Promise<string>;
+	command?: ProfileAliasCommand;
+	writeFile?: (filePath: string, content: string) => Promise<void>;
+}
+
+export interface ProfileAliasInstallResult {
+	shell: ProfileAliasShell;
+	configPath: string;
+	aliasName: string;
+	profile: string;
+	command: string;
+	reloadedWith: string;
+}
+
+const ALIAS_NAME_RE = /^[A-Za-z_][A-Za-z0-9_-]{0,63}$/;
+const POSIX_RESERVED_ALIAS_NAMES: ReadonlySet<string> = new Set([
+	"case",
+	"coproc",
+	"do",
+	"done",
+	"elif",
+	"else",
+	"esac",
+	"fi",
+	"for",
+	"function",
+	"if",
+	"in",
+	"select",
+	"then",
+	"time",
+	"until",
+	"while",
+]);
+const FISH_RESERVED_ALIAS_NAMES: ReadonlySet<string> = new Set([
+	"and",
+	"begin",
+	"break",
+	"builtin",
+	"case",
+	"command",
+	"continue",
+	"else",
+	"end",
+	"exec",
+	"for",
+	"function",
+	"if",
+	"not",
+	"or",
+	"return",
+	"switch",
+	"while",
+]);
+const POWERSHELL_RESERVED_ALIAS_NAMES: ReadonlySet<string> = new Set([
+	"begin",
+	"break",
+	"catch",
+	"class",
+	"continue",
+	"data",
+	"do",
+	"dynamicparam",
+	"else",
+	"elseif",
+	"end",
+	"enum",
+	"exit",
+	"filter",
+	"finally",
+	"for",
+	"foreach",
+	"from",
+	"function",
+	"if",
+	"in",
+	"param",
+	"process",
+	"return",
+	"switch",
+	"throw",
+	"trap",
+	"try",
+	"until",
+	"using",
+	"var",
+	"while",
+	"workflow",
+]);
+
+// Keep local: importing the pi-utils root here would eagerly load env before
+// cli.ts has applied --profile, regressing profile-specific .env loading.
+function isEnoentError(error: unknown): boolean {
+	return typeof error === "object" && error !== null && (error as { code?: unknown }).code === "ENOENT";
+}
+
+function getReservedAliasNames(shell: ProfileAliasShell): ReadonlySet<string> {
+	switch (shell) {
+		case "bash":
+		case "zsh":
+			return POSIX_RESERVED_ALIAS_NAMES;
+		case "fish":
+			return FISH_RESERVED_ALIAS_NAMES;
+		case "powershell":
+		case "pwsh":
+			return POWERSHELL_RESERVED_ALIAS_NAMES;
+	}
+}
+
+function validateAliasName(aliasName: string, shell: ProfileAliasShell): string {
+	const normalized = aliasName.trim();
+	if (!ALIAS_NAME_RE.test(normalized)) {
+		throw new Error(`Invalid alias "${aliasName}". Alias names must match ${ALIAS_NAME_RE.source}.`);
+	}
+	if (normalized.toLowerCase() === "omp") {
+		throw new Error('Invalid alias "omp". Refusing to shadow the base omp command.');
+	}
+	if (getReservedAliasNames(shell).has(normalized.toLowerCase())) {
+		throw new Error(`Invalid alias "${aliasName}". Refusing to create a ${shell} reserved word.`);
+	}
+	return normalized;
+}
+
+// On Windows the launching shell is rarely exported through $SHELL, so when it
+// is missing we infer the PowerShell edition from the inherited environment.
+// PowerShell 7 (pwsh) always seeds PSModulePath with separator-delimited
+// ".../PowerShell/..." module directories (plus the Windows PowerShell ones for
+// back-compat), whereas Windows PowerShell 5.1 only ever lists
+// ".../WindowsPowerShell/...". The separator anchors keep "WindowsPowerShell"
+// from matching. POWERSHELL_DISTRIBUTION_CHANNEL is set only by some pwsh
+// distributions, so it stays a secondary hint rather than the primary signal.
+function detectWindowsPowerShell(env: NodeJS.ProcessEnv): ProfileAliasShell {
+	const modulePath = env.PSModulePath ?? env.PSMODULEPATH ?? env.psmodulepath ?? "";
+	if (/[\\/]PowerShell[\\/]/i.test(modulePath)) return "pwsh";
+	if (env.POWERSHELL_DISTRIBUTION_CHANNEL) return "pwsh";
+	return "powershell";
+}
+
+function normalizeShellName(
+	shellPath: string | undefined,
+	platform: NodeJS.Platform,
+	env: NodeJS.ProcessEnv,
+): ProfileAliasShell {
+	const shell = path
+		.basename(shellPath ?? "")
+		.toLowerCase()
+		.replace(/\.exe$/, "");
+	if (shell === "zsh") return "zsh";
+	if (shell === "bash") return "bash";
+	if (shell === "fish") return "fish";
+	if (shell === "pwsh") return "pwsh";
+	if (shell === "powershell") return "powershell";
+	if (platform === "win32") return detectWindowsPowerShell(env);
+	throw new Error(`Unsupported shell${shell ? ` "${shell}"` : ""}. Supported shells: bash, zsh, fish, PowerShell.`);
+}
+
+export function resolveProfileAliasCommandFromProcess(
+	argv: readonly string[] = process.argv,
+	cwd: string = process.cwd(),
+): ProfileAliasCommand {
+	const runtime = argv[0];
+	const script = argv[1];
+	if (!runtime || !script || !/\.[cm]?[jt]s$/.test(script)) return DEFAULT_ALIAS_COMMAND;
+
+	const scriptPath = path.resolve(cwd, script);
+	const posix = `${quoteForShell(runtime)} ${quoteForShell(scriptPath)}`;
+	return {
+		display: `${runtime} ${scriptPath}`,
+		posix,
+		fish: posix,
+		powerShell: `${quoteForPowerShell(runtime)} ${quoteForPowerShell(scriptPath)}`,
+	};
+}
+
+function resolveShellConfigPath(
+	shell: ProfileAliasShell,
+	homeDir: string,
+	platform: NodeJS.Platform,
+	env: NodeJS.ProcessEnv,
+): string {
+	switch (shell) {
+		case "zsh":
+			return path.join(env.ZDOTDIR || homeDir, ".zshrc");
+		case "bash":
+			return platform === "darwin" ? path.join(homeDir, ".bash_profile") : path.join(homeDir, ".bashrc");
+		case "fish": {
+			// fish sources conf.d from $XDG_CONFIG_HOME/fish (default ~/.config/fish);
+			// a hard-coded ~/.config would be silently ignored when the user relocates
+			// their XDG config root, leaving the alias unsourced after a restart.
+			const configHome = env.XDG_CONFIG_HOME || path.join(homeDir, ".config");
+			return path.join(configHome, "fish", "conf.d", "omp-profiles.fish");
+		}
+		case "pwsh":
+			return platform === "win32"
+				? path.join(homeDir, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1")
+				: path.join(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+		case "powershell":
+			return path.join(homeDir, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
+	}
+}
+
+function renderAliasBlock(
+	shell: ProfileAliasShell,
+	aliasName: string,
+	profile: string,
+	command: ProfileAliasCommand,
+): { block: string; command: string } {
+	const profiledCommand = `${command.display} --profile=${profile}`;
+	const start = `# >>> omp profile alias: ${aliasName} >>>`;
+	const end = `# <<< omp profile alias: ${aliasName} <<<`;
+	let body: string;
+	switch (shell) {
+		case "fish":
+			body = [
+				`function ${aliasName} --wraps omp --description 'OMP profile ${profile}'`,
+				`    command ${command.fish} --profile=${profile} $argv`,
+				"end",
+			].join("\n");
+			break;
+		case "powershell":
+		case "pwsh":
+			body = [`function ${aliasName} {`, `    & ${command.powerShell} --profile=${profile} @args`, "}"].join("\n");
+			break;
+		default:
+			body = [`${aliasName}() {`, `    command ${command.posix} --profile=${profile} "$@"`, "}"].join("\n");
+			break;
+	}
+	return { block: `${start}\n${body}\n${end}`, command: profiledCommand };
+}
+
+function upsertBlock(content: string, aliasName: string, block: string): string {
+	const start = `# >>> omp profile alias: ${aliasName} >>>`;
+	const end = `# <<< omp profile alias: ${aliasName} <<<`;
+	const startIndex = content.indexOf(start);
+	if (startIndex !== -1) {
+		const endIndex = content.indexOf(end, startIndex + start.length);
+		if (endIndex === -1) {
+			throw new Error(
+				`Found "${start}" without a matching "${end}" in the shell config. ` +
+					`The managed alias block is malformed; remove the stale marker line and rerun --alias.`,
+			);
+		}
+		const afterEnd = endIndex + end.length;
+		const prefix = content.slice(0, startIndex).replace(/[\t ]*\n?$/, "");
+		const suffix = content.slice(afterEnd).replace(/^\n?/, "");
+		return [prefix, block, suffix].filter(Boolean).join("\n\n").replace(/\n*$/, "\n");
+	}
+	const trimmed = content.replace(/\s*$/, "");
+	return `${trimmed}${trimmed ? "\n\n" : ""}${block}\n`;
+}
+
+function readAliasConfigText(filePath: string): Promise<string> {
+	return Bun.file(filePath).text();
+}
+
+export async function readProfileAliasConfigFile(
+	filePath: string,
+	readText: (filePath: string) => Promise<string> = readAliasConfigText,
+): Promise<string> {
+	try {
+		return await readText(filePath);
+	} catch (error) {
+		if (isEnoentError(error)) return "";
+		throw error;
+	}
+}
+
+export async function installProfileAlias(options: ProfileAliasInstallOptions): Promise<ProfileAliasInstallResult> {
+	const profile = normalizeProfileName(options.profile);
+	if (!profile) {
+		throw new Error("--alias requires a named --profile value.");
+	}
+	const platform = options.platform ?? process.platform;
+	const homeDir = options.homeDir ?? os.homedir();
+	const env = options.env ?? process.env;
+	const shell = normalizeShellName(options.shellPath ?? env.SHELL, platform, env);
+	const aliasName = validateAliasName(options.aliasName, shell);
+	const configPath = resolveShellConfigPath(shell, homeDir, platform, env);
+	const { block, command } = renderAliasBlock(shell, aliasName, profile, options.command ?? DEFAULT_ALIAS_COMMAND);
+	const readFile = options.readFile ?? readProfileAliasConfigFile;
+	const writeFile =
+		options.writeFile ??
+		(async (filePath, content) => {
+			await Bun.write(filePath, content);
+		});
+
+	const current = await readFile(configPath);
+	await writeFile(configPath, upsertBlock(current, aliasName, block));
+
+	return {
+		shell,
+		configPath,
+		aliasName,
+		profile,
+		command,
+		reloadedWith:
+			shell === "fish"
+				? `source ${quoteForShell(configPath)}`
+				: shell === "powershell" || shell === "pwsh"
+					? `. ${quoteForPowerShell(configPath)}`
+					: `. ${quoteForShell(configPath)}`,
+	};
+}

package/src/cli/profile-bootstrap.ts

@@ -0,0 +1,243 @@
+/**
+ * Bootstrap-time argv preparser for the global `--profile` / `--alias` flags.
+ *
+ * Profile selection MUST happen before any module reads `getAgentDir()` (notably
+ * `@oh-my-pi/pi-utils/env`, which eagerly loads `.env` from the agent directory
+ * during its own import). The full `parseArgs` from `./args.ts` lives downstream
+ * of those imports, so we can't rely on it for profile bootstrap — we have to
+ * crack open argv before the lazy command modules load.
+ *
+ * Because of that, this preparser must respect the same value-consumption
+ * contract as `args.ts`: known string-valued flags usually consume the next
+ * token even when it starts with `-`, except for string flags that can be
+ * shadowed by preloaded boolean extensions (currently `--plan`). Optional-value
+ * flags (`--resume`, `--session`, `-r`) consume the next token only when it
+ * doesn't look like another flag. Without this, `omp --system-prompt --profile
+ * foo` silently activates profile `foo`
+ * instead of passing the literal `--profile` to the system prompt and `foo`
+ * as a positional message.
+ *
+ * The shared classification lives in {@link ./flag-tables}, imported below,
+ * so the bootstrap and `args.ts` reference one source of truth instead of
+ * maintaining parallel constants.
+ *
+ * An unclassified bare long option (one not in any flag table) is treated as a
+ * possible extension string flag, but the bootstrap mirrors `parseArgs`'
+ * extension-flag rules ({@link ./args}): a string extension flag consumes its
+ * successor ONLY when that successor is value-like (does not start with `-`), and
+ * a boolean extension flag consumes nothing. So the successor is forwarded
+ * untouched (and never read as a global `--profile`/`--alias`) only when it is
+ * value-like; a flag-looking successor is left for normal processing, so
+ * `omp --some-ext-flag --profile work` still selects a profile. Known value-less
+ * launch flags ({@link VALUELESS_FLAGS}) are exempt so a trailing profile after
+ * them also activates (`omp --print --profile work`).
+ */
+
+import { isSubcommand } from "../cli-commands";
+import {
+	EXTENSION_SHADOWABLE_STRING_FLAGS,
+	OPTIONAL_FLAGS,
+	OPTIONAL_VALUE_FLAGS,
+	PROFILE_BOOTSTRAP_BOUNDARY_ARG,
+	STRING_VALUE_FLAGS,
+	VALUELESS_FLAGS,
+} from "./flag-tables";
+
+function isProfileBootstrapSubcommand(arg: string): boolean {
+	return arg === "launch" || arg === "acp";
+}
+
+function isUnknownLongValueCandidate(arg: string): boolean {
+	return (
+		arg.startsWith("--") &&
+		!arg.includes("=") &&
+		!STRING_VALUE_FLAGS.has(arg) &&
+		!OPTIONAL_VALUE_FLAGS.has(arg) &&
+		!VALUELESS_FLAGS.has(arg)
+	);
+}
+
+function needsBoundaryAfterGlobalStrip(stripped: readonly string[]): boolean {
+	const previous = stripped[stripped.length - 1];
+	return (
+		previous !== undefined &&
+		(OPTIONAL_VALUE_FLAGS.has(previous) ||
+			EXTENSION_SHADOWABLE_STRING_FLAGS.has(previous) ||
+			isUnknownLongValueCandidate(previous))
+	);
+}
+
+export interface ProfileBootstrapResult {
+	argv: string[];
+	profile?: string;
+	aliasName?: string;
+}
+
+/**
+ * Strip `--profile` / `--alias` from argv while preserving the surrounding
+ * argument structure, returning the residual argv to hand to the launch parser
+ * and the captured flag values.
+ *
+ * Global flag extraction stops only when the first residual argv token names a
+ * registered command that owns its own flags (e.g. `grep`): everything from
+ * that token onward is forwarded verbatim so a subcommand's own flags and
+ * positionals are never stolen (`omp grep --profile <path>` greps for
+ * `--profile`; it does not select a profile). `launch` and `acp` are explicit
+ * spellings of launch-shaped commands, so `omp launch --profile work` and
+ * `omp acp --profile work` still select profile `work`.
+ *
+ * Throws when either flag is supplied without a value.
+ */
+export function extractProfileFlags(argv: readonly string[]): ProfileBootstrapResult {
+	const stripped: string[] = [];
+	let profile: string | undefined;
+	let aliasName: string | undefined;
+	let passThrough = false;
+	let sawSubcommand = false;
+	let canDispatchSubcommand = true;
+	let insertBoundaryBeforeNextValue = false;
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+
+		if (passThrough || sawSubcommand) {
+			stripped.push(arg);
+			continue;
+		}
+
+		if (insertBoundaryBeforeNextValue) {
+			if (!arg.startsWith("-")) {
+				stripped.push(PROFILE_BOOTSTRAP_BOUNDARY_ARG);
+			}
+			insertBoundaryBeforeNextValue = false;
+		}
+
+		// `--` ends option processing. Anything that follows is forwarded verbatim
+		// so users can pass arbitrary tokens (including a literal `--profile`) to
+		// downstream tools without the bootstrap stealing them.
+		if (arg === "--") {
+			passThrough = true;
+			stripped.push(arg);
+			continue;
+		}
+
+		if (arg === "--profile") {
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) {
+				throw new Error("--profile requires a profile name");
+			}
+			profile = value;
+			insertBoundaryBeforeNextValue = needsBoundaryAfterGlobalStrip(stripped);
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--profile=")) {
+			const value = arg.slice("--profile=".length);
+			if (!value) {
+				throw new Error("--profile requires a profile name");
+			}
+			profile = value;
+			insertBoundaryBeforeNextValue = needsBoundaryAfterGlobalStrip(stripped);
+			continue;
+		}
+		if (arg === "--alias") {
+			const value = argv[index + 1];
+			if (!value || value.startsWith("-")) {
+				throw new Error("--alias requires a command name");
+			}
+			aliasName = value;
+			insertBoundaryBeforeNextValue = needsBoundaryAfterGlobalStrip(stripped);
+			index += 1;
+			continue;
+		}
+		if (arg.startsWith("--alias=")) {
+			const value = arg.slice("--alias=".length);
+			if (!value) {
+				throw new Error("--alias requires a command name");
+			}
+			aliasName = value;
+			insertBoundaryBeforeNextValue = needsBoundaryAfterGlobalStrip(stripped);
+			continue;
+		}
+
+		// Known string flags normally consume flag-looking values (for example
+		// `--system-prompt --profile foo` means the system prompt is literally
+		// `--profile`). A small allow-list of built-ins can be shadowed by boolean
+		// extensions before extension metadata is loaded; those mirror extension
+		// consumption here so `--plan --profile work` still activates `work`.
+		if (EXTENSION_SHADOWABLE_STRING_FLAGS.has(arg)) {
+			canDispatchSubcommand = false;
+			stripped.push(arg);
+			const next = argv[index + 1];
+			if (next !== undefined && !next.startsWith("-")) {
+				stripped.push(next);
+				index += 1;
+			}
+			continue;
+		}
+
+		// Forward both the flag and its value untouched so the downstream parser
+		// gets exactly what the user typed. Critical for `--system-prompt
+		// --profile foo`: the bootstrap must NOT interpret `--profile` here, it
+		// belongs to `--system-prompt`.
+		if (STRING_VALUE_FLAGS.has(arg)) {
+			canDispatchSubcommand = false;
+			stripped.push(arg);
+			if (index + 1 < argv.length) {
+				stripped.push(argv[index + 1]);
+				index += 1;
+			}
+			continue;
+		}
+
+		if (OPTIONAL_VALUE_FLAGS.has(arg)) {
+			canDispatchSubcommand = false;
+			stripped.push(arg);
+			const config = OPTIONAL_FLAGS[arg];
+			const next = argv[index + 1];
+			if (next !== undefined && !next.startsWith("-") && !(config.rejectEmpty === true && next.length === 0)) {
+				stripped.push(next);
+				index += 1;
+			}
+			continue;
+		}
+
+		// An unclassified bare long option (`--xxx` with no `=`) may be an extension
+		// string flag that consumes the next token as its value. The bootstrap runs
+		// before extensions load, so it cannot consult the extension flag table; it
+		// therefore mirrors the value-consumption rule `parseArgs` applies to
+		// extension flags (./args.ts): a string extension flag consumes its successor
+		// ONLY when that successor is value-like (does not start with `-`), and a
+		// boolean extension flag consumes nothing. So protect (forward + skip) the
+		// successor only when it is value-like — `omp --bar val --profile work` keeps
+		// `val` with `--bar` and still extracts the trailing profile — and otherwise
+		// forward just the flag, letting the loop process a flag-looking successor so
+		// a trailing global flag still applies (`omp --some-ext-bool --profile work`
+		// selects profile `work`). A `--` successor is deliberately NOT protected
+		// here: it falls through to the end-of-options arm above, keeping `--` a
+		// single, consistent meaning instead of being swallowed as a flag value.
+		// Known value-less launch flags are exempt so a trailing profile still
+		// activates (`omp --print --profile work`).
+		if (isUnknownLongValueCandidate(arg)) {
+			canDispatchSubcommand = false;
+			stripped.push(arg);
+			const next = argv[index + 1];
+			if (next !== undefined && !next.startsWith("-")) {
+				stripped.push(next);
+				index += 1;
+			}
+			continue;
+		}
+
+		// Only the first residual argv token can be the dispatched subcommand. Once
+		// any other token has been forwarded, later subcommand names are launch text.
+		// `launch` and `acp` are explicit spellings of launch-shaped commands, so
+		// global launch flags that follow them must still be extracted.
+		if (canDispatchSubcommand && isSubcommand(arg) && !isProfileBootstrapSubcommand(arg)) {
+			sawSubcommand = true;
+		}
+		canDispatchSubcommand = false;
+		stripped.push(arg);
+	}
+
+	return { argv: stripped, profile, aliasName };
+}