@f5-sales-demo/xcsh 19.51.2

package/src/cli/config-cli.ts

@@ -0,0 +1,418 @@
+/**
+ * Config CLI command handlers.
+ *
+ * Handles `xcsh config <command>` subcommands for managing settings.
+ * Uses the settings schema as the source of truth for available settings.
+ */
+
+import { APP_NAME, getAgentDir } from "@f5xc-salesdemos/pi-utils";
+import chalk from "chalk";
+import {
+	getDefault,
+	getEnumValues,
+	getType,
+	getUi,
+	type SettingPath,
+	Settings,
+	type SettingValue,
+	settings,
+} from "../config/settings";
+import { SETTINGS_SCHEMA } from "../config/settings-schema";
+import { theme } from "../modes/theme/theme";
+import { initXdg } from "./commands/init-xdg";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export type ConfigAction = "list" | "get" | "set" | "reset" | "path" | "init-xdg";
+
+export interface ConfigCommandArgs {
+	action: ConfigAction;
+	key?: string;
+	value?: string;
+	flags: {
+		json?: boolean;
+	};
+}
+// =============================================================================
+// Setting Filtering
+// =============================================================================
+
+type CliSettingDef = {
+	path: SettingPath;
+	type: string;
+	description: string;
+	tab: string;
+};
+
+const ALL_SETTING_PATHS = Object.keys(SETTINGS_SCHEMA) as SettingPath[];
+
+/** Find setting definition by path */
+function findSettingDef(path: string): CliSettingDef | undefined {
+	if (!(path in SETTINGS_SCHEMA)) return undefined;
+	const key = path as SettingPath;
+	const ui = getUi(key);
+	return {
+		path: key,
+		type: getType(key),
+		description: ui?.description ?? "",
+		tab: ui?.tab ?? "internal",
+	};
+}
+
+/** Get available values for a setting */
+function getSettingValues(def: CliSettingDef): readonly string[] | undefined {
+	if (def.type === "enum") {
+		return getEnumValues(def.path);
+	}
+	return undefined;
+}
+
+// =============================================================================
+// Argument Parser
+// =============================================================================
+
+const VALID_ACTIONS: ConfigAction[] = ["list", "get", "set", "reset", "path", "init-xdg"];
+
+/**
+ * Parse config subcommand arguments.
+ * Returns undefined if not a config command.
+ */
+export function parseConfigArgs(args: string[]): ConfigCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "config") {
+		return undefined;
+	}
+
+	if (args.length < 2 || args[1] === "--help" || args[1] === "-h") {
+		return { action: "list", flags: {} };
+	}
+
+	const action = args[1];
+	if (!VALID_ACTIONS.includes(action as ConfigAction)) {
+		console.error(chalk.red(`Unknown config command: ${action}`));
+		console.error(`Valid commands: ${VALID_ACTIONS.join(", ")}`);
+		process.exit(1);
+	}
+
+	const result: ConfigCommandArgs = {
+		action: action as ConfigAction,
+		flags: {},
+	};
+
+	const positionalArgs: string[] = [];
+	for (let i = 2; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--json") {
+			result.flags.json = true;
+		} else if (!arg.startsWith("-")) {
+			positionalArgs.push(arg);
+		}
+	}
+
+	if (positionalArgs.length > 0) {
+		result.key = positionalArgs[0];
+	}
+	if (positionalArgs.length > 1) {
+		result.value = positionalArgs.slice(1).join(" ");
+	}
+
+	return result;
+}
+
+// =============================================================================
+// Value Formatting
+// =============================================================================
+
+function formatValue(value: unknown): string {
+	if (value === undefined || value === null) {
+		return chalk.dim("(not set)");
+	}
+	if (typeof value === "boolean") {
+		return value ? chalk.green("true") : chalk.red("false");
+	}
+	if (typeof value === "number") {
+		return chalk.cyan(String(value));
+	}
+	if (typeof value === "string") {
+		return chalk.yellow(value);
+	}
+	if (Array.isArray(value) || typeof value === "object") {
+		try {
+			return chalk.yellow(JSON.stringify(value));
+		} catch {
+			return chalk.yellow(String(value));
+		}
+	}
+	return chalk.yellow(String(value));
+}
+
+function getTypeDisplay(def: CliSettingDef): string {
+	const values = getSettingValues(def);
+	if (values && values.length > 0) {
+		return `(${values.join("|")})`;
+	}
+	switch (def.type) {
+		case "boolean":
+			return "(boolean)";
+		case "number":
+			return "(number)";
+		case "array":
+			return "(array)";
+		case "record":
+			return "(record)";
+		default:
+			return "(string)";
+	}
+}
+
+// =============================================================================
+// Schema-Driven Value Parsing
+// =============================================================================
+
+function parseAndSetValue(path: SettingPath, rawValue: string): void {
+	const schemaType = getType(path);
+	let parsedValue: unknown;
+
+	const trimmed = rawValue.trim();
+	switch (schemaType) {
+		case "boolean": {
+			const lower = trimmed.toLowerCase();
+			if (["true", "1", "yes", "on"].includes(lower)) parsedValue = true;
+			else if (["false", "0", "no", "off"].includes(lower)) parsedValue = false;
+			else throw new Error(`Invalid boolean value: ${rawValue}. Use true/false, yes/no, on/off, or 1/0`);
+			break;
+		}
+		case "number":
+			parsedValue = Number(trimmed);
+			if (!Number.isFinite(parsedValue)) throw new Error(`Invalid number: ${rawValue}`);
+			break;
+		case "enum": {
+			const valid = getEnumValues(path);
+			if (valid && !valid.includes(trimmed)) {
+				throw new Error(`Invalid value: ${rawValue}. Valid values: ${valid.join(", ")}`);
+			}
+			parsedValue = trimmed;
+			break;
+		}
+		case "array": {
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(trimmed);
+			} catch {
+				throw new Error(`Invalid array JSON: ${rawValue}`);
+			}
+			if (!Array.isArray(parsed)) {
+				throw new Error(`Invalid array JSON: ${rawValue}`);
+			}
+			parsedValue = parsed;
+			break;
+		}
+		case "record": {
+			let parsed: unknown;
+			try {
+				parsed = JSON.parse(trimmed);
+			} catch {
+				throw new Error(`Invalid record JSON: ${rawValue}`);
+			}
+			if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+				throw new Error(`Invalid record JSON: ${rawValue}`);
+			}
+			parsedValue = parsed;
+			break;
+		}
+		default:
+			parsedValue = trimmed;
+	}
+
+	settings.set(path, parsedValue as SettingValue<typeof path>);
+}
+
+// =============================================================================
+// Command Handlers
+// =============================================================================
+
+export async function runConfigCommand(cmd: ConfigCommandArgs): Promise<void> {
+	await Settings.init();
+
+	switch (cmd.action) {
+		case "list":
+			handleList(cmd.flags);
+			break;
+		case "get":
+			handleGet(cmd.key, cmd.flags);
+			break;
+		case "set":
+			await handleSet(cmd.key, cmd.value, cmd.flags);
+			break;
+		case "reset":
+			await handleReset(cmd.key, cmd.flags);
+			break;
+		case "path":
+			handlePath();
+			break;
+		case "init-xdg":
+			await initXdg();
+			break;
+	}
+}
+
+function handleList(flags: { json?: boolean }): void {
+	const defs = ALL_SETTING_PATHS.map(path => findSettingDef(path)).filter((def): def is CliSettingDef => !!def);
+
+	if (flags.json) {
+		const result: Record<string, { value: unknown; type: string; description: string }> = {};
+		for (const def of defs) {
+			result[def.path] = {
+				value: settings.get(def.path),
+				type: def.type,
+				description: def.description,
+			};
+		}
+		console.log(JSON.stringify(result, null, 2));
+		return;
+	}
+
+	console.log(chalk.bold("Settings:\n"));
+
+	const groups: Record<string, CliSettingDef[]> = {};
+	for (const def of defs) {
+		if (!groups[def.tab]) {
+			groups[def.tab] = [];
+		}
+		groups[def.tab].push(def);
+	}
+
+	const sortedGroups = Object.keys(groups).sort((a, b) => {
+		if (a === "config") return -1;
+		if (b === "config") return 1;
+		return a.localeCompare(b);
+	});
+
+	for (const group of sortedGroups) {
+		console.log(chalk.bold.blue(`[${group}]`));
+		for (const def of groups[group]) {
+			const value = settings.get(def.path);
+			const valueStr = formatValue(value);
+			const typeStr = getTypeDisplay(def);
+			console.log(`  ${chalk.white(def.path)} = ${valueStr} ${chalk.dim(typeStr)}`);
+		}
+		console.log("");
+	}
+}
+
+function handleGet(key: string | undefined, flags: { json?: boolean }): void {
+	if (!key) {
+		console.error(chalk.red(`Usage: ${APP_NAME} config get <key>`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const def = findSettingDef(key);
+	if (!def) {
+		console.error(chalk.red(`Unknown setting: ${key}`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const value = settings.get(def.path);
+
+	if (flags.json) {
+		console.log(JSON.stringify({ key: def.path, value, type: def.type, description: def.description }, null, 2));
+		return;
+	}
+
+	console.log(formatValue(value));
+}
+
+async function handleSet(key: string | undefined, value: string | undefined, flags: { json?: boolean }): Promise<void> {
+	if (!key || value === undefined) {
+		console.error(chalk.red(`Usage: ${APP_NAME} config set <key> <value>`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const def = findSettingDef(key);
+	if (!def) {
+		console.error(chalk.red(`Unknown setting: ${key}`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	try {
+		parseAndSetValue(def.path, value);
+	} catch (err) {
+		console.error(chalk.red(String(err)));
+		process.exit(1);
+	}
+
+	const newValue = settings.get(def.path);
+
+	if (flags.json) {
+		console.log(JSON.stringify({ key: def.path, value: newValue }));
+	} else {
+		console.log(chalk.green(`${theme.status.success} Set ${def.path} = ${formatValue(newValue)}`));
+	}
+}
+
+async function handleReset(key: string | undefined, flags: { json?: boolean }): Promise<void> {
+	if (!key) {
+		console.error(chalk.red(`Usage: ${APP_NAME} config reset <key>`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const def = findSettingDef(key);
+	if (!def) {
+		console.error(chalk.red(`Unknown setting: ${key}`));
+		console.error(chalk.dim(`\nRun '${APP_NAME} config list' to see available keys`));
+		process.exit(1);
+	}
+
+	const path = def.path as SettingPath;
+	const defaultValue = getDefault(path);
+	settings.set(path, defaultValue as SettingValue<typeof path>);
+
+	if (flags.json) {
+		console.log(JSON.stringify({ key: def.path, value: defaultValue }));
+	} else {
+		console.log(chalk.green(`${theme.status.success} Reset ${def.path} to ${formatValue(defaultValue)}`));
+	}
+}
+
+function handlePath(): void {
+	console.log(getAgentDir());
+}
+
+// =============================================================================
+// Help
+// =============================================================================
+
+export function printConfigHelp(): void {
+	console.log(`${chalk.bold(`${APP_NAME} config`)} - Manage settings
+
+${chalk.bold("Commands:")}
+  list               List all settings with current values
+  get <key>          Get a specific setting value
+  set <key> <value>  Set a setting value
+  reset <key>        Reset a setting to its default value
+  path               Print the config directory path
+  init-xdg           Initialize XDG Base Directory structure
+
+${chalk.bold("Options:")}
+  --json             Output as JSON
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} config list
+  ${APP_NAME} config get theme
+  ${APP_NAME} config set theme catppuccin-mocha
+  ${APP_NAME} config set compaction.enabled false
+  ${APP_NAME} config set defaultThinkingLevel medium
+  ${APP_NAME} config reset steeringMode
+  ${APP_NAME} config list --json
+  ${APP_NAME} config init-xdg
+
+${chalk.bold("Boolean Values:")}
+  true, false, yes, no, on, off, 1, 0
+`);
+}

package/src/cli/file-processor.ts

@@ -0,0 +1,121 @@
+/**
+ * Process @file CLI arguments into text content and image attachments
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { ImageContent } from "@f5xc-salesdemos/pi-ai";
+import { getProjectDir, isEnoent, readImageMetadata, t } from "@f5xc-salesdemos/pi-utils";
+import chalk from "chalk";
+import { resolveReadPath } from "../tools/path-utils";
+import { formatBytes } from "../tools/render-utils";
+import { formatDimensionNote, resizeImage } from "../utils/image-resize";
+
+// Keep CLI startup responsive and avoid OOM when users pass huge files.
+// If a file exceeds these limits, we include it as a path-only <file/> block.
+const MAX_CLI_TEXT_BYTES = 5 * 1024 * 1024; // 5MB
+const MAX_CLI_IMAGE_BYTES = 25 * 1024 * 1024; // 25MB
+
+export interface ProcessedFiles {
+	text: string;
+	images: ImageContent[];
+}
+
+export interface ProcessFileOptions {
+	/** Whether to auto-resize images to 2000x2000 max. Default: true */
+	autoResizeImages?: boolean;
+}
+
+/** Process @file arguments into text content and image attachments */
+export async function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles> {
+	const autoResizeImages = options?.autoResizeImages ?? true;
+	let text = "";
+	const images: ImageContent[] = [];
+
+	for (const fileArg of fileArgs) {
+		// Expand and resolve path (handles ~ expansion and macOS screenshot Unicode spaces)
+		const absolutePath = path.resolve(resolveReadPath(fileArg, getProjectDir()));
+
+		const stat = fs.statSync(absolutePath, { throwIfNoEntry: false });
+		if (!stat) {
+			console.error(chalk.red(t("file.errors.notFound", { path: absolutePath })));
+			process.exit(1);
+		}
+
+		const imageMetadata = await readImageMetadata(absolutePath);
+		const mimeType = imageMetadata?.mimeType;
+		const maxBytes = mimeType ? MAX_CLI_IMAGE_BYTES : MAX_CLI_TEXT_BYTES;
+		if (stat.size > maxBytes) {
+			console.error(chalk.yellow(t("file.warnings.tooLarge", { size: formatBytes(stat.size), path: absolutePath })));
+			text += `<file name="${absolutePath}">(skipped: too large, ${formatBytes(stat.size)})</file>\n`;
+			continue;
+		}
+
+		// Read file, handling not-found gracefully
+		let buffer: Uint8Array;
+		try {
+			buffer = await Bun.file(absolutePath).bytes();
+		} catch (err) {
+			if (isEnoent(err)) {
+				console.error(chalk.red(t("file.errors.notFound", { path: absolutePath })));
+				process.exit(1);
+			}
+			throw err;
+		}
+		if (buffer.length === 0) {
+			continue;
+		}
+
+		if (mimeType) {
+			// Handle image file
+			const base64Content = buffer.toBase64();
+			let attachment: ImageContent;
+			let dimensionNote: string | undefined;
+
+			if (autoResizeImages) {
+				try {
+					const resized = await resizeImage({ type: "image", data: base64Content, mimeType });
+					dimensionNote = formatDimensionNote(resized);
+					attachment = {
+						type: "image",
+						mimeType: resized.mimeType,
+						data: resized.data,
+					};
+				} catch {
+					// Fall back to original image on resize failure
+					attachment = {
+						type: "image",
+						mimeType,
+						data: base64Content,
+					};
+				}
+			} else {
+				attachment = {
+					type: "image",
+					mimeType,
+					data: base64Content,
+				};
+			}
+
+			images.push(attachment);
+
+			// Add text reference to image with optional dimension note
+			if (dimensionNote) {
+				text += `<file name="${absolutePath}">${dimensionNote}</file>\n`;
+			} else {
+				text += `<file name="${absolutePath}"></file>\n`;
+			}
+		} else {
+			// Handle text file
+			try {
+				const content = new TextDecoder().decode(buffer);
+				text += `<file name="${absolutePath}">\n${content}\n</file>\n`;
+			} catch (error: unknown) {
+				const message = error instanceof Error ? error.message : String(error);
+				console.error(chalk.red(t("file.errors.readFailed", { path: absolutePath, message })));
+				process.exit(1);
+			}
+		}
+	}
+
+	return { text, images };
+}

package/src/cli/grep-cli.ts

@@ -0,0 +1,160 @@
+/**
+ * Grep CLI command handlers.
+ *
+ * Handles `xcsh grep` subcommand for testing grep tool on Windows.
+ */
+import * as path from "node:path";
+import { GrepOutputMode, grep } from "@f5xc-salesdemos/pi-natives";
+import { APP_NAME, t } from "@f5xc-salesdemos/pi-utils";
+import chalk from "chalk";
+
+export interface GrepCommandArgs {
+	pattern: string;
+	path: string;
+	glob?: string;
+	limit: number;
+	context: number;
+	mode: GrepOutputMode;
+	gitignore: boolean;
+}
+
+/**
+ * Parse grep subcommand arguments.
+ * Returns undefined if not a grep command.
+ */
+export function parseGrepArgs(args: string[]): GrepCommandArgs | undefined {
+	if (args.length === 0 || args[0] !== "grep") {
+		return undefined;
+	}
+
+	const result: GrepCommandArgs = {
+		pattern: "",
+		path: ".",
+		limit: 20,
+		context: 2,
+		mode: GrepOutputMode.Content,
+		gitignore: true,
+	};
+
+	const positional: string[] = [];
+
+	for (let i = 1; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--glob" || arg === "-g") {
+			result.glob = args[++i];
+		} else if (arg === "--limit" || arg === "-l") {
+			result.limit = parseInt(args[++i], 10);
+		} else if (arg === "--context" || arg === "-C") {
+			result.context = parseInt(args[++i], 10);
+		} else if (arg === "--files" || arg === "-f") {
+			result.mode = GrepOutputMode.FilesWithMatches;
+		} else if (arg === "--count" || arg === "-c") {
+			result.mode = GrepOutputMode.Count;
+		} else if (arg === "--no-gitignore") {
+			result.gitignore = false;
+		} else if (!arg.startsWith("-")) {
+			positional.push(arg);
+		}
+	}
+
+	if (positional.length >= 1) {
+		result.pattern = positional[0];
+	}
+	if (positional.length >= 2) {
+		result.path = positional[1];
+	}
+
+	return result;
+}
+
+export async function runGrepCommand(cmd: GrepCommandArgs): Promise<void> {
+	if (!cmd.pattern) {
+		console.error(chalk.red(t("grep.errors.patternRequired")));
+		process.exit(1);
+	}
+
+	const searchPath = path.resolve(cmd.path);
+	console.log(chalk.dim(`Searching in: ${searchPath}`));
+	console.log(chalk.dim(`Pattern: ${cmd.pattern}`));
+	console.log(
+		chalk.dim(`Mode: ${cmd.mode}, Limit: ${cmd.limit}, Context: ${cmd.context}, Gitignore: ${cmd.gitignore}`),
+	);
+
+	console.log("");
+
+	try {
+		const result = await grep({
+			pattern: cmd.pattern,
+			path: searchPath,
+			glob: cmd.glob,
+			mode: cmd.mode,
+			maxCount: cmd.limit,
+			context: cmd.mode === GrepOutputMode.Content ? cmd.context : undefined,
+			hidden: true,
+			gitignore: cmd.gitignore,
+		});
+
+		console.log(chalk.green(t("grep.results.totalMatches", { count: result.totalMatches })));
+		console.log(chalk.green(t("grep.results.filesWithMatches", { count: result.filesWithMatches })));
+		console.log(chalk.green(t("grep.results.filesSearched", { count: result.filesSearched })));
+		if (result.limitReached) {
+			console.log(chalk.yellow(`Limit reached: true`));
+		}
+		console.log("");
+
+		for (const match of result.matches) {
+			const displayPath = match.path.replace(/\\/g, "/");
+
+			if (cmd.mode === GrepOutputMode.Content) {
+				if (match.contextBefore) {
+					for (const ctx of match.contextBefore) {
+						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
+					}
+				}
+				console.log(`${chalk.cyan(displayPath)}:${chalk.yellow(String(match.lineNumber))}: ${match.line}`);
+				if (match.contextAfter) {
+					for (const ctx of match.contextAfter) {
+						console.log(chalk.dim(`${displayPath}-${ctx.lineNumber}- ${ctx.line}`));
+					}
+				}
+				console.log("");
+			} else if (cmd.mode === GrepOutputMode.Count) {
+				console.log(`${chalk.cyan(displayPath)}: ${match.matchCount ?? 0} matches`);
+			} else {
+				console.log(chalk.cyan(displayPath));
+			}
+		}
+	} catch (err) {
+		console.error(chalk.red(`Error: ${err instanceof Error ? err.message : String(err)}`));
+		process.exit(1);
+	}
+}
+
+export function printGrepHelp(): void {
+	console.log(`${chalk.bold(`${APP_NAME} grep`)} - Test grep tool
+
+${chalk.bold("Usage:")}
+  ${APP_NAME} grep <pattern> [path] [options]
+
+${chalk.bold("Arguments:")}
+  pattern   Regex pattern to search for
+  path      Directory or file to search (default: .)
+
+${chalk.bold("Options:")}
+  -g, --glob <pattern>  Filter files by glob pattern
+  -l, --limit <n>       Max matches (default: 20)
+  -C, --context <n>     Context lines (default: 2)
+  -f, --files           Output file names only
+  -c, --count           Output match counts per file
+  -h, --help            Show this help
+  --no-gitignore        Include files excluded by .gitignore
+
+${chalk.bold("Environment:")}
+  PI_GREP_WORKERS=0    Disable worker pool (use single-threaded mode)
+
+${chalk.bold("Examples:")}
+  ${APP_NAME} grep "import" src/
+  ${APP_NAME} grep "TODO" . --glob "*.ts"
+  ${APP_NAME} grep "function" --files
+`);
+}