@f5xc-salesdemos/xcsh 18.8.2 → 18.9.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@f5xc-salesdemos/xcsh",
-	"version": "18.8.2",
+	"version": "18.9.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/f5xc-salesdemos/xcsh",
 	"author": "Can Boluk",
@@ -47,12 +47,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.16.1",
 		"@mozilla/readability": "^0.6",
-		"@f5xc-salesdemos/xcsh-stats": "18.8.2",
-		"@f5xc-salesdemos/pi-agent-core": "18.8.2",
-		"@f5xc-salesdemos/pi-ai": "18.8.2",
-		"@f5xc-salesdemos/pi-natives": "18.8.2",
-		"@f5xc-salesdemos/pi-tui": "18.8.2",
-		"@f5xc-salesdemos/pi-utils": "18.8.2",
+		"@f5xc-salesdemos/xcsh-stats": "18.9.0",
+		"@f5xc-salesdemos/pi-agent-core": "18.9.0",
+		"@f5xc-salesdemos/pi-ai": "18.9.0",
+		"@f5xc-salesdemos/pi-natives": "18.9.0",
+		"@f5xc-salesdemos/pi-tui": "18.9.0",
+		"@f5xc-salesdemos/pi-utils": "18.9.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/config/settings-schema.ts

@@ -657,6 +657,17 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"keybindings.chordTimeout": {
+		type: "number",
+		default: 1000,
+		ui: {
+			tab: "interaction",
+			label: "Chord Timeout",
+			description: "Milliseconds to wait for the second key of a chord binding before abandoning it.",
+			submenu: true,
+		},
+	},
+
 	"startup.quiet": {
 		type: "boolean",
 		default: false,

package/src/config/settings.ts

@@ -356,6 +356,17 @@ export class Settings {
 		return this.get("bashInterceptor.patterns");
 	}
 
+	/**
+	 * Get the chord-binding timeout (milliseconds) clamped to the supported range.
+	 * Values outside [200, 5000] are clamped so a malformed config cannot break the
+	 * chord dispatcher (e.g. 0 => never abandon, huge value => leaked state).
+	 */
+	getChordTimeoutMs(): number {
+		const raw = this.get("keybindings.chordTimeout");
+		const value = typeof raw === "number" && Number.isFinite(raw) ? raw : 1000;
+		return Math.min(5000, Math.max(200, Math.round(value)));
+	}
+
 	/**
 	 * Set a model role (helper for modelRoles record).
 	 */

package/src/internal-urls/build-info.generated.ts

@@ -17,17 +17,17 @@ export interface BuildInfo {
 }
 
 export const BUILD_INFO: BuildInfo = {
-	"version": "18.8.2",
-	"commit": "b67646bd5096b169019d794fd0f894f2969696d4",
-	"shortCommit": "b67646b",
+	"version": "18.9.0",
+	"commit": "ed061104e575b3004bd0f578577b9e30d1f294a5",
+	"shortCommit": "ed06110",
 	"branch": "main",
-	"tag": "v18.8.2",
-	"commitDate": "2026-04-22T19:12:35Z",
-	"buildDate": "2026-04-22T19:48:35.804Z",
+	"tag": "v18.9.0",
+	"commitDate": "2026-04-22T21:34:04Z",
+	"buildDate": "2026-04-22T21:57:56.107Z",
 	"dirty": false,
 	"prNumber": "",
 	"repoUrl": "https://github.com/f5xc-salesdemos/xcsh",
 	"repoSlug": "f5xc-salesdemos/xcsh",
-	"commitUrl": "https://github.com/f5xc-salesdemos/xcsh/commit/b67646bd5096b169019d794fd0f894f2969696d4",
-	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v18.8.2"
+	"commitUrl": "https://github.com/f5xc-salesdemos/xcsh/commit/ed061104e575b3004bd0f578577b9e30d1f294a5",
+	"releaseUrl": "https://github.com/f5xc-salesdemos/xcsh/releases/tag/v18.9.0"
 };

package/src/modes/components/settings-defs.ts

@@ -221,6 +221,15 @@ const OPTION_PROVIDERS: Partial<Record<SettingPath, OptionProvider>> = {
 		{ value: "15", label: "15 items" },
 		{ value: "20", label: "20 items" },
 	],
+	// Chord binding timeout (clamped to [200, 5000] ms at read time)
+	"keybindings.chordTimeout": [
+		{ value: "200", label: "200 ms", description: "Minimum — fastest abandon" },
+		{ value: "500", label: "500 ms", description: "Snappy" },
+		{ value: "1000", label: "1 second", description: "Default" },
+		{ value: "2000", label: "2 seconds", description: "Relaxed" },
+		{ value: "3000", label: "3 seconds" },
+		{ value: "5000", label: "5 seconds", description: "Maximum" },
+	],
 	// Ask timeout
 	"ask.timeout": [
 		{ value: "0", label: "Disabled" },

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

@@ -3,6 +3,7 @@ import type { AssistantMessage } from "@f5xc-salesdemos/pi-ai";
 import { type Component, truncateToWidth, visibleWidth } from "@f5xc-salesdemos/pi-tui";
 import { formatCount, getShellPwd } from "@f5xc-salesdemos/pi-utils";
 import { $ } from "bun";
+import { formatKeyHint } from "../../config/keybindings";
 import { settings } from "../../config/settings";
 import type { StatusLinePreset, StatusLineSegmentId, StatusLineSeparatorStyle } from "../../config/settings-schema";
 import { theme } from "../../modes/theme/theme";
@@ -62,6 +63,10 @@ export class StatusLineComponent implements Component {
 	#sessionStartTime: number = Date.now();
 	#planModeStatus: { enabled: boolean; paused: boolean } | null = null;
 	#cwd: string = getShellPwd();
+	// Display text for a pending chord leader (e.g. "Ctrl+X-") or null when no
+	// chord is pending. Populated by the InputController's ChordDispatcher
+	// callbacks; rendered as a dim right-aligned segment in the top border.
+	#chordPending: string | null = null;
 
 	// Git status caching (1s TTL)
 	#cachedGitStatus: {
@@ -116,6 +121,33 @@ export class StatusLineComponent implements Component {
 		this.#planModeStatus = status ?? null;
 	}
 
+	/**
+	 * Called by the InputController's ChordDispatcher when a chord leader is
+	 * pressed. Displays e.g. "Ctrl+X-" in the top border so the user knows a
+	 * partial chord is active and the dispatcher is waiting for the 2nd key.
+	 */
+	setChordPending(leader: string): void {
+		// formatKeyHint's param type is KeyId (a template-literal union) but its
+		// implementation only needs a "+"-separated key string, which is exactly
+		// what the chord dispatcher hands us. Cast so callers can pass a plain
+		// string without having to thread KeyId through the controller API.
+		const next = `${formatKeyHint(leader as Parameters<typeof formatKeyHint>[0])}-`;
+		if (this.#chordPending === next) return;
+		this.#chordPending = next;
+		this.#onStatusChanged?.();
+	}
+
+	/**
+	 * Called when the chord is dispatched, abandoned, or times out. Clears the
+	 * pending indicator. No-op when no chord is pending (avoids spurious
+	 * re-renders).
+	 */
+	clearChordPending(): void {
+		if (this.#chordPending === null) return;
+		this.#chordPending = null;
+		this.#onStatusChanged?.();
+	}
+
 	setHookStatus(key: string, text: string | undefined): void {
 		if (text === undefined) {
 			this.#hookStatuses.delete(key);
@@ -486,6 +518,18 @@ export class StatusLineComponent implements Component {
 			});
 		}
 
+		// Chord-pending indicator: rightmost segment, dim style. Appended last
+		// so it visually sits at the far right of the top border (after any
+		// background-jobs indicator). Swallowed by truncation-from-right in the
+		// sizing loop below if the terminal is too narrow, which is acceptable.
+		if (this.#chordPending !== null) {
+			rightParts.push({
+				content: theme.fg("dim", this.#chordPending),
+				bg: defaultBg,
+				fg: defaultFg,
+			});
+		}
+
 		const topFillWidth = Math.max(0, width);
 		const left = [...leftParts];
 		const right = [...rightParts];

package/src/modes/controllers/chord-routing.ts

@@ -0,0 +1,37 @@
+import type { ChordResult } from "@f5xc-salesdemos/pi-tui";
+
+/**
+ * Sinks invoked by routeChordResult. Exactly one of these fires per call
+ * (or neither, for pending / abandoned — which are intentionally swallowed
+ * so the user's partial chord never leaks into the editor buffer).
+ */
+export interface ChordRouteSinks {
+	action: (actionId: string) => void;
+	editor: (key: string) => void;
+}
+
+/**
+ * Pure routing: given a ChordResult, dispatch to the right sink.
+ *
+ * - `dispatched` → action sink (keybinding matched a complete chord)
+ * - `passthrough` → editor sink (key is not a chord leader or match)
+ * - `pending` / `abandoned` → swallowed (Emacs convention: an abandoned
+ *   leader does not emit the second key into the buffer)
+ *
+ * Extracted so tests can exercise routing logic without constructing a
+ * full InputController.
+ */
+export function routeChordResult(result: ChordResult, key: string, sinks: ChordRouteSinks): void {
+	switch (result.kind) {
+		case "dispatched":
+			sinks.action(result.action);
+			return;
+		case "passthrough":
+			sinks.editor(key);
+			return;
+		case "pending":
+		case "abandoned":
+			// Swallowed — Emacs convention for abandoned leaders.
+			return;
+	}
+}

package/src/modes/controllers/input-controller.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs/promises";
 import { type AgentMessage, ThinkingLevel } from "@f5xc-salesdemos/pi-agent-core";
 import { sanitizeText } from "@f5xc-salesdemos/pi-natives";
-import type { AutocompleteProvider, SlashCommand } from "@f5xc-salesdemos/pi-tui";
+import { type AutocompleteProvider, ChordDispatcher, type SlashCommand } from "@f5xc-salesdemos/pi-tui";
 import { $env } from "@f5xc-salesdemos/pi-utils";
 import { settings } from "../../config/settings";
 import { createStreamingAssistantGutter } from "../../modes/components/gutter-block";
@@ -26,9 +26,63 @@ function isExpandable(obj: unknown): obj is Expandable {
 }
 
 export class InputController {
+	#dispatcher: ChordDispatcher | null = null;
+
 	constructor(private ctx: InteractiveModeContext) {}
 
+	/**
+	 * Rebuild the chord dispatcher from the current keybindings + settings.
+	 * Called from setupKeyHandlers so a subsequent keybindings reload / settings
+	 * change can re-init without leaking the previous pending-timer.
+	 *
+	 * The dispatcher callbacks drive the status-line chord-pending indicator.
+	 * Optional-chaining is deliberate: Task 11 adds setChordPending/clearChordPending
+	 * on StatusLineComponent, so this wiring stays safe before Task 11 lands.
+	 */
+	#initChordDispatcher(): void {
+		this.#dispatcher?.dispose();
+		this.#dispatcher = null;
+		// Feature-detect the context: partial mocks in tests may omit these methods.
+		// Production always satisfies both interfaces (see config/keybindings.ts,
+		// config/settings.ts), so the no-op branch here only protects test fakes.
+		const getBindings = this.ctx.keybindings?.getChordBindings?.bind(this.ctx.keybindings);
+		const getTimeout = this.ctx.settings?.getChordTimeoutMs?.bind(this.ctx.settings);
+		if (!getBindings || !getTimeout) return;
+		const bindings = getBindings();
+		const timeoutMs = getTimeout();
+		// Optional-chaining on methods that Task 11 adds to StatusLineComponent.
+		// Typed loosely so Task 10 can ship before Task 11 wires the methods.
+		const statusLine = this.ctx.statusLine as
+			| {
+					setChordPending?: (leader: string) => void;
+					clearChordPending?: () => void;
+			  }
+			| undefined;
+		this.#dispatcher = new ChordDispatcher(bindings, timeoutMs, {
+			onPending: leader => statusLine?.setChordPending?.(leader),
+			onCleared: () => statusLine?.clearChordPending?.(),
+		});
+	}
+
+	/**
+	 * Dispose of the chord dispatcher (clears any pending chord timer).
+	 * Exposed for tests and for the outer controller lifecycle.
+	 */
+	dispose(): void {
+		this.#dispatcher?.dispose();
+		this.#dispatcher = null;
+	}
+
+	/**
+	 * Exposed for tests: returns the current dispatcher instance (or null if
+	 * setupKeyHandlers has not been called yet).
+	 */
+	getChordDispatcher(): ChordDispatcher | null {
+		return this.#dispatcher;
+	}
+
 	setupKeyHandlers(): void {
+		this.#initChordDispatcher();
 		this.ctx.editor.setActionKeys("app.interrupt", this.ctx.keybindings.getKeys("app.interrupt"));
 		this.ctx.editor.shouldBypassAutocompleteOnEscape = () =>
 			Boolean(