@oh-my-pi/pi-coding-agent 3.33.0 → 3.34.0

package/src/core/system-prompt.ts

@@ -2,7 +2,9 @@
  * System prompt construction and project context loading
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import chalk from "chalk";
 import { contextFileCapability } from "../capability/context-file";
 import type { Rule } from "../capability/rule";
@@ -70,6 +72,7 @@ const toolDescriptions: Record<ToolName, string> = {
 	ask: "Ask user for input or clarification",
 	read: "Read file contents",
 	bash: "Execute bash commands (npm, docker, etc.)",
+	ssh: "Execute commands on remote hosts via SSH",
 	edit: "Make surgical edits to files (find exact text and replace)",
 	write: "Create or overwrite files",
 	grep: "Search file contents for patterns (respects .gitignore)",
@@ -126,6 +129,406 @@ function buildPromptFooter(dateTime: string, cwd: string): string {
 	return `Current date and time: ${dateTime}\nCurrent working directory: ${cwd}`;
 }
 
+function execCommand(args: string[]): string | null {
+	const result = Bun.spawnSync(args, { stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+	if (result.exitCode !== 0) return null;
+	const output = result.stdout.toString().trim();
+	return output.length > 0 ? output : null;
+}
+
+function execIfExists(command: string, args: string[]): string | null {
+	if (!Bun.which(command)) return null;
+	return execCommand([command, ...args]);
+}
+
+function firstNonEmpty(values: Array<string | undefined | null>): string | null {
+	for (const value of values) {
+		const trimmed = value?.trim();
+		if (trimmed) return trimmed;
+	}
+	return null;
+}
+
+function firstNonEmptyLine(value: string | null): string | null {
+	if (!value) return null;
+	const line = value
+		.split("\n")
+		.map((entry) => entry.trim())
+		.filter(Boolean)[0];
+	return line ?? null;
+}
+
+function parseWmicTable(output: string, header: string): string | null {
+	const lines = output
+		.split("\n")
+		.map((line) => line.trim())
+		.filter(Boolean);
+	const filtered = lines.filter((line) => line.toLowerCase() !== header.toLowerCase());
+	return filtered[0] ?? null;
+}
+
+function parseKeyValueOutput(output: string): Record<string, string> {
+	const result: Record<string, string> = {};
+	for (const line of output.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		const [key, ...rest] = trimmed.split("=");
+		if (!key || rest.length === 0) continue;
+		const value = rest.join("=").trim();
+		if (value) result[key.trim()] = value;
+	}
+	return result;
+}
+
+function stripQuotes(value: string): string {
+	return value.replace(/^"|"$/g, "");
+}
+
+function getOsName(): string {
+	switch (process.platform) {
+		case "win32":
+			return "Windows";
+		case "darwin":
+			return "macOS";
+		case "linux":
+			return "Linux";
+		case "freebsd":
+			return "FreeBSD";
+		case "openbsd":
+			return "OpenBSD";
+		case "netbsd":
+			return "NetBSD";
+		case "aix":
+			return "AIX";
+		default:
+			return process.platform || "unknown";
+	}
+}
+
+function getKernelVersion(): string {
+	if (process.platform === "win32") {
+		return execCommand(["cmd", "/c", "ver"]) ?? "unknown";
+	}
+
+	return execCommand(["uname", "-sr"]) ?? "unknown";
+}
+
+function getOsDistro(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["os", "get", "Caption,Version", "/value"]);
+			if (!output) return null;
+			const parsed = parseKeyValueOutput(output);
+			const caption = parsed.Caption;
+			const version = parsed.Version;
+			if (caption && version) return `${caption} ${version}`.trim();
+			return caption ?? version ?? null;
+		}
+		case "darwin": {
+			const name = firstNonEmptyLine(execIfExists("sw_vers", ["-productName"]));
+			const version = firstNonEmptyLine(execIfExists("sw_vers", ["-productVersion"]));
+			if (name && version) return `${name} ${version}`.trim();
+			return name ?? version ?? null;
+		}
+		case "linux": {
+			const lsb = firstNonEmptyLine(execIfExists("lsb_release", ["-ds"]));
+			if (lsb) return stripQuotes(lsb);
+			const osRelease = execIfExists("cat", ["/etc/os-release"]);
+			if (!osRelease) return null;
+			const parsed = parseKeyValueOutput(osRelease);
+			const pretty = parsed.PRETTY_NAME ?? parsed.NAME;
+			const version = parsed.VERSION ?? parsed.VERSION_ID;
+			if (pretty) return stripQuotes(pretty);
+			if (parsed.NAME && version) return `${stripQuotes(parsed.NAME)} ${stripQuotes(version)}`.trim();
+			return parsed.NAME ? stripQuotes(parsed.NAME) : null;
+		}
+		default:
+			return null;
+	}
+}
+
+function getCpuArch(): string {
+	return process.arch || "unknown";
+}
+
+function getCpuModel(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["cpu", "get", "Name"]);
+			return output ? parseWmicTable(output, "Name") : null;
+		}
+		case "darwin": {
+			return firstNonEmptyLine(execIfExists("sysctl", ["-n", "machdep.cpu.brand_string"]));
+		}
+		case "linux": {
+			const lscpu = execIfExists("lscpu", []);
+			if (lscpu) {
+				const match = lscpu
+					.split("\n")
+					.map((line) => line.trim())
+					.find((line) => line.toLowerCase().startsWith("model name:"));
+				if (match) return match.split(":").slice(1).join(":").trim();
+			}
+			const cpuInfo = execIfExists("cat", ["/proc/cpuinfo"]);
+			if (!cpuInfo) return null;
+			for (const line of cpuInfo.split("\n")) {
+				const [key, ...rest] = line.split(":");
+				if (!key || rest.length === 0) continue;
+				const normalized = key.trim().toLowerCase();
+				if (normalized === "model name" || normalized === "hardware" || normalized === "processor") {
+					return rest.join(":").trim();
+				}
+			}
+			return null;
+		}
+		default:
+			return null;
+	}
+}
+
+function getGpuModel(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["path", "win32_VideoController", "get", "name"]);
+			return output ? parseWmicTable(output, "Name") : null;
+		}
+		case "linux": {
+			const output = execIfExists("lspci", []);
+			if (!output) return null;
+			const gpus: Array<{ name: string; priority: number }> = [];
+			for (const line of output.split("\n")) {
+				if (!/(VGA|3D|Display)/i.test(line)) continue;
+				const parts = line.split(":");
+				const name = parts.length > 1 ? parts.slice(1).join(":").trim() : line.trim();
+				const nameLower = name.toLowerCase();
+				// Skip BMC/server management adapters
+				if (/aspeed|matrox g200|mgag200/i.test(name)) continue;
+				// Prioritize discrete GPUs
+				let priority = 0;
+				if (
+					nameLower.includes("nvidia") ||
+					nameLower.includes("geforce") ||
+					nameLower.includes("quadro") ||
+					nameLower.includes("rtx")
+				) {
+					priority = 3;
+				} else if (nameLower.includes("amd") || nameLower.includes("radeon") || nameLower.includes("rx ")) {
+					priority = 3;
+				} else if (nameLower.includes("intel")) {
+					priority = 1;
+				} else {
+					priority = 2;
+				}
+				gpus.push({ name, priority });
+			}
+			if (gpus.length === 0) return null;
+			gpus.sort((a, b) => b.priority - a.priority);
+			return gpus[0].name;
+		}
+		default:
+			return null;
+	}
+}
+
+function getShellName(): string {
+	const shell = firstNonEmpty([process.env.SHELL, process.env.ComSpec]);
+	return shell ?? "unknown";
+}
+
+function getTerminalName(): string {
+	const termProgram = process.env.TERM_PROGRAM;
+	const termProgramVersion = process.env.TERM_PROGRAM_VERSION;
+	if (termProgram) {
+		return termProgramVersion ? `${termProgram} ${termProgramVersion}` : termProgram;
+	}
+
+	if (process.env.WT_SESSION) return "Windows Terminal";
+
+	const term = firstNonEmpty([process.env.TERM, process.env.COLORTERM, process.env.TERMINAL_EMULATOR]);
+	return term ?? "unknown";
+}
+
+function normalizeDesktopValue(value: string): string {
+	const trimmed = value.trim();
+	if (!trimmed) return "unknown";
+	const parts = trimmed
+		.split(":")
+		.map((part) => part.trim())
+		.filter(Boolean);
+	return parts[0] ?? trimmed;
+}
+
+function getDesktopEnvironment(): string {
+	if (process.env.KDE_FULL_SESSION === "true") return "KDE";
+	const raw = firstNonEmpty([
+		process.env.XDG_CURRENT_DESKTOP,
+		process.env.DESKTOP_SESSION,
+		process.env.XDG_SESSION_DESKTOP,
+		process.env.GDMSESSION,
+	]);
+	return raw ? normalizeDesktopValue(raw) : "unknown";
+}
+
+function matchKnownWindowManager(value: string): string | null {
+	const normalized = value.toLowerCase();
+	const candidates = [
+		"sway",
+		"i3",
+		"i3wm",
+		"bspwm",
+		"openbox",
+		"awesome",
+		"herbstluftwm",
+		"fluxbox",
+		"icewm",
+		"dwm",
+		"hyprland",
+		"wayfire",
+		"river",
+		"labwc",
+		"qtile",
+	];
+	for (const candidate of candidates) {
+		if (normalized.includes(candidate)) return candidate;
+	}
+	return null;
+}
+
+function getWindowManager(): string {
+	const explicit = firstNonEmpty([process.env.WINDOWMANAGER]);
+	if (explicit) return explicit;
+
+	const desktop = firstNonEmpty([process.env.XDG_CURRENT_DESKTOP, process.env.DESKTOP_SESSION]);
+	if (desktop) {
+		const matched = matchKnownWindowManager(desktop);
+		if (matched) return matched;
+	}
+
+	return "unknown";
+}
+
+/** Cached system info structure */
+interface SystemInfoCache {
+	os: string;
+	distro: string;
+	kernel: string;
+	arch: string;
+	cpu: string;
+	gpu: string;
+	disk: string;
+}
+
+function getSystemInfoCachePath(): string {
+	return join(homedir(), ".omp", "system_info.json");
+}
+
+function loadSystemInfoCache(): SystemInfoCache | null {
+	try {
+		const cachePath = getSystemInfoCachePath();
+		if (!existsSync(cachePath)) return null;
+		const content = readFileSync(cachePath, "utf-8");
+		return JSON.parse(content) as SystemInfoCache;
+	} catch {
+		return null;
+	}
+}
+
+function saveSystemInfoCache(info: SystemInfoCache): void {
+	try {
+		const cachePath = getSystemInfoCachePath();
+		const dir = join(homedir(), ".omp");
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		writeFileSync(cachePath, JSON.stringify(info, null, "\t"), "utf-8");
+	} catch {
+		// Silently ignore cache write failures
+	}
+}
+
+function collectSystemInfo(): SystemInfoCache {
+	return {
+		os: getOsName(),
+		distro: getOsDistro() ?? "unknown",
+		kernel: getKernelVersion(),
+		arch: getCpuArch(),
+		cpu: getCpuModel() ?? "unknown",
+		gpu: getGpuModel() ?? "unknown",
+		disk: getDiskInfo() ?? "unknown",
+	};
+}
+
+function formatBytes(bytes: number): string {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+	if (bytes < 1024 * 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+	return `${(bytes / (1024 * 1024 * 1024 * 1024)).toFixed(1)}TB`;
+}
+
+function getDiskInfo(): string | null {
+	switch (process.platform) {
+		case "win32": {
+			const output = execIfExists("wmic", ["logicaldisk", "get", "Caption,Size,FreeSpace", "/format:csv"]);
+			if (!output) return null;
+			const lines = output.split("\n").filter((l) => l.trim() && !l.startsWith("Node"));
+			const disks: string[] = [];
+			for (const line of lines) {
+				const parts = line.split(",");
+				if (parts.length < 4) continue;
+				const caption = parts[1]?.trim();
+				const freeSpace = Number.parseInt(parts[2]?.trim() ?? "", 10);
+				const size = Number.parseInt(parts[3]?.trim() ?? "", 10);
+				if (!caption || Number.isNaN(size) || size === 0) continue;
+				const used = size - (Number.isNaN(freeSpace) ? 0 : freeSpace);
+				const pct = Math.round((used / size) * 100);
+				disks.push(`${caption} ${formatBytes(used)}/${formatBytes(size)} (${pct}%)`);
+			}
+			return disks.length > 0 ? disks.join(", ") : null;
+		}
+		case "linux":
+		case "darwin": {
+			const output = execIfExists("df", ["-h", "/"]);
+			if (!output) return null;
+			const lines = output.split("\n");
+			if (lines.length < 2) return null;
+			const parts = lines[1].split(/\s+/);
+			if (parts.length < 5) return null;
+			const size = parts[1];
+			const used = parts[2];
+			const pct = parts[4];
+			return `/ ${used}/${size} (${pct})`;
+		}
+		default:
+			return null;
+	}
+}
+
+function formatEnvironmentInfo(): string {
+	// Load cached system info or collect fresh
+	let sysInfo = loadSystemInfoCache();
+	if (!sysInfo) {
+		sysInfo = collectSystemInfo();
+		saveSystemInfoCache(sysInfo);
+	}
+
+	// Session-specific values (not cached)
+	const items: Array<[string, string]> = [
+		["OS", sysInfo.os],
+		["Distro", sysInfo.distro],
+		["Kernel", sysInfo.kernel],
+		["Arch", sysInfo.arch],
+		["CPU", sysInfo.cpu],
+		["GPU", sysInfo.gpu],
+		["Disk", sysInfo.disk],
+		["Shell", getShellName()],
+		["Terminal", getTerminalName()],
+		["DE", getDesktopEnvironment()],
+		["WM", getWindowManager()],
+	];
+	return items.map(([label, value]) => `- ${label}: ${value}`).join("\n");
+}
+
 /**
  * Generate anti-bash rules section if the agent has both bash and specialized tools.
  * Only include rules for tools that are actually available.
@@ -201,6 +604,24 @@ function generateAntiBashRules(tools: ToolName[]): string | null {
 		);
 	}
 
+	// Add SSH remote filesystem guidance if available
+	const hasSSH = tools.includes("ssh");
+	if (hasSSH) {
+		lines.push("\n### SSH Command Execution");
+		lines.push(
+			"**Critical**: Each SSH host runs a specific shell. **You MUST match commands to the host's shell type**.",
+		);
+		lines.push("Check the host list in the ssh tool description. Shell types:");
+		lines.push("- linux/bash, linux/zsh, macos/bash, macos/zsh: ls, cat, grep, find, ps, df, uname");
+		lines.push("- windows/bash, windows/sh: ls, cat, grep, find (Windows with WSL/Cygwin — Unix commands)");
+		lines.push("- windows/cmd: dir, type, findstr, tasklist, systeminfo");
+		lines.push("- windows/powershell: Get-ChildItem, Get-Content, Select-String, Get-Process");
+		lines.push("");
+		lines.push("### SSH Filesystems");
+		lines.push("Mounted at `~/.omp/remote/<hostname>/` — use read/edit/write tools directly.");
+		lines.push("Windows paths need colon: `~/.omp/remote/host/C:/Users/...` not `C/Users/...`\n");
+	}
+
 	// Add search-first protocol
 	if (hasGrep || hasFind) {
 		lines.push("\n### Search-First Protocol");
@@ -389,6 +810,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 
 	// Generate anti-bash rules (returns null if not applicable)
 	const antiBashSection = generateAntiBashRules(Array.from(tools?.keys() ?? []));
+	const environmentInfo = formatEnvironmentInfo();
 
 	// Build guidelines based on which tools are actually available
 	const guidelinesList: string[] = [];
@@ -446,6 +868,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 		toolsList,
 		antiBashSection: antiBashBlock,
 		guidelines,
+		environmentInfo,
 		readmePath,
 		docsPath,
 		examplesPath,

package/src/core/title-generator.ts

@@ -2,8 +2,8 @@
  * Generate session titles using a smol, fast model.
  */
 
-import type { Api, Model } from "@mariozechner/pi-ai";
-import { completeSimple } from "@mariozechner/pi-ai";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { completeSimple } from "@oh-my-pi/pi-ai";
 import titleSystemPrompt from "../prompts/title-system.md" with { type: "text" };
 import { logger } from "./logger";
 import type { ModelRegistry } from "./model-registry";

package/src/core/tools/index.test.ts

@@ -162,6 +162,7 @@ describe("createTools", () => {
 		const expectedTools = [
 			"ask",
 			"bash",
+			"ssh",
 			"edit",
 			"find",
 			"git",

package/src/core/tools/index.ts

@@ -26,6 +26,7 @@ export { createOutputTool, type OutputToolDetails } from "./output";
 export { createReadTool, type ReadToolDetails } from "./read";
 export { reportFindingTool, type SubmitReviewDetails } from "./review";
 export { filterRulebookRules, formatRulesForPrompt, type RulebookToolDetails } from "./rulebook";
+export { createSshTool, type SSHToolDetails } from "./ssh";
 export { BUNDLED_AGENTS, createTaskTool, taskTool } from "./task/index";
 export type { TruncationResult } from "./truncate";
 export { createWebFetchTool, type WebFetchToolDetails } from "./web-fetch";
@@ -68,6 +69,7 @@ import { createOutputTool } from "./output";
 import { createReadTool } from "./read";
 import { reportFindingTool } from "./review";
 import { createRulebookTool } from "./rulebook";
+import { createSshTool } from "./ssh";
 import { createTaskTool } from "./task/index";
 import { createWebFetchTool } from "./web-fetch";
 import { createWebSearchTool } from "./web-search/index";
@@ -115,6 +117,7 @@ type ToolFactory = (session: ToolSession) => Tool | null | Promise<Tool | null>;
 export const BUILTIN_TOOLS: Record<string, ToolFactory> = {
 	ask: createAskTool,
 	bash: createBashTool,
+	ssh: createSshTool,
 	edit: createEditTool,
 	find: createFindTool,
 	git: createGitTool,

package/src/core/tools/output.ts

@@ -6,8 +6,8 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";

package/src/core/tools/read.ts

@@ -1,9 +1,11 @@
+import { homedir } from "node:os";
 import path from "node:path";
-import type { ImageContent, TextContent } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text } from "@oh-my-pi/pi-tui";
 import { Type } from "@sinclair/typebox";
+import { CONFIG_DIR_NAME } from "../../config";
 import { getLanguageFromPath, highlightCode, type Theme } from "../../modes/interactive/theme/theme";
 import readDescription from "../../prompts/tools/read.md" with { type: "text" };
 import { formatDimensionNote, resizeImage } from "../../utils/image-resize";
@@ -27,6 +29,13 @@ import {
 // Document types convertible via markitdown
 const CONVERTIBLE_EXTENSIONS = new Set([".pdf", ".doc", ".docx", ".ppt", ".pptx", ".xls", ".xlsx", ".rtf", ".epub"]);
 
+// Remote mount path prefix (sshfs mounts) - skip fuzzy matching to avoid hangs
+const REMOTE_MOUNT_PREFIX = path.join(homedir(), CONFIG_DIR_NAME, "remote") + path.sep;
+
+function isRemoteMountPath(absolutePath: string): boolean {
+	return absolutePath.startsWith(REMOTE_MOUNT_PREFIX);
+}
+
 // Maximum image file size (20MB) - larger images will be rejected to prevent OOM during serialization
 const MAX_IMAGE_SIZE = 20 * 1024 * 1024;
 const MAX_FUZZY_RESULTS = 5;
@@ -438,19 +447,23 @@ export function createReadTool(session: ToolSession): AgentTool<typeof readSchem
 					isDirectory = stat.isDirectory();
 				} catch (error) {
 					if (isNotFoundError(error)) {
-						const suggestions = await findReadPathSuggestions(readPath, session.cwd, signal);
 						let message = `File not found: ${readPath}`;
 
-						if (suggestions?.suggestions.length) {
-							const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";
-							message += `\n\nClosest matches${scopeLabel}:\n${suggestions.suggestions.map((match) => `- ${match}`).join("\n")}`;
-							if (suggestions.truncated) {
-								message += `\n[Search truncated to first ${MAX_FUZZY_CANDIDATES} paths. Refine the path if the match isn't listed.]`;
+						// Skip fuzzy matching for remote mounts (sshfs) to avoid hangs
+						if (!isRemoteMountPath(absolutePath)) {
+							const suggestions = await findReadPathSuggestions(readPath, session.cwd, signal);
+
+							if (suggestions?.suggestions.length) {
+								const scopeLabel = suggestions.scopeLabel ? ` in ${suggestions.scopeLabel}` : "";
+								message += `\n\nClosest matches${scopeLabel}:\n${suggestions.suggestions.map((match) => `- ${match}`).join("\n")}`;
+								if (suggestions.truncated) {
+									message += `\n[Search truncated to first ${MAX_FUZZY_CANDIDATES} paths. Refine the path if the match isn't listed.]`;
+								}
+							} else if (suggestions?.error) {
+								message += `\n\nFuzzy match failed: ${suggestions.error}`;
+							} else if (suggestions?.scopeLabel) {
+								message += `\n\nNo similar paths found in ${suggestions.scopeLabel}.`;
 							}
-						} else if (suggestions?.error) {
-							message += `\n\nFuzzy match failed: ${suggestions.error}`;
-						} else if (suggestions?.scopeLabel) {
-							message += `\n\nNo similar paths found in ${suggestions.scopeLabel}.`;
 						}
 
 						throw new Error(message);

package/src/core/tools/renderers.ts

@@ -17,6 +17,7 @@ import { lspToolRenderer } from "./lsp/render";
 import { notebookToolRenderer } from "./notebook";
 import { outputToolRenderer } from "./output";
 import { readToolRenderer } from "./read";
+import { sshToolRenderer } from "./ssh";
 import { taskToolRenderer } from "./task/render";
 import { webFetchToolRenderer } from "./web-fetch";
 import { webSearchToolRenderer } from "./web-search/render";
@@ -43,6 +44,7 @@ export const toolRenderers: Record<string, ToolRenderer> = {
 	notebook: notebookToolRenderer as ToolRenderer,
 	output: outputToolRenderer as ToolRenderer,
 	read: readToolRenderer as ToolRenderer,
+	ssh: sshToolRenderer as ToolRenderer,
 	task: taskToolRenderer as ToolRenderer,
 	web_fetch: webFetchToolRenderer as ToolRenderer,
 	web_search: webSearchToolRenderer as ToolRenderer,