gsd-pi 2.77.0-dev.538325aea → 2.77.0-dev.eaa4973bc

package/packages/gsd-agent-core/src/keybindings.ts

@@ -1,220 +0,0 @@
-import {
-	DEFAULT_EDITOR_KEYBINDINGS,
-	type EditorAction,
-	type EditorKeybindingsConfig,
-	EditorKeybindingsManager,
-	type KeyId,
-	matchesKey,
-	setEditorKeybindings,
-} from "@gsd/pi-tui";
-
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { getAgentDir } from "@gsd/pi-coding-agent";
-
-/**
- * Application-level actions (coding agent specific).
- */
-export type AppAction =
-	| "interrupt"
-	| "clear"
-	| "exit"
-	| "suspend"
-	| "cycleThinkingLevel"
-	| "cycleModelForward"
-	| "cycleModelBackward"
-	| "selectModel"
-	| "expandTools"
-	| "toggleThinking"
-	| "toggleSessionNamedFilter"
-	| "externalEditor"
-	| "followUp"
-	| "dequeue"
-	| "pasteImage"
-	| "newSession"
-	| "tree"
-	| "fork"
-	| "resume";
-
-/**
- * All configurable actions.
- */
-export type KeyAction = AppAction | EditorAction;
-
-/**
- * Full keybindings configuration (app + editor actions).
- */
-export type KeybindingsConfig = {
-	[K in KeyAction]?: KeyId | KeyId[];
-};
-
-/**
- * Default application keybindings.
- */
-const DEFAULT_APP_KEYBINDINGS: Record<AppAction, KeyId | KeyId[]> = {
-	interrupt: "escape",
-	clear: "ctrl+c",
-	exit: "ctrl+d",
-	suspend: "ctrl+z",
-	cycleThinkingLevel: "shift+tab",
-	cycleModelForward: "ctrl+p",
-	cycleModelBackward: "shift+ctrl+p",
-	selectModel: "ctrl+l",
-	expandTools: "ctrl+o",
-	toggleThinking: "ctrl+t",
-	toggleSessionNamedFilter: "ctrl+n",
-	externalEditor: "ctrl+g",
-	followUp: "alt+enter",
-	dequeue: "alt+up",
-	pasteImage: process.platform === "win32" ? "alt+v" : ["ctrl+v", "alt+v"],
-	newSession: [],
-	tree: [],
-	fork: [],
-	resume: [],
-};
-
-/**
- * All default keybindings (app + editor).
- * TUI_KEYBINDINGS provides defaults for the editor actions; map to first default key.
- */
-const DEFAULT_EDITOR_KEYBINDING_DEFAULTS: Partial<Record<EditorAction, KeyId | KeyId[]>> = Object.fromEntries(
-	Object.entries(DEFAULT_EDITOR_KEYBINDINGS),
-) as Partial<Record<EditorAction, KeyId | KeyId[]>>;
-
-const DEFAULT_KEYBINDINGS: Required<KeybindingsConfig> = {
-	...DEFAULT_EDITOR_KEYBINDING_DEFAULTS,
-	...DEFAULT_APP_KEYBINDINGS,
-} as Required<KeybindingsConfig>;
-
-// App actions list for type checking
-const APP_ACTIONS: AppAction[] = [
-	"interrupt",
-	"clear",
-	"exit",
-	"suspend",
-	"cycleThinkingLevel",
-	"cycleModelForward",
-	"cycleModelBackward",
-	"selectModel",
-	"expandTools",
-	"toggleThinking",
-	"toggleSessionNamedFilter",
-	"externalEditor",
-	"followUp",
-	"dequeue",
-	"pasteImage",
-	"newSession",
-	"tree",
-	"fork",
-	"resume",
-];
-
-function isAppAction(action: string): action is AppAction {
-	return APP_ACTIONS.includes(action as AppAction);
-}
-
-/**
- * Manages all keybindings (app + editor).
- */
-export class KeybindingsManager {
-	private config: KeybindingsConfig;
-	private appActionToKeys: Map<AppAction, KeyId[]>;
-
-	private constructor(config: KeybindingsConfig) {
-		this.config = config;
-		this.appActionToKeys = new Map();
-		this.buildMaps();
-	}
-
-	/**
-	 * Create from config file and set up editor keybindings.
-	 */
-	static create(agentDir: string = getAgentDir()): KeybindingsManager {
-		const configPath = join(agentDir, "keybindings.json");
-		const config = KeybindingsManager.loadFromFile(configPath);
-		const manager = new KeybindingsManager(config);
-
-		// Set up editor keybindings globally.
-		// Include both editor actions and expandTools (shared between app and editor).
-		// 0.67.2 KeybindingsManager takes (definitions, userBindings) where definitions
-		// is the full keybinding definition map (TUI_KEYBINDINGS) and userBindings
-		// are the user overrides (EditorKeybindingsConfig).
-		const editorConfig: EditorKeybindingsConfig = {};
-		for (const [action, keys] of Object.entries(config)) {
-			if (!isAppAction(action) || action === "expandTools") {
-				editorConfig[action as EditorAction] = keys;
-			}
-		}
-		setEditorKeybindings(new EditorKeybindingsManager(editorConfig));
-
-		return manager;
-	}
-
-	/**
-	 * Create in-memory.
-	 */
-	static inMemory(config: KeybindingsConfig = {}): KeybindingsManager {
-		return new KeybindingsManager(config);
-	}
-
-	private static loadFromFile(path: string): KeybindingsConfig {
-		if (!existsSync(path)) return {};
-		try {
-			return JSON.parse(readFileSync(path, "utf-8"));
-		} catch {
-			return {};
-		}
-	}
-
-	private buildMaps(): void {
-		this.appActionToKeys.clear();
-
-		// Set defaults for app actions
-		for (const [action, keys] of Object.entries(DEFAULT_APP_KEYBINDINGS)) {
-			const keyArray = Array.isArray(keys) ? keys : [keys];
-			this.appActionToKeys.set(action as AppAction, [...keyArray]);
-		}
-
-		// Override with user config (app actions only)
-		for (const [action, keys] of Object.entries(this.config)) {
-			if (keys === undefined || !isAppAction(action)) continue;
-			const keyArray = Array.isArray(keys) ? keys : [keys];
-			this.appActionToKeys.set(action, keyArray);
-		}
-	}
-
-	/**
-	 * Check if input matches an app action.
-	 */
-	matches(data: string, action: AppAction): boolean {
-		const keys = this.appActionToKeys.get(action);
-		if (!keys) return false;
-		for (const key of keys) {
-			if (matchesKey(data, key)) return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Get keys bound to an app action.
-	 */
-	getKeys(action: AppAction): KeyId[] {
-		return this.appActionToKeys.get(action) ?? [];
-	}
-
-	/**
-	 * Get the full effective config.
-	 */
-	getEffectiveConfig(): Required<KeybindingsConfig> {
-		const result = { ...DEFAULT_KEYBINDINGS };
-		for (const [action, keys] of Object.entries(this.config)) {
-			if (keys !== undefined) {
-				(result as KeybindingsConfig)[action as KeyAction] = keys;
-			}
-		}
-		return result;
-	}
-}
-
-// Re-export for convenience
-export type { EditorAction, KeyId };

package/packages/gsd-agent-core/src/lifecycle-hooks.ts

@@ -1,284 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { pathToFileURL } from "node:url";
-import type { PackageManager } from "@gsd/agent-types";
-import type {
-	LifecycleHookContext,
-	LifecycleHookMap,
-	LifecycleHookHandler,
-	LifecycleHookPhase,
-	LifecycleHookScope,
-} from "@gsd/agent-types";
-
-interface ExtensionManifest {
-	dependencies?: {
-		runtime?: string[];
-	};
-}
-
-export interface PackageLifecycleHooksOptions {
-	source: string;
-	local: boolean;
-	cwd: string;
-	agentDir: string;
-	appName: string;
-	packageManager: PackageManager;
-	stdout: NodeJS.WriteStream;
-	stderr: NodeJS.WriteStream;
-}
-
-export type LifecycleHooksTarget = "source" | "installed";
-
-export interface PrepareLifecycleHooksOptions {
-	verifyRuntimeDependencies?: boolean;
-}
-
-export interface LifecycleHooksRunResult {
-	phase: LifecycleHookPhase;
-	hooksRun: number;
-	hookErrors: number;
-	legacyHooksRun: number;
-	entryPathCount: number;
-	skipped: boolean;
-}
-
-interface LoadedLifecycleHooks {
-	source: string;
-	scope: LifecycleHookScope;
-	installedPath?: string;
-	cwd: string;
-	stdout: NodeJS.WriteStream;
-	stderr: NodeJS.WriteStream;
-	entryPaths: string[];
-	hooksByPath: Map<string, LifecycleHookMap>;
-}
-
-function toScope(local: boolean): LifecycleHookScope {
-	return local ? "project" : "user";
-}
-
-function isGitSource(source: string): boolean {
-	if (!source) return false;
-	// https://host/owner/repo(.git), ssh://..., git://..., git@host:owner/repo.git
-	return /^(?:git@[^:\s]+:[^\s]+|(?:https?|ssh|git):\/\/[^\s]+)$/i.test(source);
-}
-
-export function readManifestRuntimeDeps(dir: string): string[] {
-	const manifestPath = join(dir, "extension-manifest.json");
-	if (!existsSync(manifestPath)) return [];
-	try {
-		const manifest = JSON.parse(readFileSync(manifestPath, "utf-8")) as ExtensionManifest;
-		return manifest.dependencies?.runtime?.filter((dep): dep is string => typeof dep === "string") ?? [];
-	} catch {
-		return [];
-	}
-}
-
-export function collectRuntimeDependencies(installedPath: string, entryPaths: string[]): string[] {
-	const deps = new Set<string>();
-	const candidateDirs = new Set<string>([installedPath, ...entryPaths.map((entryPath) => dirname(entryPath))]);
-	for (const dir of candidateDirs) {
-		for (const dep of readManifestRuntimeDeps(dir)) {
-			deps.add(dep);
-		}
-	}
-	return Array.from(deps);
-}
-
-export function verifyRuntimeDependencies(runtimeDeps: string[], source: string, appName: string): void {
-	const missing: string[] = [];
-	for (const dep of runtimeDeps) {
-		const result = spawnSync(dep, ["--version"], { encoding: "utf-8", timeout: 5000 });
-		if (result.error || result.status !== 0) {
-			missing.push(dep);
-		}
-	}
-	if (missing.length === 0) return;
-	throw new Error(
-		`Missing runtime dependencies: ${missing.join(", ")}.\n` +
-			`Install them and retry: ${appName} install ${source}`,
-	);
-}
-
-export function resolveLocalSourcePath(source: string, cwd: string): string | undefined {
-	const trimmed = source.trim();
-	if (!trimmed) return undefined;
-	if (trimmed.startsWith("npm:")) return undefined;
-	if (isGitSource(trimmed)) return undefined;
-
-	let normalized = trimmed;
-	if (normalized === "~") {
-		normalized = homedir();
-	} else if (normalized.startsWith("~/")) {
-		normalized = join(homedir(), normalized.slice(2));
-	}
-
-	const absolutePath = resolve(cwd, normalized);
-	return existsSync(absolutePath) ? absolutePath : undefined;
-}
-
-async function resolveEntryPathsFromTarget(
-	options: PackageLifecycleHooksOptions,
-	target: LifecycleHooksTarget,
-	scope: LifecycleHookScope,
-): Promise<{ entryPaths: string[]; installedPath?: string }> {
-	if (target === "source") {
-		const localSourcePath = resolveLocalSourcePath(options.source, options.cwd);
-		if (!localSourcePath) return { entryPaths: [] };
-		const resolved = await options.packageManager.resolveExtensionSources([localSourcePath], { local: true });
-		const entryPaths = resolved.extensions.filter((resource) => resource.enabled).map((resource) => resource.path);
-		return { entryPaths, installedPath: localSourcePath };
-	}
-
-	const installedPath = options.packageManager.getInstalledPath(options.source, scope);
-	if (!installedPath) return { entryPaths: [] };
-	const resolved = await options.packageManager.resolveExtensionSources([installedPath], { local: true });
-	const entryPaths = resolved.extensions.filter((resource) => resource.enabled).map((resource) => resource.path);
-	return { entryPaths, installedPath };
-}
-
-export async function prepareLifecycleHooks(
-	options: PackageLifecycleHooksOptions,
-	target: LifecycleHooksTarget,
-	prepareOptions?: PrepareLifecycleHooksOptions,
-): Promise<LoadedLifecycleHooks | null> {
-	const scope = toScope(options.local);
-	const { entryPaths, installedPath } = await resolveEntryPathsFromTarget(options, target, scope);
-	if (entryPaths.length === 0) {
-		return null;
-	}
-
-	if (prepareOptions?.verifyRuntimeDependencies && installedPath) {
-		const runtimeDeps = collectRuntimeDependencies(installedPath, entryPaths);
-		verifyRuntimeDependencies(runtimeDeps, options.source, options.appName);
-	}
-
-	// extension.lifecycleHooks and the loadExtensions-based registration path were
-	// removed from the Extension interface in 0.67.2. Only the legacy export path
-	// (runLegacyExportHook via dynamic import()) is used now. Pre-populate hooksByPath
-	// with empty maps so runLifecycleHooks falls through to runLegacyExportHook for
-	// every entry path.
-	const hooksByPath = new Map<string, LifecycleHookMap>();
-	for (const entryPath of entryPaths) {
-		hooksByPath.set(entryPath, {});
-	}
-
-	return {
-		source: options.source,
-		scope,
-		installedPath,
-		cwd: options.cwd,
-		stdout: options.stdout,
-		stderr: options.stderr,
-		entryPaths,
-		hooksByPath,
-	};
-}
-
-async function runHookSafe(
-	hook: LifecycleHookHandler,
-	context: LifecycleHookContext,
-	stderr: NodeJS.WriteStream,
-): Promise<boolean> {
-	try {
-		await hook(context);
-		return true;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		stderr.write(`[lifecycle-hooks:${context.phase}] Hook failed: ${message}\n`);
-		return false;
-	}
-}
-
-function getLegacyExportCandidates(phase: LifecycleHookPhase): string[] {
-	return [phase];
-}
-
-const _legacyModuleCache = new Map<string, Record<string, unknown>>();
-
-async function runLegacyExportHook(
-	entryPath: string,
-	phase: LifecycleHookPhase,
-	_context: LifecycleHookContext,
-): Promise<LifecycleHookHandler | null> {
-	try {
-		let module: Record<string, unknown> | undefined = _legacyModuleCache.get(entryPath);
-		if (!module) {
-			module = (await import(pathToFileURL(entryPath).href)) as Record<string, unknown>;
-			if (!module) return null;
-			_legacyModuleCache.set(entryPath, module);
-		}
-		for (const exportName of getLegacyExportCandidates(phase)) {
-			const candidate = module[exportName];
-			if (typeof candidate === "function") {
-				return candidate as LifecycleHookHandler;
-			}
-		}
-		return null;
-	} catch {
-		return null;
-	}
-}
-
-export async function runLifecycleHooks(
-	loaded: LoadedLifecycleHooks | null,
-	phase: LifecycleHookPhase,
-): Promise<LifecycleHooksRunResult> {
-	if (!loaded) {
-		return {
-			phase,
-			hooksRun: 0,
-			hookErrors: 0,
-			legacyHooksRun: 0,
-			entryPathCount: 0,
-			skipped: true,
-		};
-	}
-
-	const context: LifecycleHookContext = {
-		phase,
-		source: loaded.source,
-		installedPath: loaded.installedPath,
-		scope: loaded.scope,
-		cwd: loaded.cwd,
-		interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
-		log: (message: string) => loaded.stdout.write(`${message}\n`),
-		warn: (message: string) => loaded.stderr.write(`${message}\n`),
-		error: (message: string) => loaded.stderr.write(`${message}\n`),
-	};
-
-	let hooksRun = 0;
-	let hookErrors = 0;
-	let legacyHooksRun = 0;
-
-	for (const entryPath of loaded.entryPaths) {
-		const hookMap = loaded.hooksByPath.get(entryPath);
-		const registeredHooks = hookMap?.[phase] ?? [];
-		if (registeredHooks.length > 0) {
-			for (const hook of registeredHooks) {
-				hooksRun += 1;
-				const ok = await runHookSafe(hook, context, loaded.stderr);
-				if (!ok) hookErrors += 1;
-			}
-			continue;
-		}
-
-		const legacyHook = await runLegacyExportHook(entryPath, phase, context);
-		if (!legacyHook) continue;
-
-		legacyHooksRun += 1;
-		const ok = await runHookSafe(legacyHook, context, loaded.stderr);
-		if (!ok) hookErrors += 1;
-	}
-
-	return {
-		phase,
-		hooksRun,
-		hookErrors,
-		legacyHooksRun,
-		entryPathCount: loaded.entryPaths.length,
-		skipped: false,
-	};
-}