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

package/src/core/tools/ssh.ts

@@ -0,0 +1,302 @@
+import type { AgentTool, AgentToolContext } from "@oh-my-pi/pi-agent-core";
+import type { Component } from "@oh-my-pi/pi-tui";
+import { Text } from "@oh-my-pi/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { SSHHost } from "../../capability/ssh";
+import { sshCapability } from "../../capability/ssh";
+import { loadSync } from "../../discovery/index";
+import type { Theme } from "../../modes/interactive/theme/theme";
+import sshDescriptionBase from "../../prompts/tools/ssh.md" with { type: "text" };
+import type { RenderResultOptions } from "../custom-tools/types";
+import type { SSHHostInfo } from "../ssh/connection-manager";
+import { ensureHostInfo, getHostInfoForHost } from "../ssh/connection-manager";
+import { executeSSH } from "../ssh/ssh-executor";
+import type { ToolSession } from "./index";
+import { createToolUIKit } from "./render-utils";
+import { DEFAULT_MAX_BYTES, formatSize, type TruncationResult, truncateTail } from "./truncate";
+
+const sshSchema = Type.Object({
+	host: Type.String({ description: "Host name from ssh.json or .ssh.json" }),
+	command: Type.String({ description: "Command to execute on the remote host" }),
+	cwd: Type.Optional(Type.String({ description: "Remote working directory (optional)" })),
+	timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" })),
+});
+
+export interface SSHToolDetails {
+	truncation?: TruncationResult;
+	fullOutputPath?: string;
+}
+
+function formatHostEntry(host: SSHHost): string {
+	const info = getHostInfoForHost(host);
+
+	let shell: string;
+	if (!info) {
+		shell = "detecting...";
+	} else if (info.os === "windows") {
+		if (info.compatEnabled) {
+			const compatShell = info.compatShell || "bash";
+			shell = `windows/${compatShell}`;
+		} else if (info.shell === "powershell") {
+			shell = "windows/powershell";
+		} else {
+			shell = "windows/cmd";
+		}
+	} else if (info.os === "linux") {
+		shell = `linux/${info.shell}`;
+	} else if (info.os === "macos") {
+		shell = `macos/${info.shell}`;
+	} else {
+		shell = `unknown/${info.shell}`;
+	}
+
+	return `- ${host.name} (${host.host}) | ${shell}`;
+}
+
+function formatDescription(hosts: SSHHost[]): string {
+	if (hosts.length === 0) {
+		return sshDescriptionBase;
+	}
+	const hostList = hosts.map(formatHostEntry).join("\n");
+	return `${sshDescriptionBase}\n\nAvailable hosts:\n${hostList}`;
+}
+
+function quoteRemotePath(value: string): string {
+	if (value.length === 0) {
+		return "''";
+	}
+	const escaped = value.replace(/'/g, "'\\''");
+	return `'${escaped}'`;
+}
+
+function quotePowerShellPath(value: string): string {
+	if (value.length === 0) {
+		return "''";
+	}
+	const escaped = value.replace(/'/g, "''");
+	return `'${escaped}'`;
+}
+
+function quoteCmdPath(value: string): string {
+	const escaped = value.replace(/"/g, '""');
+	return `"${escaped}"`;
+}
+
+function buildRemoteCommand(command: string, cwd: string | undefined, info: SSHHostInfo): string {
+	if (!cwd) return command;
+
+	if (info.os === "windows" && !info.compatEnabled) {
+		if (info.shell === "powershell") {
+			return `Set-Location -Path ${quotePowerShellPath(cwd)}; ${command}`;
+		}
+		return `cd /d ${quoteCmdPath(cwd)} && ${command}`;
+	}
+
+	return `cd -- ${quoteRemotePath(cwd)} && ${command}`;
+}
+
+function loadHosts(session: ToolSession): {
+	hostNames: string[];
+	hostsByName: Map<string, SSHHost>;
+} {
+	const result = loadSync<SSHHost>(sshCapability.id, { cwd: session.cwd });
+	const hostsByName = new Map<string, SSHHost>();
+	for (const host of result.items) {
+		if (!hostsByName.has(host.name)) {
+			hostsByName.set(host.name, host);
+		}
+	}
+	const hostNames = Array.from(hostsByName.keys()).sort();
+	return { hostNames, hostsByName };
+}
+
+export function createSshTool(session: ToolSession): AgentTool<typeof sshSchema> | null {
+	const { hostNames, hostsByName } = loadHosts(session);
+	if (hostNames.length === 0) {
+		return null;
+	}
+
+	const allowedHosts = new Set(hostNames);
+
+	const descriptionHosts = hostNames
+		.map((name) => hostsByName.get(name))
+		.filter((host): host is SSHHost => host !== undefined);
+
+	return {
+		name: "ssh",
+		label: "SSH",
+		description: formatDescription(descriptionHosts),
+		parameters: sshSchema,
+		execute: async (
+			_toolCallId: string,
+			{ host, command, cwd, timeout }: { host: string; command: string; cwd?: string; timeout?: number },
+			signal?: AbortSignal,
+			onUpdate?,
+			_ctx?: AgentToolContext,
+		) => {
+			if (!allowedHosts.has(host)) {
+				throw new Error(`Unknown SSH host: ${host}. Available hosts: ${hostNames.join(", ")}`);
+			}
+
+			const hostConfig = hostsByName.get(host);
+			if (!hostConfig) {
+				throw new Error(`SSH host not loaded: ${host}`);
+			}
+
+			const hostInfo = await ensureHostInfo(hostConfig);
+			const remoteCommand = buildRemoteCommand(command, cwd, hostInfo);
+			let currentOutput = "";
+
+			const result = await executeSSH(hostConfig, remoteCommand, {
+				timeout: timeout ? timeout * 1000 : undefined,
+				signal,
+				compatEnabled: hostInfo.compatEnabled,
+				onChunk: (chunk) => {
+					currentOutput += chunk;
+					if (onUpdate) {
+						const truncation = truncateTail(currentOutput);
+						onUpdate({
+							content: [{ type: "text", text: truncation.content || "" }],
+							details: {
+								truncation: truncation.truncated ? truncation : undefined,
+							},
+						});
+					}
+				},
+			});
+
+			if (result.cancelled) {
+				throw new Error(result.output || "Command aborted");
+			}
+
+			const truncation = truncateTail(result.output);
+			let outputText = truncation.content || "(no output)";
+
+			let details: SSHToolDetails | undefined;
+
+			if (truncation.truncated) {
+				details = {
+					truncation,
+					fullOutputPath: result.fullOutputPath,
+				};
+
+				const startLine = truncation.totalLines - truncation.outputLines + 1;
+				const endLine = truncation.totalLines;
+
+				if (truncation.lastLinePartial) {
+					const lastLineSize = formatSize(Buffer.byteLength(result.output.split("\n").pop() || "", "utf-8"));
+					outputText += `\n\n[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${result.fullOutputPath}]`;
+				} else if (truncation.truncatedBy === "lines") {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${result.fullOutputPath}]`;
+				} else {
+					outputText += `\n\n[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(DEFAULT_MAX_BYTES)} limit). Full output: ${result.fullOutputPath}]`;
+				}
+			}
+
+			if (result.exitCode !== 0 && result.exitCode !== undefined) {
+				outputText += `\n\nCommand exited with code ${result.exitCode}`;
+				throw new Error(outputText);
+			}
+
+			return { content: [{ type: "text", text: outputText }], details };
+		},
+	};
+}
+
+// =============================================================================
+// TUI Renderer
+// =============================================================================
+
+interface SshRenderArgs {
+	host?: string;
+	command?: string;
+	timeout?: number;
+}
+
+interface SshRenderContext {
+	/** Visual lines for truncated output (pre-computed by tool-execution) */
+	visualLines?: string[];
+	/** Number of lines skipped */
+	skippedCount?: number;
+	/** Total visual lines */
+	totalVisualLines?: number;
+}
+
+export const sshToolRenderer = {
+	renderCall(args: SshRenderArgs, uiTheme: Theme): Component {
+		const ui = createToolUIKit(uiTheme);
+		const host = args.host || uiTheme.format.ellipsis;
+		const command = args.command || uiTheme.format.ellipsis;
+		const text = ui.title(`[${host}] $ ${command}`);
+		return new Text(text, 0, 0);
+	},
+
+	renderResult(
+		result: {
+			content: Array<{ type: string; text?: string }>;
+			details?: SSHToolDetails;
+		},
+		options: RenderResultOptions & { renderContext?: SshRenderContext },
+		uiTheme: Theme,
+	): Component {
+		const ui = createToolUIKit(uiTheme);
+		const { expanded, renderContext } = options;
+		const details = result.details;
+		const lines: string[] = [];
+
+		const textContent = result.content?.find((c) => c.type === "text")?.text ?? "";
+		const output = textContent.trim();
+
+		if (output) {
+			if (expanded) {
+				const styledOutput = output
+					.split("\n")
+					.map((line) => uiTheme.fg("toolOutput", line))
+					.join("\n");
+				lines.push(styledOutput);
+			} else if (renderContext?.visualLines) {
+				const { visualLines, skippedCount = 0, totalVisualLines = visualLines.length } = renderContext;
+				if (skippedCount > 0) {
+					lines.push(
+						uiTheme.fg(
+							"dim",
+							`${uiTheme.format.ellipsis} (${skippedCount} earlier lines, showing ${visualLines.length} of ${totalVisualLines}) (ctrl+o to expand)`,
+						),
+					);
+				}
+				lines.push(...visualLines);
+			} else {
+				const outputLines = output.split("\n");
+				const maxLines = 5;
+				const displayLines = outputLines.slice(0, maxLines);
+				const remaining = outputLines.length - maxLines;
+
+				lines.push(...displayLines.map((line) => uiTheme.fg("toolOutput", line)));
+				if (remaining > 0) {
+					lines.push(uiTheme.fg("dim", `${uiTheme.format.ellipsis} (${remaining} more lines) (ctrl+o to expand)`));
+				}
+			}
+		}
+
+		const truncation = details?.truncation;
+		const fullOutputPath = details?.fullOutputPath;
+		if (truncation?.truncated || fullOutputPath) {
+			const warnings: string[] = [];
+			if (fullOutputPath) {
+				warnings.push(`Full output: ${fullOutputPath}`);
+			}
+			if (truncation?.truncated) {
+				if (truncation.truncatedBy === "lines") {
+					warnings.push(`Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines`);
+				} else {
+					warnings.push(
+						`Truncated: ${truncation.outputLines} lines shown (${ui.formatBytes(truncation.maxBytes ?? DEFAULT_MAX_BYTES)} limit)`,
+					);
+				}
+			}
+			lines.push(uiTheme.fg("warning", ui.wrapBrackets(warnings.join(". "))));
+		}
+
+		return new Text(lines.join("\n"), 0, 0);
+	},
+};

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

@@ -13,8 +13,8 @@
  *   - Session artifacts for debugging
  */
 
-import type { Usage } from "@mariozechner/pi-ai";
 import type { AgentTool } from "@oh-my-pi/pi-agent-core";
+import type { Usage } from "@oh-my-pi/pi-ai";
 import type { Theme } from "../../../modes/interactive/theme/theme";
 import taskDescriptionTemplate from "../../../prompts/tools/task.md" with { type: "text" };
 import { formatDuration } from "../render-utils";

package/src/core/tools/task/types.ts

@@ -1,4 +1,4 @@
-import type { Usage } from "@mariozechner/pi-ai";
+import type { Usage } from "@oh-my-pi/pi-ai";
 import { type Static, Type } from "@sinclair/typebox";
 
 /** Source of an agent definition */

package/src/core/tools/task/worker.ts

@@ -13,8 +13,8 @@
  * 5. Parent can send { type: "abort" } to request cancellation
  */
 
-import type { Api, Model } from "@mariozechner/pi-ai";
 import type { AgentEvent, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { Api, Model } from "@oh-my-pi/pi-ai";
 import type { AgentSessionEvent } from "../../agent-session";
 import { parseModelPattern, parseModelString } from "../../model-resolver";
 import { createAgentSession, discoverAuthStorage, discoverModels } from "../../sdk";

package/src/core/voice.ts

@@ -1,7 +1,7 @@
 import { unlinkSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { completeSimple, type Model } from "@mariozechner/pi-ai";
+import { completeSimple, type Model } from "@oh-my-pi/pi-ai";
 import { nanoid } from "nanoid";
 import voiceSummaryPrompt from "../prompts/voice-summary.md" with { type: "text" };
 import { logger } from "./logger";

package/src/discovery/index.ts

@@ -18,6 +18,7 @@ import "../capability/settings";
 import "../capability/skill";
 import "../capability/slash-command";
 import "../capability/system-prompt";
+import "../capability/ssh";
 import "../capability/tool";
 
 // Import providers (each registers itself on import)
@@ -32,6 +33,7 @@ import "./github";
 import "./vscode";
 import "./agents-md";
 import "./mcp-json";
+import "./ssh";
 
 export type { ContextFile } from "../capability/context-file";
 export type { Extension, ExtensionManifest } from "../capability/extension";
@@ -70,6 +72,7 @@ export type { Rule, RuleFrontmatter } from "../capability/rule";
 export type { Settings } from "../capability/settings";
 export type { Skill, SkillFrontmatter } from "../capability/skill";
 export type { SlashCommand } from "../capability/slash-command";
+export type { SSHHost } from "../capability/ssh";
 export type { SystemPrompt } from "../capability/system-prompt";
 export type { CustomTool } from "../capability/tool";
 // Re-export types

package/src/discovery/ssh.ts

@@ -0,0 +1,162 @@
+/**
+ * SSH JSON Provider
+ *
+ * Discovers SSH hosts from ssh.json or .ssh.json in the project root.
+ * Priority: 5 (low, project-level only)
+ */
+
+import { join } from "node:path";
+import { registerProvider } from "../capability/index";
+import { type SSHHost, sshCapability } from "../capability/ssh";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
+import { createSourceMeta, expandEnvVarsDeep, parseJSON } from "./helpers";
+
+const PROVIDER_ID = "ssh-json";
+const DISPLAY_NAME = "SSH Config";
+
+interface SSHConfigFile {
+	hosts?: Record<
+		string,
+		{
+			host?: string;
+			username?: string;
+			port?: number | string;
+			compat?: boolean | string;
+			key?: string;
+			keyPath?: string;
+			description?: string;
+		}
+	>;
+}
+
+function expandTilde(value: string, home: string): string {
+	if (value === "~") return home;
+	if (value.startsWith("~/") || value.startsWith("~\\")) {
+		return `${home}${value.slice(1)}`;
+	}
+	return value;
+}
+
+function parsePort(value: number | string | undefined): number | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isNaN(parsed) ? undefined : parsed;
+}
+
+function parseCompat(value: boolean | string | undefined): boolean | undefined {
+	if (value === undefined) return undefined;
+	if (typeof value === "boolean") return value;
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "true" || normalized === "1" || normalized === "yes") return true;
+	if (normalized === "false" || normalized === "0" || normalized === "no") return false;
+	return undefined;
+}
+
+function normalizeHost(
+	name: string,
+	raw: NonNullable<SSHConfigFile["hosts"]>[string],
+	source: SourceMeta,
+	home: string,
+	warnings: string[],
+): SSHHost | null {
+	if (!raw.host) {
+		warnings.push(`Missing host for SSH entry: ${name}`);
+		return null;
+	}
+
+	const port = parsePort(raw.port);
+	if (raw.port !== undefined && port === undefined) {
+		warnings.push(`Invalid port for SSH entry ${name}: ${String(raw.port)}`);
+	}
+
+	const compat = parseCompat(raw.compat);
+	if (raw.compat !== undefined && compat === undefined) {
+		warnings.push(`Invalid compat flag for SSH entry ${name}: ${String(raw.compat)}`);
+	}
+
+	const keyValue = raw.keyPath ?? raw.key;
+	const keyPath = keyValue ? expandTilde(keyValue, home) : undefined;
+
+	return {
+		name,
+		host: raw.host,
+		username: raw.username,
+		port,
+		keyPath,
+		description: raw.description,
+		compat,
+		_source: source,
+	};
+}
+
+function loadSshJsonFile(ctx: LoadContext, path: string): LoadResult<SSHHost> {
+	const items: SSHHost[] = [];
+	const warnings: string[] = [];
+
+	if (!ctx.fs.isFile(path)) {
+		return { items, warnings };
+	}
+
+	const content = ctx.fs.readFile(path);
+	if (content === null) {
+		warnings.push(`Failed to read ${path}`);
+		return { items, warnings };
+	}
+
+	const parsed = parseJSON<SSHConfigFile>(content);
+	if (!parsed) {
+		warnings.push(`Failed to parse JSON in ${path}`);
+		return { items, warnings };
+	}
+
+	const config = expandEnvVarsDeep(parsed);
+	if (!config.hosts || typeof config.hosts !== "object") {
+		warnings.push(`Missing hosts in ${path}`);
+		return { items, warnings };
+	}
+
+	const source = createSourceMeta(PROVIDER_ID, path, "project");
+	for (const [name, rawHost] of Object.entries(config.hosts)) {
+		if (!name.trim()) {
+			warnings.push(`Invalid SSH host name in ${path}`);
+			continue;
+		}
+		if (!rawHost || typeof rawHost !== "object") {
+			warnings.push(`Invalid host entry in ${path}: ${name}`);
+			continue;
+		}
+		const host = normalizeHost(name, rawHost, source, ctx.home, warnings);
+		if (host) items.push(host);
+	}
+
+	return {
+		items,
+		warnings: warnings.length > 0 ? warnings : undefined,
+	};
+}
+
+function load(ctx: LoadContext): LoadResult<SSHHost> {
+	const allItems: SSHHost[] = [];
+	const allWarnings: string[] = [];
+
+	for (const filename of ["ssh.json", ".ssh.json"]) {
+		const path = join(ctx.cwd, filename);
+		const result = loadSshJsonFile(ctx, path);
+		allItems.push(...result.items);
+		if (result.warnings) allWarnings.push(...result.warnings);
+	}
+
+	return {
+		items: allItems,
+		warnings: allWarnings.length > 0 ? allWarnings : undefined,
+	};
+}
+
+registerProvider(sshCapability.id, {
+	id: PROVIDER_ID,
+	displayName: DISPLAY_NAME,
+	description: "Load SSH hosts from ssh.json or .ssh.json in the project root",
+	priority: 5,
+	load,
+});

package/src/main.ts

@@ -7,7 +7,7 @@
 
 import { homedir, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
-import { type ImageContent, supportsXhigh } from "@mariozechner/pi-ai";
+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";

package/src/modes/interactive/components/assistant-message.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 import { getMarkdownTheme, theme } from "../theme/theme";
 

package/src/modes/interactive/components/custom-message.ts

@@ -1,4 +1,4 @@
-import type { TextContent } from "@mariozechner/pi-ai";
+import type { TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Box, Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 import type { MessageRenderer } from "../../../core/extensions/types";

package/src/modes/interactive/components/footer.ts

@@ -1,5 +1,5 @@
 import { existsSync, type FSWatcher, readFileSync, watch } from "node:fs";
-import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { dirname, join } from "path";
 import type { AgentSession } from "../../../core/agent-session";

package/src/modes/interactive/components/hook-message.ts

@@ -1,4 +1,4 @@
-import type { TextContent } from "@mariozechner/pi-ai";
+import type { TextContent } from "@oh-my-pi/pi-ai";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Box, Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 import type { HookMessageRenderer } from "../../../core/hooks/types";

package/src/modes/interactive/components/model-selector.ts

@@ -1,4 +1,4 @@
-import { type Model, modelsAreEqual } from "@mariozechner/pi-ai";
+import { type Model, modelsAreEqual } from "@oh-my-pi/pi-ai";
 import {
 	Container,
 	Input,

package/src/modes/interactive/components/oauth-selector.ts

@@ -1,4 +1,4 @@
-import { getOAuthProviders, type OAuthProviderInfo } from "@mariozechner/pi-ai";
+import { getOAuthProviders, type OAuthProviderInfo } from "@oh-my-pi/pi-ai";
 import { Container, isArrowDown, isArrowUp, isCtrlC, isEnter, isEscape, Spacer, TruncatedText } from "@oh-my-pi/pi-tui";
 import type { AuthStorage } from "../../../core/auth-storage";
 import { theme } from "../theme/theme";

package/src/modes/interactive/components/status-line.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage } from "@mariozechner/pi-ai";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@oh-my-pi/pi-tui";
 import { type FSWatcher, watch } from "fs";
 import { dirname, join } from "path";

package/src/modes/interactive/interactive-mode.ts

@@ -6,8 +6,8 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import type { AssistantMessage, ImageContent, Message, OAuthProvider } from "@mariozechner/pi-ai";
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage, ImageContent, Message, OAuthProvider } from "@oh-my-pi/pi-ai";
 import type { SlashCommand } from "@oh-my-pi/pi-tui";
 import {
 	CombinedAutocompleteProvider,

package/src/modes/print-mode.ts

@@ -6,7 +6,7 @@
  * - `omp --mode json "prompt"` - JSON event stream
  */
 
-import type { AssistantMessage, ImageContent } from "@mariozechner/pi-ai";
+import type { AssistantMessage, ImageContent } from "@oh-my-pi/pi-ai";
 import type { AgentSession } from "../core/agent-session";
 
 /**

package/src/modes/rpc/rpc-client.ts

@@ -4,8 +4,8 @@
  * Spawns the agent in RPC mode and provides a typed API for all operations.
  */
 
-import type { ImageContent } from "@mariozechner/pi-ai";
 import type { AgentEvent, AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent } from "@oh-my-pi/pi-ai";
 import type { Subprocess } from "bun";
 import type { SessionStats } from "../../core/agent-session";
 import type { BashResult } from "../../core/bash-executor";

package/src/modes/rpc/rpc-types.ts

@@ -5,8 +5,8 @@
  * Responses and events are emitted as JSON lines on stdout.
  */
 
-import type { ImageContent, Model } from "@mariozechner/pi-ai";
 import type { AgentMessage, ThinkingLevel } from "@oh-my-pi/pi-agent-core";
+import type { ImageContent, Model } from "@oh-my-pi/pi-ai";
 import type { SessionStats } from "../../core/agent-session";
 import type { BashResult } from "../../core/bash-executor";
 import type { CompactionResult } from "../../core/compaction/index";

package/src/prompts/system-prompt.md

@@ -21,6 +21,10 @@ Core behavior:
 - After each tool result, check relevance; iterate or clarify if results conflict or are insufficient.
 - Use concise, scannable responses; include file paths in backticks; use short bullets for multi-item lists; avoid dumping large files.
 
+<environment>
+{{environmentInfo}}
+</environment>
+
 Documentation:
 - Main documentation: {{readmePath}}
 - Additional docs: {{docsPath}}