@f5-sales-demo/xcsh 19.51.2

package/src/utils/clipboard.ts

@@ -0,0 +1,80 @@
+import { execSync } from "node:child_process";
+import type { ClipboardImage } from "@f5xc-salesdemos/pi-natives";
+import * as native from "@f5xc-salesdemos/pi-natives";
+
+const hasDisplay = process.platform !== "linux" || Boolean(process.env.DISPLAY || process.env.WAYLAND_DISPLAY);
+
+/**
+ * Copy text to the system clipboard.
+ *
+ * Emits OSC 52 first when running in a real terminal (works over SSH/mosh),
+ * then attempts native clipboard copy as best-effort for local sessions.
+ * On Termux, tries `termux-clipboard-set` before native.
+ *
+ * @param text - UTF-8 text to place on the clipboard.
+ */
+export async function copyToClipboard(text: string): Promise<void> {
+	if (process.stdout.isTTY) {
+		const onError = (err: unknown) => {
+			process.stdout.off("error", onError);
+			// Prevent unhandled 'error' from crashing the process when stdout is a closed pipe.
+			if ((err as NodeJS.ErrnoException | null | undefined)?.code === "EPIPE") {
+				return;
+			}
+		};
+		try {
+			const encoded = Buffer.from(text).toString("base64");
+			const osc52 = `\x1b]52;c;${encoded}\x07`;
+			process.stdout.on("error", onError);
+			process.stdout.write(osc52, err => {
+				process.stdout.off("error", onError);
+				// If stdout is closed (e.g. piped to a process that exits early),
+				// ignore EPIPE and proceed with native clipboard best-effort.
+				if ((err as NodeJS.ErrnoException | null | undefined)?.code === "EPIPE") {
+					return;
+				}
+			});
+		} catch (err) {
+			process.stdout.off("error", onError);
+			if ((err as NodeJS.ErrnoException | null | undefined)?.code !== "EPIPE") {
+				// Ignore all write failures (OSC 52 is best-effort).
+			}
+		}
+	}
+
+	// Also try native tools (best effort for local sessions)
+	try {
+		if (process.env.TERMUX_VERSION) {
+			try {
+				execSync("termux-clipboard-set", { input: text, timeout: 5000 });
+				return;
+			} catch {
+				// Fall through to native
+			}
+		}
+
+		await native.copyToClipboard(text);
+	} catch {
+		// Ignore — clipboard copy is best-effort
+	}
+}
+
+/**
+ * Read an image from the system clipboard.
+ *
+ * Returns null on Termux (no image clipboard support) or when no display
+ * server is available (headless/SSH without forwarding).
+ *
+ * @returns PNG payload or null when no image is available.
+ */
+export async function readImageFromClipboard(): Promise<ClipboardImage | null> {
+	if (process.env.TERMUX_VERSION) {
+		return null;
+	}
+
+	if (!hasDisplay) {
+		return null;
+	}
+
+	return (await native.readImageFromClipboard()) ?? null;
+}

package/src/utils/command-args.ts

@@ -0,0 +1,76 @@
+export function parseCommandArgs(argsString: string): string[] {
+	const args: string[] = [];
+	let current = "";
+	let inQuote: string | null = null;
+
+	for (let i = 0; i < argsString.length; i++) {
+		const char = argsString[i];
+
+		if (inQuote) {
+			if (char === inQuote) {
+				inQuote = null;
+			} else {
+				current += char;
+			}
+		} else if (char === '"' || char === "'") {
+			inQuote = char;
+		} else if (char === " " || char === "\t") {
+			if (current) {
+				args.push(current);
+				current = "";
+			}
+		} else {
+			current += char;
+		}
+	}
+
+	if (current) {
+		args.push(current);
+	}
+
+	return args;
+}
+
+/**
+ * Substitute argument placeholders in template content
+ * Supports $1, $2, ... for positional args, $@ and $ARGUMENTS for all args
+ *
+ * Note: Replacement happens on the template string only. Argument values
+ * containing patterns like $1, $@, or $ARGUMENTS are NOT recursively substituted.
+ */
+export function substituteArgs(content: string, args: string[]): string {
+	let result = content;
+
+	// Replace $1, $2, etc. with positional args FIRST (before wildcards)
+	// This prevents wildcard replacement values containing $<digit> patterns from being re-substituted
+	result = result.replace(/\$(\d+)/g, (_, num) => {
+		const index = parseInt(num, 10) - 1;
+		return args[index] ?? "";
+	});
+
+	result = result.replace(/\$@\[(\d+)(?::(\d*)?)?\]/g, (_, startRaw: string, lengthRaw?: string) => {
+		const start = Number.parseInt(startRaw, 10);
+		if (!Number.isFinite(start) || start < 1) return "";
+		const startIndex = start - 1;
+		if (startIndex >= args.length) return "";
+
+		if (lengthRaw === undefined || lengthRaw === "") {
+			return args.slice(startIndex).join(" ");
+		}
+
+		const length = Number.parseInt(lengthRaw, 10);
+		if (!Number.isFinite(length) || length <= 0) return "";
+		return args.slice(startIndex, startIndex + length).join(" ");
+	});
+
+	// Pre-compute all args joined (optimization)
+	const allArgs = args.join(" ");
+
+	// Replace $ARGUMENTS with all args joined (new syntax, aligns with Claude, Codex, OpenCode)
+	result = result.replaceAll("$ARGUMENTS", allArgs);
+
+	// Replace $@ with all args joined (existing syntax)
+	result = result.replaceAll("$@", allArgs);
+
+	return result;
+}

package/src/utils/commit-message-generator.ts

@@ -0,0 +1,137 @@
+/**
+ * Generate commit messages from diffs using a smol, fast model.
+ * Follows the same pattern as title-generator.ts.
+ */
+import type { ThinkingLevel } from "@f5xc-salesdemos/pi-agent-core";
+import type { Api, Model } from "@f5xc-salesdemos/pi-ai";
+import { completeSimple } from "@f5xc-salesdemos/pi-ai";
+import { logger, prompt } from "@f5xc-salesdemos/pi-utils";
+import type { ModelRegistry } from "../config/model-registry";
+import { resolveModelRoleValue } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import MODEL_PRIO from "../priority.json" with { type: "json" };
+import commitSystemPrompt from "../prompts/system/commit-message-system.md" with { type: "text" };
+import { toReasoningEffort } from "../thinking";
+
+const COMMIT_SYSTEM_PROMPT = prompt.render(commitSystemPrompt);
+const MAX_DIFF_CHARS = 4000;
+
+/** File patterns that should be excluded from commit message generation diffs. */
+const NOISE_SUFFIXES = [".lock", ".lockb", "-lock.json", "-lock.yaml"];
+
+/** Strip diff hunks for noisy files that drown out real changes. */
+function filterDiffNoise(diff: string): string {
+	const lines = diff.split("\n");
+	const filtered: string[] = [];
+	let skip = false;
+	for (const line of lines) {
+		if (line.startsWith("diff --git ")) {
+			const bPath = line.split(" b/")[1];
+			skip = bPath != null && NOISE_SUFFIXES.some(s => bPath.endsWith(s));
+		}
+		if (!skip) filtered.push(line);
+	}
+	return filtered.join("\n");
+}
+
+function getSmolModelCandidates(
+	registry: ModelRegistry,
+	settings: Settings,
+): Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return [];
+
+	const candidates: Array<{ model: Model<Api>; thinkingLevel?: ThinkingLevel }> = [];
+	const addCandidate = (model?: Model<Api>, thinkingLevel?: ThinkingLevel): void => {
+		if (!model) return;
+		if (candidates.some(c => c.model.provider === model.provider && c.model.id === model.id)) return;
+		candidates.push({ model, thinkingLevel });
+	};
+
+	const matchPreferences = { usageOrder: settings.getStorage()?.getModelUsageOrder() };
+	const configuredSmol = resolveModelRoleValue(settings.getModelRole("smol"), availableModels, {
+		settings,
+		matchPreferences,
+		modelRegistry: registry,
+	});
+	addCandidate(configuredSmol.model, configuredSmol.thinkingLevel);
+
+	for (const pattern of MODEL_PRIO.smol) {
+		const needle = pattern.toLowerCase();
+		addCandidate(availableModels.find(m => m.id.toLowerCase() === needle));
+		addCandidate(availableModels.find(m => m.id.toLowerCase().includes(needle)));
+	}
+
+	for (const model of availableModels) {
+		addCandidate(model);
+	}
+
+	return candidates;
+}
+
+/**
+ * Generate a commit message from a unified diff.
+ * Returns null if generation fails (caller should fall back to generic message).
+ */
+export async function generateCommitMessage(
+	diff: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+): Promise<string | null> {
+	const candidates = getSmolModelCandidates(registry, settings);
+	if (candidates.length === 0) {
+		logger.debug("commit-msg-generator: no smol model found");
+		return null;
+	}
+
+	const cleanDiff = filterDiffNoise(diff);
+	const truncatedDiff =
+		cleanDiff.length > MAX_DIFF_CHARS ? `${cleanDiff.slice(0, MAX_DIFF_CHARS)}\n… (truncated)` : cleanDiff;
+	if (!truncatedDiff.trim()) {
+		logger.debug("commit-msg-generator: diff is empty after noise filtering");
+		return null;
+	}
+	const userMessage = `<diff>\n${truncatedDiff}\n</diff>`;
+
+	for (const candidate of candidates) {
+		const apiKey = await registry.getApiKey(candidate.model, sessionId);
+		if (!apiKey) continue;
+
+		try {
+			const response = await completeSimple(
+				candidate.model,
+				{
+					systemPrompt: COMMIT_SYSTEM_PROMPT,
+					messages: [{ role: "user", content: userMessage, timestamp: Date.now() }],
+				},
+				{ apiKey, maxTokens: 60, reasoning: toReasoningEffort(candidate.thinkingLevel) },
+			);
+
+			if (response.stopReason === "error") {
+				logger.debug("commit-msg-generator: error", { model: candidate.model.id, error: response.errorMessage });
+				continue;
+			}
+
+			let msg = "";
+			for (const content of response.content) {
+				if (content.type === "text") msg += content.text;
+			}
+			msg = msg.trim();
+			if (!msg) continue;
+
+			// Clean up: remove wrapping quotes, backticks, trailing period
+			msg = msg.replace(/^[`"']|[`"']$/g, "").replace(/\.$/, "");
+
+			logger.debug("commit-msg-generator: generated", { model: candidate.model.id, msg });
+			return msg;
+		} catch (err) {
+			logger.debug("commit-msg-generator: error", {
+				model: candidate.model.id,
+				error: err instanceof Error ? err.message : String(err),
+			});
+		}
+	}
+
+	return null;
+}

package/src/utils/edit-mode.ts

@@ -0,0 +1,50 @@
+import { $env, $flag } from "@f5xc-salesdemos/pi-utils";
+
+export type EditMode = "replace" | "patch" | "hashline" | "chunk" | "vim";
+
+export const DEFAULT_EDIT_MODE: EditMode = "hashline";
+
+const EDIT_MODE_IDS = {
+	chunk: "chunk",
+	hashline: "hashline",
+	patch: "patch",
+	replace: "replace",
+	vim: "vim",
+} as const satisfies Record<string, EditMode>;
+
+export const EDIT_MODES = Object.keys(EDIT_MODE_IDS) as EditMode[];
+
+export function normalizeEditMode(mode?: string | null): EditMode | undefined {
+	if (!mode) return undefined;
+	return EDIT_MODE_IDS[mode as keyof typeof EDIT_MODE_IDS];
+}
+
+export interface EditModeSettingsLike {
+	get(key: "edit.mode"): unknown;
+	getEditVariantForModel?(model: string | undefined): EditMode | null;
+}
+
+export interface EditModeSessionLike {
+	settings: EditModeSettingsLike;
+	getActiveModelString?: () => string | undefined;
+}
+
+export function resolveEditMode(session: EditModeSessionLike): EditMode {
+	const activeModel = session.getActiveModelString?.();
+	const modelVariant = session.settings.getEditVariantForModel?.(activeModel);
+	if (modelVariant) return modelVariant;
+
+	const envMode = normalizeEditMode($env.PI_EDIT_VARIANT);
+	if (envMode) return envMode;
+
+	if (!$flag("PI_STRICT_EDIT_MODE")) {
+		if (activeModel?.includes("spark")) return "replace";
+		if (activeModel?.includes("nano")) return "replace";
+		if (activeModel?.includes("mini")) return "replace";
+		if (activeModel?.includes("haiku")) return "replace";
+		if (activeModel?.includes("flash")) return "replace";
+	}
+
+	const settingsMode = normalizeEditMode(String(session.settings.get("edit.mode") ?? ""));
+	return settingsMode ?? DEFAULT_EDIT_MODE;
+}

package/src/utils/event-bus.ts

@@ -0,0 +1,33 @@
+import { logger } from "@f5xc-salesdemos/pi-utils";
+
+export class EventBus {
+	readonly #listeners = new Map<string, Set<(data: unknown) => void>>();
+
+	emit(channel: string, data: unknown): void {
+		const handlers = this.#listeners.get(channel);
+		if (handlers) {
+			for (const handler of handlers) {
+				handler(data);
+			}
+		}
+	}
+
+	on(channel: string, handler: (data: unknown) => void): () => void {
+		if (!this.#listeners.has(channel)) {
+			this.#listeners.set(channel, new Set());
+		}
+		const safeHandler = async (data: unknown) => {
+			try {
+				await handler(data);
+			} catch (err) {
+				logger.error("Event handler error", { channel, error: String(err) });
+			}
+		};
+		this.#listeners.get(channel)!.add(safeHandler);
+		return () => this.#listeners.get(channel)?.delete(safeHandler);
+	}
+
+	clear(): void {
+		this.#listeners.clear();
+	}
+}

package/src/utils/external-editor.ts

@@ -0,0 +1,65 @@
+/**
+ * Utilities for launching an external text editor ($VISUAL / $EDITOR).
+ */
+import { spawn } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $env, Snowflake } from "@f5xc-salesdemos/pi-utils";
+
+/** Returns the user's preferred editor command, or undefined if not configured. */
+export function getEditorCommand(): string | undefined {
+	return $env.VISUAL || $env.EDITOR || undefined;
+}
+
+export interface OpenInEditorOptions {
+	/** File extension for the temp file (default: ".md"). */
+	extension?: string;
+	/** Custom stdio configuration (default: all "inherit"). */
+	stdio?: [number | "inherit", number | "inherit", number | "inherit"];
+	/** Keep the file's trailing newline instead of trimming it from the returned text. */
+	trimTrailingNewline?: boolean;
+}
+
+/**
+ * Opens `content` in the user's external editor and returns the edited text.
+ * Returns `null` if the editor exits with a non-zero code.
+ *
+ * The caller is responsible for stopping/starting the TUI around this call.
+ */
+export async function openInEditor(
+	editorCmd: string,
+	content: string,
+	options?: OpenInEditorOptions,
+): Promise<string | null> {
+	const ext = options?.extension ?? ".md";
+	const tmpFile = path.join(os.tmpdir(), `xcsh-editor-${Snowflake.next()}${ext}`);
+
+	try {
+		await Bun.write(tmpFile, content);
+
+		const [editor, ...editorArgs] = editorCmd.split(" ");
+		const stdio = options?.stdio ?? ["inherit", "inherit", "inherit"];
+
+		const child = spawn(editor, [...editorArgs, tmpFile], { stdio, shell: process.platform === "win32" });
+		const { promise, reject, resolve } = Promise.withResolvers<number>();
+		child.once("exit", (code, signal) => resolve(code ?? (signal ? -1 : 0)));
+		child.once("error", error => reject(error));
+		const exitCode = await promise;
+
+		if (exitCode === 0) {
+			const text = await Bun.file(tmpFile).text();
+			if (options?.trimTrailingNewline === false) {
+				return text;
+			}
+			return text.replace(/\n$/, "");
+		}
+		return null;
+	} finally {
+		try {
+			await fs.rm(tmpFile, { force: true });
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+}

package/src/utils/file-display-mode.ts

@@ -0,0 +1,37 @@
+/**
+ * Resolve line-display mode for file-like outputs (read, grep, @file mentions).
+ */
+
+import { resolveEditMode } from "./edit-mode";
+
+export interface FileDisplayMode {
+	lineNumbers: boolean;
+	hashLines: boolean;
+	chunked: boolean;
+}
+
+/** Session-like object providing settings and tool availability for display mode resolution. */
+export interface FileDisplayModeSession {
+	/** Whether the edit tool is available. Hashlines are suppressed without it. */
+	hasEditTool?: boolean;
+	settings: {
+		get(key: "readLineNumbers" | "readHashLines" | "edit.mode"): unknown;
+	};
+}
+
+/**
+ * Computes effective line display mode from session settings/env.
+ * Hashline mode takes precedence and implies line-addressed output everywhere.
+ * Hashlines are suppressed when the edit tool is not available (e.g. explore agents).
+ */
+export function resolveFileDisplayMode(session: FileDisplayModeSession): FileDisplayMode {
+	const { settings } = session;
+	const hasEditTool = session.hasEditTool ?? true;
+	const hashLines = hasEditTool && resolveEditMode(session) === "hashline" && settings.get("readHashLines") !== false;
+	const chunked = hasEditTool && resolveEditMode(session) === "chunk";
+	return {
+		hashLines,
+		lineNumbers: hashLines || settings.get("readLineNumbers") === true,
+		chunked,
+	};
+}