@f5-sales-demo/xcsh 19.51.2

package/src/utils/title-generator.ts

@@ -0,0 +1,193 @@
+/**
+ * Generate session titles using a smol, fast model.
+ */
+import * as path from "node:path";
+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 { resolveRoleSelection } from "../config/model-resolver";
+import type { Settings } from "../config/settings";
+import titleSystemPrompt from "../prompts/system/title-system.md" with { type: "text" };
+import { toReasoningEffort } from "../thinking";
+
+const TITLE_SYSTEM_PROMPT = prompt.render(titleSystemPrompt);
+
+const DEFAULT_TERMINAL_TITLE = "π";
+const TERMINAL_TITLE_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f]/g;
+
+const MAX_INPUT_CHARS = 2000;
+
+function getTitleModel(
+	registry: ModelRegistry,
+	settings: Settings,
+	currentModel?: Model<Api>,
+): { model: Model<Api>; thinkingLevel?: ThinkingLevel } | undefined {
+	const availableModels = registry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	const titleModel = resolveRoleSelection(["commit", "smol"], settings, availableModels, registry);
+	if (titleModel) {
+		return { model: titleModel.model, thinkingLevel: titleModel.thinkingLevel };
+	}
+
+	if (currentModel) {
+		return { model: currentModel };
+	}
+
+	return undefined;
+}
+
+/**
+ * Generate a title for a session based on the first user message.
+ *
+ * @param firstMessage The first user message
+ * @param registry Model registry
+ * @param settings Settings used to resolve the smol role, including per-role thinking
+ * @param sessionId Optional session id for sticky API key selection
+ */
+export async function generateSessionTitle(
+	firstMessage: string,
+	registry: ModelRegistry,
+	settings: Settings,
+	sessionId?: string,
+	currentModel?: Model<Api>,
+): Promise<string | null> {
+	const candidate = getTitleModel(registry, settings, currentModel);
+	if (!candidate) {
+		logger.debug("title-generator: no title model found");
+		return null;
+	}
+
+	// Truncate message if too long
+	const truncatedMessage =
+		firstMessage.length > MAX_INPUT_CHARS ? `${firstMessage.slice(0, MAX_INPUT_CHARS)}…` : firstMessage;
+	const userMessage = `<user-message>
+${truncatedMessage}
+</user-message>`;
+
+	const apiKey = await registry.getApiKey(candidate.model, sessionId);
+	if (!apiKey) {
+		logger.debug("title-generator: no API key for smol model", {
+			provider: candidate.model.provider,
+			id: candidate.model.id,
+		});
+		return null;
+	}
+
+	const request = {
+		model: `${candidate.model.provider}/${candidate.model.id}`,
+		systemPrompt: TITLE_SYSTEM_PROMPT,
+		userMessage,
+		maxTokens: 30,
+	};
+	logger.debug("title-generator: request", request);
+
+	try {
+		const response = await completeSimple(
+			candidate.model,
+			{
+				systemPrompt: request.systemPrompt,
+				messages: [{ role: "user", content: request.userMessage, timestamp: Date.now() }],
+			},
+			{
+				apiKey,
+				maxTokens: 30,
+				reasoning: toReasoningEffort(candidate.thinkingLevel),
+			},
+		);
+
+		if (response.stopReason === "error") {
+			logger.debug("title-generator: response error", {
+				model: request.model,
+				stopReason: response.stopReason,
+				errorMessage: response.errorMessage,
+			});
+			return null;
+		}
+
+		let title = "";
+		for (const content of response.content) {
+			if (content.type === "text") {
+				title += content.text;
+			}
+		}
+		title = title.trim();
+
+		logger.debug("title-generator: response", {
+			model: request.model,
+			title,
+			usage: response.usage,
+			stopReason: response.stopReason,
+		});
+
+		if (!title) {
+			return null;
+		}
+
+		return title.replace(/^["']|["']$/g, "").replace(/[.!?]$/, "");
+	} catch (err) {
+		logger.debug("title-generator: error", {
+			model: request.model,
+			error: err instanceof Error ? err.message : String(err),
+		});
+		return null;
+	}
+}
+
+/**
+ * Remove control characters so model-generated titles cannot inject terminal escapes.
+ */
+function sanitizeTerminalTitlePart(value: string | undefined): string | undefined {
+	if (!value) return undefined;
+	const sanitized = value.replace(TERMINAL_TITLE_CONTROL_CHARS, "").trim();
+	return sanitized || undefined;
+}
+
+function getFallbackTerminalTitle(cwd: string | undefined): string | undefined {
+	if (!cwd) return undefined;
+	const resolvedCwd = path.resolve(cwd);
+	const baseName = path.basename(resolvedCwd);
+	if (!baseName || baseName === path.parse(resolvedCwd).root) return undefined;
+	return sanitizeTerminalTitlePart(baseName);
+}
+
+export function formatSessionTerminalTitle(
+	sessionName: string | undefined,
+	cwd?: string,
+	titleSource?: "auto" | "user" | undefined,
+): string {
+	const label =
+		sanitizeTerminalTitlePart(titleSource === "auto" ? undefined : sessionName) ?? getFallbackTerminalTitle(cwd);
+	return label ? `${DEFAULT_TERMINAL_TITLE}: ${label}` : DEFAULT_TERMINAL_TITLE;
+}
+
+/**
+ * Set the terminal title using OSC 0 (sets both tab and window title). Unsupported terminals ignore it.
+ */
+export function setTerminalTitle(title: string): void {
+	process.stdout.write(`\x1b]0;${sanitizeTerminalTitlePart(title) ?? DEFAULT_TERMINAL_TITLE}\x07`);
+}
+
+export function setSessionTerminalTitle(
+	sessionName: string | undefined,
+	cwd?: string,
+	titleSource?: "auto" | "user" | undefined,
+): void {
+	setTerminalTitle(formatSessionTerminalTitle(sessionName, cwd, titleSource));
+}
+
+/**
+ * Save the current terminal title on terminals that support xterm window ops.
+ */
+export function pushTerminalTitle(): void {
+	process.stdout.write("\x1b[22;2t");
+}
+
+/**
+ * Restore the previously saved terminal title on terminals that support xterm window ops.
+ */
+export function popTerminalTitle(): void {
+	process.stdout.write("\x1b[23;2t");
+}

package/src/utils/tool-choice.ts

@@ -0,0 +1,28 @@
+import type { Api, Model, ToolChoice } from "@f5xc-salesdemos/pi-ai";
+
+/**
+ * Build a provider-aware tool choice that targets one specific tool when supported.
+ * Some providers only support "any tool" forcing, not a named tool.
+ */
+export function buildNamedToolChoice(toolName: string, model?: Model<Api>): ToolChoice | undefined {
+	if (!model) return undefined;
+
+	if (model.api === "anthropic-messages" || model.api === "bedrock-converse-stream") {
+		return { type: "tool", name: toolName };
+	}
+
+	if (
+		model.api === "openai-codex-responses" ||
+		model.api === "openai-responses" ||
+		model.api === "openai-completions" ||
+		model.api === "azure-openai-responses"
+	) {
+		return { type: "function", name: toolName };
+	}
+
+	if (model.api === "google-generative-ai" || model.api === "google-gemini-cli" || model.api === "google-vertex") {
+		return "required";
+	}
+
+	return "required";
+}

package/src/utils/tools-manager.ts

@@ -0,0 +1,356 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { $which, APP_NAME, getToolsDir, logger, ptree, TempDir } from "@f5xc-salesdemos/pi-utils";
+
+const TOOLS_DIR = getToolsDir();
+const TOOL_DOWNLOAD_TIMEOUT_MS = 120_000;
+const TOOL_METADATA_TIMEOUT_MS = 5000;
+
+interface ToolConfig {
+	name: string;
+	repo: string; // GitHub repo (e.g., "sharkdp/fd")
+	binaryName: string; // Name of the binary inside the archive
+	tagPrefix: string; // Prefix for tags (e.g., "v" for v1.0.0, "" for 1.0.0)
+	isDirectBinary?: boolean; // If true, asset is a direct binary (not an archive)
+	getAssetName: (version: string, plat: string, architecture: string) => string | null;
+}
+
+const TOOLS: Record<string, ToolConfig> = {
+	sd: {
+		name: "sd",
+		repo: "chmln/sd",
+		binaryName: "sd",
+		tagPrefix: "v",
+		getAssetName: (version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `sd-v${version}-${archStr}-apple-darwin.tar.gz`;
+			} else if (plat === "linux") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `sd-v${version}-${archStr}-unknown-linux-musl.tar.gz`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `sd-v${version}-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+	sg: {
+		name: "ast-grep",
+		repo: "ast-grep/ast-grep",
+		binaryName: "sg",
+		tagPrefix: "",
+		getAssetName: (_version, plat, architecture) => {
+			if (plat === "darwin") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ast-grep-${archStr}-apple-darwin.zip`;
+			} else if (plat === "linux") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ast-grep-${archStr}-unknown-linux-gnu.zip`;
+			} else if (plat === "win32") {
+				const archStr = architecture === "arm64" ? "aarch64" : "x86_64";
+				return `ast-grep-${archStr}-pc-windows-msvc.zip`;
+			}
+			return null;
+		},
+	},
+	"yt-dlp": {
+		name: "yt-dlp",
+		repo: "yt-dlp/yt-dlp",
+		binaryName: "yt-dlp",
+		tagPrefix: "",
+		isDirectBinary: true,
+		getAssetName: (_version, plat, architecture) => {
+			if (plat === "darwin") {
+				return "yt-dlp_macos"; // Universal binary
+			} else if (plat === "linux") {
+				return architecture === "arm64" ? "yt-dlp_linux_aarch64" : "yt-dlp_linux";
+			} else if (plat === "win32") {
+				return architecture === "arm64" ? "yt-dlp_arm64.exe" : "yt-dlp.exe";
+			}
+			return null;
+		},
+	},
+};
+
+// Python packages installed via uv/pip
+interface PythonToolConfig {
+	name: string;
+	package: string; // PyPI package name
+	binaryName: string; // CLI command name after install
+}
+
+const PYTHON_TOOLS: Record<string, PythonToolConfig> = {
+	trafilatura: {
+		name: "trafilatura",
+		package: "trafilatura",
+		binaryName: "trafilatura",
+	},
+};
+
+export type ToolName = "sd" | "sg" | "yt-dlp" | "trafilatura";
+
+// Get the path to a tool (system-wide or in our tools dir)
+export function getToolPath(tool: ToolName): string | null {
+	// Check Python tools first
+	const pythonConfig = PYTHON_TOOLS[tool];
+	if (pythonConfig) {
+		return $which(pythonConfig.binaryName);
+	}
+
+	const config = TOOLS[tool];
+	if (!config) return null;
+
+	// Check our tools directory first
+	const localPath = path.join(TOOLS_DIR, config.binaryName + (os.platform() === "win32" ? ".exe" : ""));
+	if (fs.existsSync(localPath)) {
+		return localPath;
+	}
+
+	// Check system PATH
+	return $which(config.binaryName);
+}
+
+// Fetch latest release version from GitHub
+async function getLatestVersion(repo: string, signal?: AbortSignal): Promise<string> {
+	let response: Response;
+	try {
+		response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+			headers: { "User-Agent": `${APP_NAME}-coding-agent` },
+			signal: ptree.combineSignals(signal, TOOL_METADATA_TIMEOUT_MS),
+		});
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") {
+			throw new Error("GitHub API request timed out");
+		}
+		throw err;
+	}
+
+	if (!response.ok) {
+		throw new Error(`GitHub API error: ${response.status}`);
+	}
+
+	const data = (await response.json()) as { tag_name: string };
+	return data.tag_name.replace(/^v/, "");
+}
+
+// Download a file from URL
+async function downloadFile(url: string, dest: string, signal?: AbortSignal): Promise<void> {
+	let response: Response;
+	try {
+		response = await fetch(url, {
+			signal: ptree.combineSignals(signal, TOOL_DOWNLOAD_TIMEOUT_MS),
+		});
+	} catch (err) {
+		if (err instanceof Error && err.name === "AbortError") {
+			throw new Error(`Download timed out: ${url}`);
+		}
+		throw err;
+	}
+	if (!response.ok) {
+		throw new Error(`Failed to download: ${response.status}`);
+	} else if (!response.body) {
+		throw new Error("No response body");
+	}
+	await Bun.write(dest, response);
+}
+
+// Download and install a tool
+async function downloadTool(tool: ToolName, signal?: AbortSignal): Promise<string> {
+	const config = TOOLS[tool];
+	if (!config) throw new Error(`Unknown tool: ${tool}`);
+
+	const plat = os.platform();
+	const architecture = os.arch();
+
+	// Get latest version
+	const version = await getLatestVersion(config.repo, signal);
+
+	// Get asset name for this platform
+	const assetName = config.getAssetName(version, plat, architecture);
+	if (!assetName) {
+		throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+	}
+
+	// Create tools directory
+	await fs.promises.mkdir(TOOLS_DIR, { recursive: true });
+
+	const downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`;
+	const binaryExt = plat === "win32" ? ".exe" : "";
+	const binaryPath = path.join(TOOLS_DIR, config.binaryName + binaryExt);
+
+	// Handle direct binary downloads (no archive extraction needed)
+	if (config.isDirectBinary) {
+		await downloadFile(downloadUrl, binaryPath, signal);
+		if (plat !== "win32") {
+			await fs.promises.chmod(binaryPath, 0o755);
+		}
+		return binaryPath;
+	}
+
+	// Download archive
+	const archivePath = path.join(TOOLS_DIR, assetName);
+	await downloadFile(downloadUrl, archivePath, signal);
+
+	// Extract
+	const tmp = await TempDir.create("@xcsh-tools-extract-");
+
+	try {
+		if (!assetName.endsWith(".tar.gz") && !assetName.endsWith(".zip")) {
+			throw new Error(`Unsupported archive format: ${assetName}`);
+		}
+
+		try {
+			const archive = new Bun.Archive(await Bun.file(archivePath).arrayBuffer());
+			const files = await archive.files();
+			const extractRoot = path.resolve(tmp.path());
+
+			for (const [filePath, file] of files) {
+				const outputPath = path.resolve(extractRoot, filePath);
+				if (!outputPath.startsWith(extractRoot + path.sep)) {
+					throw new Error(`Archive entry escapes extraction dir: ${filePath}`);
+				}
+				await Bun.write(outputPath, file);
+			}
+		} catch (err) {
+			throw new Error(`Failed to extract ${assetName}: ${err instanceof Error ? err.message : String(err)}`);
+		}
+
+		// Find the binary in extracted files
+		// ast-grep releases the binary directly in the zip, not in a subdirectory
+		let extractedBinary: string;
+		if (tool === "sg") {
+			extractedBinary = path.join(tmp.path(), config.binaryName + binaryExt);
+		} else {
+			const extractedDir = path.join(tmp.path(), assetName.replace(/\.(tar\.gz|zip)$/, ""));
+			extractedBinary = path.join(extractedDir, config.binaryName + binaryExt);
+		}
+
+		if (fs.existsSync(extractedBinary)) {
+			await fs.promises.rename(extractedBinary, binaryPath);
+		} else {
+			throw new Error(`Binary not found in archive: ${extractedBinary}`);
+		}
+
+		// Make executable (Unix only)
+		if (plat !== "win32") {
+			await fs.promises.chmod(binaryPath, 0o755);
+		}
+	} finally {
+		// Cleanup
+		await tmp.remove();
+		await fs.promises.rm(archivePath, { force: true });
+	}
+
+	return binaryPath;
+}
+
+// Install a Python package via uv (preferred) or pip
+async function installPythonPackage(pkg: string, signal?: AbortSignal): Promise<boolean> {
+	// Try uv first (faster, better isolation)
+	const uv = $which("uv");
+	if (uv) {
+		const result = await ptree.exec(["uv", "tool", "install", pkg], {
+			signal,
+			allowNonZero: true,
+			allowAbort: true,
+			stderr: "full",
+		});
+		if (result.exitCode === 0) return true;
+	}
+
+	// Fall back to pip
+	const pip = $which("pip3") || $which("pip");
+	if (pip) {
+		const result = await ptree.exec(["pip", "install", "--user", pkg], {
+			signal,
+			allowNonZero: true,
+			allowAbort: true,
+			stderr: "full",
+		});
+		return result.exitCode === 0;
+	}
+
+	return false;
+}
+
+// Termux package names for tools
+const TERMUX_PACKAGES: Partial<Record<ToolName, string>> = {
+	sd: "sd",
+	sg: "ast-grep",
+};
+
+// Ensure a tool is available, downloading if necessary
+// Returns the path to the tool, or null if unavailable
+type EnsureToolOptions = {
+	signal?: AbortSignal;
+	silent?: boolean;
+	notify?: (message: string) => void;
+};
+
+export async function ensureTool(tool: ToolName, silentOrOptions?: EnsureToolOptions): Promise<string | undefined> {
+	const { signal, silent = false, notify } = silentOrOptions ?? {};
+	const existingPath = getToolPath(tool);
+	if (existingPath) {
+		return existingPath;
+	}
+
+	// On Android/Termux, Linux binaries don't work due to Bionic libc incompatibility.
+	// Users must install via pkg.
+	if (os.platform() === "android") {
+		const pkgName = TERMUX_PACKAGES[tool] ?? tool;
+		if (!silent) {
+			logger.warn(`${TOOLS[tool]?.name ?? tool} not found. Install with: pkg install ${pkgName}`);
+		}
+		return undefined;
+	}
+
+	// Handle Python tools
+	const pythonConfig = PYTHON_TOOLS[tool];
+	if (pythonConfig) {
+		if (!silent) {
+			logger.debug(`${pythonConfig.name} not found. Installing via uv/pip...`);
+		}
+		notify?.(`Installing ${pythonConfig.name}…`);
+		const success = await installPythonPackage(pythonConfig.package, signal);
+		if (success) {
+			// Re-check for the command after installation
+			const path = $which(pythonConfig.binaryName);
+			if (path) {
+				if (!silent) {
+					logger.debug(`${pythonConfig.name} installed successfully`);
+				}
+				return path;
+			}
+		}
+		if (!silent) {
+			logger.warn(`Failed to install ${pythonConfig.name}`);
+		}
+		return undefined;
+	}
+
+	const config = TOOLS[tool];
+	if (!config) return undefined;
+
+	// Tool not found - download it
+	if (!silent) {
+		logger.debug(`${config.name} not found. Downloading...`);
+	}
+	notify?.(`Downloading ${config.name}…`);
+
+	try {
+		const path = await downloadTool(tool, signal);
+		if (!silent) {
+			logger.debug(`${config.name} installed to ${path}`);
+		}
+		return path;
+	} catch (e) {
+		if (!silent) {
+			logger.warn(`Failed to download ${config.name}`, {
+				error: e instanceof Error ? e.message : String(e),
+			});
+		}
+		return undefined;
+	}
+}