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

package/src/cli/update-cli.ts

@@ -0,0 +1,274 @@
+/**
+ * Update CLI command handler.
+ *
+ * Handles `omp update` to check for and install updates.
+ * Uses bun if available, otherwise downloads binary from GitHub releases.
+ */
+
+import { execSync, spawnSync } from "node:child_process";
+import { createWriteStream, existsSync, renameSync, unlinkSync } from "node:fs";
+import { dirname } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import chalk from "chalk";
+import { APP_NAME, VERSION } from "../config";
+import { theme } from "../modes/interactive/theme/theme";
+
+/**
+ * Detect if we're running as a Bun compiled binary.
+ */
+const isBunBinary =
+	import.meta.url.includes("$bunfs") || import.meta.url.includes("~BUN") || import.meta.url.includes("%7EBUN");
+
+const REPO = "can1357/oh-my-pi";
+const PACKAGE = "@oh-my-pi/pi-coding-agent";
+
+interface ReleaseInfo {
+	tag: string;
+	version: string;
+	assets: Array<{ name: string; url: string }>;
+}
+
+/**
+ * Parse update subcommand arguments.
+ * Returns undefined if not an update command.
+ */
+export function parseUpdateArgs(args: string[]): { force: boolean; check: boolean } | undefined {
+	if (args.length === 0 || args[0] !== "update") {
+		return undefined;
+	}
+
+	return {
+		force: args.includes("--force") || args.includes("-f"),
+		check: args.includes("--check") || args.includes("-c"),
+	};
+}
+
+/**
+ * Check if bun is available in PATH.
+ */
+function hasBun(): boolean {
+	try {
+		const result = spawnSync("bun", ["--version"], { encoding: "utf-8", stdio: "pipe" });
+		return result.status === 0;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Get the latest release info from GitHub.
+ */
+async function getLatestRelease(): Promise<ReleaseInfo> {
+	const response = await fetch(`https://api.github.com/repos/${REPO}/releases/latest`);
+	if (!response.ok) {
+		throw new Error(`Failed to fetch release info: ${response.statusText}`);
+	}
+
+	const data = (await response.json()) as {
+		tag_name: string;
+		assets: Array<{ name: string; browser_download_url: string }>;
+	};
+
+	return {
+		tag: data.tag_name,
+		version: data.tag_name.replace(/^v/, ""),
+		assets: data.assets.map((a) => ({ name: a.name, url: a.browser_download_url })),
+	};
+}
+
+/**
+ * Compare semver versions. Returns:
+ * - negative if a < b
+ * - 0 if a == b
+ * - positive if a > b
+ */
+function compareVersions(a: string, b: string): number {
+	const pa = a.split(".").map(Number);
+	const pb = b.split(".").map(Number);
+
+	for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+		const na = pa[i] || 0;
+		const nb = pb[i] || 0;
+		if (na !== nb) return na - nb;
+	}
+	return 0;
+}
+
+/**
+ * Get the appropriate binary name for this platform.
+ */
+function getBinaryName(): string {
+	const platform = process.platform;
+	const arch = process.arch;
+
+	let os: string;
+	switch (platform) {
+		case "linux":
+			os = "linux";
+			break;
+		case "darwin":
+			os = "darwin";
+			break;
+		case "win32":
+			os = "windows";
+			break;
+		default:
+			throw new Error(`Unsupported platform: ${platform}`);
+	}
+
+	let archName: string;
+	switch (arch) {
+		case "x64":
+			archName = "x64";
+			break;
+		case "arm64":
+			archName = "arm64";
+			break;
+		default:
+			throw new Error(`Unsupported architecture: ${arch}`);
+	}
+
+	if (os === "windows") {
+		return `${APP_NAME}-${os}-${archName}.exe`;
+	}
+	return `${APP_NAME}-${os}-${archName}`;
+}
+
+/**
+ * Update via bun package manager.
+ */
+async function updateViaBun(): Promise<void> {
+	console.log(chalk.dim("Updating via bun..."));
+
+	try {
+		execSync(`bun update -g ${PACKAGE}`, { stdio: "inherit" });
+		console.log(chalk.green(`\n${theme.status.success} Update complete`));
+	} catch {
+		throw new Error("bun update failed");
+	}
+}
+
+/**
+ * Update by downloading binary from GitHub releases.
+ */
+async function updateViaBinary(release: ReleaseInfo): Promise<void> {
+	const binaryName = getBinaryName();
+	const asset = release.assets.find((a) => a.name === binaryName);
+
+	if (!asset) {
+		throw new Error(`No binary found for ${binaryName}`);
+	}
+
+	const execPath = process.execPath;
+	const _execDir = dirname(execPath);
+	const tempPath = `${execPath}.new`;
+	const backupPath = `${execPath}.bak`;
+
+	console.log(chalk.dim(`Downloading ${binaryName}...`));
+
+	// Download to temp file
+	const response = await fetch(asset.url, { redirect: "follow" });
+	if (!response.ok || !response.body) {
+		throw new Error(`Download failed: ${response.statusText}`);
+	}
+
+	const fileStream = createWriteStream(tempPath, { mode: 0o755 });
+	const nodeStream = Readable.fromWeb(response.body as import("stream/web").ReadableStream);
+	await pipeline(nodeStream, fileStream);
+
+	// Replace current binary
+	console.log(chalk.dim("Installing update..."));
+
+	try {
+		// Backup current binary
+		if (existsSync(backupPath)) {
+			unlinkSync(backupPath);
+		}
+		renameSync(execPath, backupPath);
+
+		// Move new binary into place
+		renameSync(tempPath, execPath);
+
+		// Clean up backup
+		unlinkSync(backupPath);
+
+		console.log(chalk.green(`\n${theme.status.success} Updated to ${release.version}`));
+		console.log(chalk.dim(`Restart ${APP_NAME} to use the new version`));
+	} catch (err) {
+		// Restore from backup if possible
+		if (existsSync(backupPath) && !existsSync(execPath)) {
+			renameSync(backupPath, execPath);
+		}
+		if (existsSync(tempPath)) {
+			unlinkSync(tempPath);
+		}
+		throw err;
+	}
+}
+
+/**
+ * Run the update command.
+ */
+export async function runUpdateCommand(opts: { force: boolean; check: boolean }): Promise<void> {
+	console.log(chalk.dim(`Current version: ${VERSION}`));
+
+	// Check for updates
+	let release: ReleaseInfo;
+	try {
+		release = await getLatestRelease();
+	} catch (err) {
+		console.error(chalk.red(`Failed to check for updates: ${err}`));
+		process.exit(1);
+	}
+
+	const comparison = compareVersions(release.version, VERSION);
+
+	if (comparison <= 0 && !opts.force) {
+		console.log(chalk.green(`${theme.status.success} Already up to date`));
+		return;
+	}
+
+	if (comparison > 0) {
+		console.log(chalk.cyan(`New version available: ${release.version}`));
+	} else {
+		console.log(chalk.yellow(`Forcing reinstall of ${release.version}`));
+	}
+
+	if (opts.check) {
+		// Just check, don't install
+		return;
+	}
+
+	// Choose update method
+	try {
+		if (!isBunBinary && hasBun()) {
+			await updateViaBun();
+		} else {
+			await updateViaBinary(release);
+		}
+	} catch (err) {
+		console.error(chalk.red(`Update failed: ${err}`));
+		process.exit(1);
+	}
+}
+
+/**
+ * Print update command help.
+ */
+export function printUpdateHelp(): void {
+	console.log(`${chalk.bold(`${APP_NAME} update`)} - Check for and install updates
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} update [options]
+
+${chalk.bold("Options:")}
+  -c, --check   Check for updates without installing
+  -f, --force   Force reinstall even if up to date
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} update           Update to latest version
+  ${APP_NAME} update --check   Check if updates are available
+  ${APP_NAME} update --force   Force reinstall
+`);
+}

package/src/cli.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env bun
+/**
+ * CLI entry point for the refactored coding agent.
+ * Uses main.ts with AgentSession and new mode modules.
+ *
+ * Test with: npx tsx src/cli-new.ts [args...]
+ */
+import { main } from "./main";
+
+main(process.argv.slice(2));

package/src/config.ts

@@ -0,0 +1,391 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+
+// Embed package.json at build time for config
+import packageJson from "../package.json" with { type: "json" };
+
+// =============================================================================
+// App Config (from embedded package.json)
+// =============================================================================
+
+export const APP_NAME: string = (packageJson as { ompConfig?: { name?: string } }).ompConfig?.name || "omp";
+export const CONFIG_DIR_NAME: string =
+	(packageJson as { ompConfig?: { configDir?: string } }).ompConfig?.configDir || ".omp";
+export const VERSION: string = (packageJson as { version: string }).version;
+
+const priorityList = [
+	{ dir: ".omp", globalAgentDir: ".omp/agent" },
+	{ dir: ".pi", globalAgentDir: ".pi/agent" },
+	{ dir: ".claude" },
+	{ dir: ".codex" },
+	{ dir: ".gemini" },
+];
+
+// e.g., OMP_CODING_AGENT_DIR
+export const ENV_AGENT_DIR = `${APP_NAME.toUpperCase()}_CODING_AGENT_DIR`;
+
+// =============================================================================
+// Package Directory (for optional external docs/examples)
+// =============================================================================
+
+/**
+ * Get the base directory for resolving optional package assets (docs, examples).
+ * Walk up from import.meta.dir until we find package.json, or fall back to cwd.
+ */
+export function getPackageDir(): string {
+	let dir = import.meta.dir;
+	while (dir !== dirname(dir)) {
+		if (existsSync(join(dir, "package.json"))) {
+			return dir;
+		}
+		dir = dirname(dir);
+	}
+	// Fallback to cwd (docs/examples won't be found, but that's fine)
+	return process.cwd();
+}
+
+/** Get path to README.md (optional, may not exist in binary) */
+export function getReadmePath(): string {
+	return resolve(join(getPackageDir(), "README.md"));
+}
+
+/** Get path to docs directory (optional, may not exist in binary) */
+export function getDocsPath(): string {
+	return resolve(join(getPackageDir(), "docs"));
+}
+
+/** Get path to examples directory (optional, may not exist in binary) */
+export function getExamplesPath(): string {
+	return resolve(join(getPackageDir(), "examples"));
+}
+
+/** Get path to CHANGELOG.md (optional, may not exist in binary) */
+export function getChangelogPath(): string {
+	return resolve(join(getPackageDir(), "CHANGELOG.md"));
+}
+
+// =============================================================================
+// User Config Paths (~/.omp/agent/*)
+// =============================================================================
+
+/** Get the agent config directory (e.g., ~/.omp/agent/) */
+export function getAgentDir(): string {
+	return process.env[ENV_AGENT_DIR] || join(homedir(), CONFIG_DIR_NAME, "agent");
+}
+
+/** Get path to user's custom themes directory */
+export function getCustomThemesDir(): string {
+	return join(getAgentDir(), "themes");
+}
+
+/** Get path to models.json */
+export function getModelsPath(): string {
+	return join(getAgentDir(), "models.json");
+}
+
+/** Get path to auth.json */
+export function getAuthPath(): string {
+	return join(getAgentDir(), "auth.json");
+}
+
+/** Get path to settings.json */
+export function getSettingsPath(): string {
+	return join(getAgentDir(), "settings.json");
+}
+
+/** Get path to tools directory */
+export function getToolsDir(): string {
+	return join(getAgentDir(), "tools");
+}
+
+/** Get path to slash commands directory */
+export function getCommandsDir(): string {
+	return join(getAgentDir(), "commands");
+}
+
+/** Get path to sessions directory */
+export function getSessionsDir(): string {
+	return join(getAgentDir(), "sessions");
+}
+
+/** Get path to debug log file */
+export function getDebugLogPath(): string {
+	return join(getAgentDir(), `${APP_NAME}-debug.log`);
+}
+
+// =============================================================================
+// Multi-Config Directory Helpers
+// =============================================================================
+
+/**
+ * Config directory bases in priority order (highest first).
+ * User-level: ~/.omp/agent, ~/.pi/agent, ~/.claude, ~/.codex, ~/.gemini
+ * Project-level: .omp, .pi, .claude, .codex, .gemini
+ */
+const USER_CONFIG_BASES = priorityList.map(({ dir, globalAgentDir }) => ({
+	base: () => join(homedir(), globalAgentDir ?? dir),
+	name: dir,
+}));
+
+const PROJECT_CONFIG_BASES = priorityList.map(({ dir }) => ({
+	base: dir,
+	name: dir,
+}));
+
+export interface ConfigDirEntry {
+	path: string;
+	source: string; // e.g., ".omp", ".pi", ".claude"
+	level: "user" | "project";
+}
+
+export interface GetConfigDirsOptions {
+	/** Include user-level directories (~/.omp/agent/...). Default: true */
+	user?: boolean;
+	/** Include project-level directories (.omp/...). Default: true */
+	project?: boolean;
+	/** Current working directory for project paths. Default: process.cwd() */
+	cwd?: string;
+	/** Only return directories that exist. Default: false */
+	existingOnly?: boolean;
+}
+
+/**
+ * Get all config directories for a subpath, ordered by priority (highest first).
+ *
+ * @param subpath - Subpath within config dirs (e.g., "commands", "hooks", "agents")
+ * @param options - Options for filtering
+ * @returns Array of directory entries, highest priority first
+ *
+ * @example
+ * // Get all command directories
+ * getConfigDirs("commands")
+ * // → [{ path: "~/.omp/agent/commands", source: ".omp", level: "user" }, ...]
+ *
+ * @example
+ * // Get only existing project skill directories
+ * getConfigDirs("skills", { user: false, existingOnly: true })
+ */
+export function getConfigDirs(subpath: string, options: GetConfigDirsOptions = {}): ConfigDirEntry[] {
+	const { user = true, project = true, cwd = process.cwd(), existingOnly = false } = options;
+	const results: ConfigDirEntry[] = [];
+
+	// User-level directories (highest priority)
+	if (user) {
+		for (const { base, name } of USER_CONFIG_BASES) {
+			const path = join(base(), subpath);
+			if (!existingOnly || existsSync(path)) {
+				results.push({ path, source: name, level: "user" });
+			}
+		}
+	}
+
+	// Project-level directories
+	if (project) {
+		for (const { base, name } of PROJECT_CONFIG_BASES) {
+			const path = resolve(cwd, base, subpath);
+			if (!existingOnly || existsSync(path)) {
+				results.push({ path, source: name, level: "project" });
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Get all config directory paths for a subpath (convenience wrapper).
+ * Returns just the paths, highest priority first.
+ */
+export function getConfigDirPaths(subpath: string, options: GetConfigDirsOptions = {}): string[] {
+	return getConfigDirs(subpath, options).map((e) => e.path);
+}
+
+export interface ConfigFileResult<T> {
+	path: string;
+	source: string;
+	level: "user" | "project";
+	content: T;
+}
+
+/**
+ * Read the first existing config file from priority-ordered locations.
+ *
+ * @param subpath - Subpath within config dirs (e.g., "settings.json", "models.json")
+ * @param options - Options for filtering (same as getConfigDirs)
+ * @returns The parsed content and metadata, or undefined if not found
+ *
+ * @example
+ * const result = readConfigFile<Settings>("settings.json", { project: false });
+ * if (result) {
+ *   console.log(`Loaded from ${result.path}`);
+ *   console.log(result.content);
+ * }
+ */
+export function readConfigFile<T = unknown>(
+	subpath: string,
+	options: GetConfigDirsOptions = {},
+): ConfigFileResult<T> | undefined {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+
+	for (const { path: base, source, level } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			try {
+				const content = readFileSync(filePath, "utf-8");
+				return {
+					path: filePath,
+					source,
+					level,
+					content: JSON.parse(content) as T,
+				};
+			} catch {
+				// Continue to next file on parse error
+			}
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * Get all existing config files for a subpath (for merging scenarios).
+ * Returns in priority order (highest first).
+ */
+export function readAllConfigFiles<T = unknown>(
+	subpath: string,
+	options: GetConfigDirsOptions = {},
+): ConfigFileResult<T>[] {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+	const results: ConfigFileResult<T>[] = [];
+
+	for (const { path: base, source, level } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			try {
+				const content = readFileSync(filePath, "utf-8");
+				results.push({
+					path: filePath,
+					source,
+					level,
+					content: JSON.parse(content) as T,
+				});
+			} catch {
+				// Skip files that fail to parse
+			}
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Find the first existing config file (for non-JSON files like SYSTEM.md).
+ * Returns just the path, or undefined if not found.
+ */
+export function findConfigFile(subpath: string, options: GetConfigDirsOptions = {}): string | undefined {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+
+	for (const { path: base } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			return filePath;
+		}
+	}
+
+	return undefined;
+}
+
+/**
+ * Find the first existing config file with metadata.
+ */
+export function findConfigFileWithMeta(
+	subpath: string,
+	options: GetConfigDirsOptions = {},
+): Omit<ConfigFileResult<never>, "content"> | undefined {
+	const dirs = getConfigDirs("", { ...options, existingOnly: false });
+
+	for (const { path: base, source, level } of dirs) {
+		const filePath = join(base, subpath);
+		if (existsSync(filePath)) {
+			return { path: filePath, source, level };
+		}
+	}
+
+	return undefined;
+}
+
+// =============================================================================
+// Walk-Up Config Discovery (for monorepo scenarios)
+// =============================================================================
+
+function isDirectory(p: string): boolean {
+	try {
+		return statSync(p).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Find nearest config directory by walking up from cwd.
+ * Checks all config bases (.omp, .pi, .claude) at each level.
+ *
+ * @param subpath - Subpath within config dirs (e.g., "commands", "agents")
+ * @param cwd - Starting directory
+ * @returns First existing directory found, or undefined
+ */
+export function findNearestProjectConfigDir(subpath: string, cwd: string = process.cwd()): ConfigDirEntry | undefined {
+	let currentDir = cwd;
+
+	while (true) {
+		// Check all config bases at this level, in priority order
+		for (const { base, name } of PROJECT_CONFIG_BASES) {
+			const candidate = join(currentDir, base, subpath);
+			if (isDirectory(candidate)) {
+				return { path: candidate, source: name, level: "project" };
+			}
+		}
+
+		// Move up one directory
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break; // Reached root
+		currentDir = parentDir;
+	}
+
+	return undefined;
+}
+
+/**
+ * Find all nearest config directories by walking up from cwd.
+ * Returns one entry per config base (.omp, .pi, .claude) - the nearest one found.
+ * Results are in priority order (highest first).
+ */
+export function findAllNearestProjectConfigDirs(subpath: string, cwd: string = process.cwd()): ConfigDirEntry[] {
+	const results: ConfigDirEntry[] = [];
+	const foundBases = new Set<string>();
+
+	let currentDir = cwd;
+
+	while (foundBases.size < PROJECT_CONFIG_BASES.length) {
+		for (const { base, name } of PROJECT_CONFIG_BASES) {
+			if (foundBases.has(name)) continue;
+
+			const candidate = join(currentDir, base, subpath);
+			if (isDirectory(candidate)) {
+				results.push({ path: candidate, source: name, level: "project" });
+				foundBases.add(name);
+			}
+		}
+
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
+
+	// Sort by priority order
+	const order = PROJECT_CONFIG_BASES.map((b) => b.name);
+	results.sort((a, b) => order.indexOf(a.source) - order.indexOf(b.source));
+
+	return results;
+}