vde-layout 0.0.1 → 0.0.3

package/dist/index.js

@@ -1,24 +1,1461 @@
 #!/usr/bin/env node
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const cli_1 = require("./cli");
-async function main() {
-    const cli = new cli_1.CLI();
-    try {
-        await cli.run(process.argv.slice(2));
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            console.error("Error:", error.message);
-            if (process.env.VDE_DEBUG === "true") {
-                console.error(error.stack);
-            }
-        }
-        else {
-            console.error("An unexpected error occurred:", String(error));
-        }
-        process.exit(1);
-    }
-}
-void main();
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import chalk from "chalk";
+import * as YAML from "yaml";
+import { parse, stringify } from "yaml";
+import fs from "fs-extra";
+import path from "node:path";
+import os from "node:os";
+import { z } from "zod";
+import { execa } from "execa";
+import { createHash } from "node:crypto";
+
+//#region src/utils/errors.ts
+const ErrorCodes = {
+	CONFIG_NOT_FOUND: "CONFIG_NOT_FOUND",
+	CONFIG_PARSE_ERROR: "CONFIG_PARSE_ERROR",
+	CONFIG_PERMISSION_ERROR: "CONFIG_PERMISSION_ERROR",
+	INVALID_PRESET: "INVALID_PRESET",
+	PRESET_NOT_FOUND: "PRESET_NOT_FOUND",
+	INVALID_LAYOUT: "INVALID_LAYOUT",
+	INVALID_PANE: "INVALID_PANE",
+	TMUX_NOT_RUNNING: "TMUX_NOT_RUNNING",
+	TMUX_COMMAND_FAILED: "TMUX_COMMAND_FAILED",
+	NOT_IN_TMUX_SESSION: "NOT_IN_TMUX_SESSION",
+	NOT_IN_TMUX: "NOT_IN_TMUX",
+	TMUX_NOT_FOUND: "TMUX_NOT_FOUND",
+	TMUX_NOT_INSTALLED: "TMUX_NOT_INSTALLED",
+	UNSUPPORTED_TMUX_VERSION: "UNSUPPORTED_TMUX_VERSION"
+};
+const createBaseError = (name, message, code, details = {}) => {
+	const error = new Error(message);
+	error.name = name;
+	error.code = code;
+	error.details = details;
+	return error;
+};
+const createConfigError = (message, code, details = {}) => {
+	return createBaseError("ConfigError", message, code, details);
+};
+const createValidationError = (message, code, details = {}) => {
+	return createBaseError("ValidationError", message, code, details);
+};
+const createTmuxError = (message, code, details = {}) => {
+	return createBaseError("TmuxError", message, code, details);
+};
+const isVDELayoutError = (error) => {
+	if (typeof error !== "object" || error === null) return false;
+	if (!("code" in error)) return false;
+	const { code } = error;
+	if (typeof code !== "string") return false;
+	if (!("details" in error)) return false;
+	return true;
+};
+const formatters = {
+	[ErrorCodes.CONFIG_NOT_FOUND]: (error) => {
+		const searchPaths = error.details.searchPaths;
+		if (!Array.isArray(searchPaths)) return "";
+		const lines = ["", "Searched in the following locations:"];
+		searchPaths.forEach((location) => lines.push(`  - ${location}`));
+		lines.push("", "To create a configuration file, run:");
+		lines.push("  mkdir -p ~/.config/vde");
+		lines.push("  echo \"presets: {}\" > ~/.config/vde/layout.yml");
+		return lines.join("\n");
+	},
+	[ErrorCodes.NOT_IN_TMUX_SESSION]: () => {
+		return "\nThis command must be run inside a tmux session.\nStart tmux first with: tmux\n";
+	},
+	[ErrorCodes.TMUX_NOT_INSTALLED]: () => {
+		return "\ntmux is required but not installed.\nInstall tmux using your package manager:\n  - macOS: brew install tmux\n  - Ubuntu/Debian: sudo apt-get install tmux\n  - Fedora: sudo dnf install tmux\n";
+	},
+	[ErrorCodes.UNSUPPORTED_TMUX_VERSION]: (error) => {
+		const requiredVersion = error.details.requiredVersion;
+		if (typeof requiredVersion !== "string") return "";
+		return `\nRequired tmux version: ${requiredVersion} or higher\n`;
+	}
+};
+
+//#endregion
+//#region src/models/schema.ts
+const TerminalPaneSchema = z.object({
+	name: z.string().min(1),
+	command: z.string().optional(),
+	cwd: z.string().optional(),
+	env: z.record(z.string()).optional(),
+	delay: z.number().int().positive().optional(),
+	title: z.string().optional(),
+	focus: z.boolean().optional()
+}).strict();
+const SplitPaneSchema = z.lazy(() => z.object({
+	type: z.enum(["horizontal", "vertical"]),
+	ratio: z.array(z.number().positive()).min(1),
+	panes: z.array(PaneSchema).min(1)
+}).strict().refine((data) => data.ratio.length === data.panes.length, { message: "Number of elements in ratio array does not match number of elements in panes array" }));
+const PaneSchema = z.lazy(() => z.union([SplitPaneSchema, TerminalPaneSchema]));
+const LayoutSchema = z.object({
+	type: z.enum(["horizontal", "vertical"]),
+	ratio: z.array(z.number().positive()).min(1),
+	panes: z.array(PaneSchema).min(1)
+}).refine((data) => data.ratio.length === data.panes.length, { message: "Number of elements in ratio array does not match number of elements in panes array" });
+const PresetSchema = z.object({
+	name: z.string().min(1),
+	description: z.string().optional(),
+	layout: LayoutSchema.optional(),
+	command: z.string().optional()
+});
+const ConfigSchema = z.object({ presets: z.record(PresetSchema) });
+
+//#endregion
+//#region src/config/validator.ts
+/**
+* Parse YAML text into an object
+* @param yamlText - YAML text to parse
+* @returns Parsed object
+* @throws {ValidationError} When YAML parsing fails
+*/
+const parseYAML = (yamlText) => {
+	if (!yamlText || typeof yamlText !== "string") throw createValidationError("YAML text not provided", ErrorCodes.CONFIG_PARSE_ERROR, { received: typeof yamlText });
+	try {
+		return YAML.parse(yamlText);
+	} catch (error) {
+		throw createValidationError("Failed to parse YAML", ErrorCodes.CONFIG_PARSE_ERROR, {
+			parseError: error instanceof Error ? error.message : String(error),
+			yamlSnippet: yamlText.substring(0, 200)
+		});
+	}
+};
+/**
+* Validate basic configuration structure
+* @param parsed - Parsed YAML object
+* @throws {ValidationError} When structure is invalid
+*/
+const validateConfigStructure = (parsed) => {
+	if (parsed === null || parsed === void 0 || typeof parsed !== "object") throw createValidationError("YAML is empty or invalid format", ErrorCodes.CONFIG_PARSE_ERROR, { parsed });
+	const parsedObj = parsed;
+	if (!("presets" in parsedObj) || parsedObj.presets === void 0 || parsedObj.presets === null) throw createValidationError("presets field is required", ErrorCodes.INVALID_PRESET, { availableFields: Object.keys(parsedObj) });
+	const presetsObj = parsedObj.presets;
+	if (typeof presetsObj !== "object" || presetsObj === null || Object.keys(presetsObj).length === 0) throw createValidationError("At least one preset is required", ErrorCodes.INVALID_PRESET, { presets: presetsObj });
+};
+/**
+* Format Zod validation errors into user-friendly messages
+* @param error - Zod validation error
+* @returns Formatted error issues
+*/
+const formatZodErrors = (error) => {
+	return error.issues.map((issue) => {
+		const path$1 = issue.path.join(".");
+		let message = issue.message;
+		if (issue.code === "invalid_type") {
+			if (issue.path.includes("command") && issue.expected === "string") message = "command field must be a string";
+			else if (issue.path.includes("workingDirectory") && issue.expected === "string") message = "workingDirectory field must be a string";
+			else if (issue.received === "number" && issue.expected === "string") message = `${path$1} must be a string`;
+			else if (issue.received === "array" && issue.expected === "string") message = `${path$1} must be a string`;
+		} else if (issue.code === "invalid_union") {
+			const unionIssue = issue;
+			if (unionIssue.unionErrors !== void 0) if (unionIssue.unionErrors.find((e) => e.issues?.some((i) => i.path.includes("command") && i.code === "invalid_type") === true) !== void 0) message = "command field is required";
+			else if (unionIssue.unionErrors.find((e) => e.issues?.some((i) => i.path.includes("panes") && i.code === "invalid_type") === true) !== void 0) message = "panes field is required";
+			else message = "Pane type must be \"terminal\" or \"split\"";
+			else message = "Pane type must be \"terminal\" or \"split\"";
+		} else if (issue.code === "invalid_literal") {
+			if (issue.path.includes("direction")) message = "direction must be \"horizontal\" or \"vertical\"";
+		} else if (issue.message.includes("required")) message = issue.message;
+		else if (issue.code === "custom" && issue.message.includes("ratio array")) message = issue.message;
+		else if (issue.code === "too_small" && issue.message.includes("Array must contain at least")) if (path$1.includes("panes")) message = "panes array must contain at least 2 elements";
+		else if (path$1.includes("ratio")) message = "ratio array must contain at least 2 elements";
+		else message = issue.message;
+		return {
+			path: path$1,
+			message,
+			code: issue.code
+		};
+	});
+};
+/**
+* Validates YAML text and converts it to a type-safe Config object
+* @param yamlText - YAML text to validate
+* @returns Validated Config object
+* @throws {ValidationError} When YAML is invalid
+*/
+const validateYAML = (yamlText) => {
+	const parsed = parseYAML(yamlText);
+	validateConfigStructure(parsed);
+	try {
+		return ConfigSchema.parse(parsed);
+	} catch (error) {
+		if (error instanceof z.ZodError) {
+			const issues = formatZodErrors(error);
+			const primaryMessage = issues.length > 0 && issues[0] ? issues[0].message : "Configuration validation failed";
+			throw createValidationError(primaryMessage, ErrorCodes.CONFIG_PARSE_ERROR, {
+				issues,
+				rawErrors: error.issues
+			});
+		}
+		if (isVDELayoutError(error) && error.name === "ValidationError") throw error;
+		throw createValidationError("Unexpected validation error occurred", ErrorCodes.CONFIG_PARSE_ERROR, { error: error instanceof Error ? error.message : String(error) });
+	}
+};
+
+//#endregion
+//#region src/config/loader.ts
+const createConfigLoader = (options = {}) => {
+	const explicitConfigPaths = options.configPaths;
+	const computeCachedSearchPaths = () => {
+		if (explicitConfigPaths && explicitConfigPaths.length > 0) return [...explicitConfigPaths];
+		const candidates = [];
+		const projectCandidate = findProjectConfigCandidate();
+		if (projectCandidate !== null) candidates.push(projectCandidate);
+		candidates.push(...buildDefaultSearchPaths());
+		return [...new Set(candidates)];
+	};
+	const loadConfig = async () => {
+		if (explicitConfigPaths && explicitConfigPaths.length > 0) {
+			const filePath = await findFirstExisting(explicitConfigPaths);
+			if (filePath === null) throw createConfigError("Configuration file not found", ErrorCodes.CONFIG_NOT_FOUND, { searchPaths: explicitConfigPaths });
+			const content = await safeReadFile(filePath);
+			return validateYAML(content);
+		}
+		const searchPaths = computeCachedSearchPaths();
+		const existingPaths = await filterExistingPaths(searchPaths);
+		if (existingPaths.length === 0) throw createConfigError("Configuration file not found", ErrorCodes.CONFIG_NOT_FOUND, { searchPaths });
+		const projectPath = findProjectConfigCandidate();
+		const globalPaths = existingPaths.filter((filePath) => filePath !== projectPath);
+		let mergedConfig = { presets: {} };
+		for (const globalPath of globalPaths) {
+			const content = await safeReadFile(globalPath);
+			const config = validateYAML(content);
+			mergedConfig = mergeConfigs(mergedConfig, config);
+		}
+		if (projectPath !== null && await fs.pathExists(projectPath)) {
+			const content = await safeReadFile(projectPath);
+			const config = validateYAML(content);
+			mergedConfig = mergeConfigs(mergedConfig, config);
+		}
+		return mergedConfig;
+	};
+	return {
+		loadYAML: async () => {
+			const config = await loadConfig();
+			return YAML.stringify(config);
+		},
+		loadConfig,
+		findConfigFile: async () => {
+			const searchPaths = explicitConfigPaths && explicitConfigPaths.length > 0 ? [...explicitConfigPaths] : computeCachedSearchPaths();
+			for (const searchPath of searchPaths) if (await fs.pathExists(searchPath)) return searchPath;
+			return null;
+		},
+		getSearchPaths: () => computeCachedSearchPaths()
+	};
+};
+const buildDefaultSearchPaths = () => {
+	const paths = [];
+	const vdeConfigPath = process.env.VDE_CONFIG_PATH;
+	if (vdeConfigPath !== void 0) paths.push(path.join(vdeConfigPath, "layout.yml"));
+	const homeDir = process.env.HOME ?? os.homedir();
+	const xdgConfigHome = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, ".config");
+	paths.push(path.join(xdgConfigHome, "vde", "layout.yml"));
+	return [...new Set(paths)];
+};
+const findProjectConfigCandidate = () => {
+	let currentDir = process.cwd();
+	const { root } = path.parse(currentDir);
+	while (true) {
+		const candidate = path.join(currentDir, ".vde", "layout.yml");
+		if (fs.existsSync(candidate)) return candidate;
+		if (currentDir === root) break;
+		const parent = path.dirname(currentDir);
+		if (parent === currentDir) break;
+		currentDir = parent;
+	}
+	return null;
+};
+const findFirstExisting = async (paths) => {
+	for (const candidate of paths) if (await fs.pathExists(candidate)) return candidate;
+	return null;
+};
+const filterExistingPaths = async (paths) => {
+	const existing = [];
+	for (const candidate of paths) if (await fs.pathExists(candidate)) existing.push(candidate);
+	return existing;
+};
+const safeReadFile = async (filePath) => {
+	try {
+		return await fs.readFile(filePath, "utf8");
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		throw createConfigError(`Failed to read configuration file`, ErrorCodes.CONFIG_PERMISSION_ERROR, {
+			filePath,
+			error: errorMessage
+		});
+	}
+};
+const mergeConfigs = (base, override) => {
+	return { presets: {
+		...base.presets,
+		...override.presets
+	} };
+};
+
+//#endregion
+//#region src/layout/preset.ts
+const createState = (options = {}) => {
+	let loaderOptions = options;
+	let cachedConfig = null;
+	const setConfigPath = (filePath) => {
+		loaderOptions = { configPaths: [filePath] };
+		cachedConfig = null;
+	};
+	const loadConfig = async () => {
+		cachedConfig = await createConfigLoader(loaderOptions).loadConfig();
+	};
+	const ensureConfig = () => {
+		if (cachedConfig === null) throw createConfigError("Configuration not loaded", ErrorCodes.CONFIG_NOT_FOUND);
+		return cachedConfig;
+	};
+	const getPreset = (name) => {
+		const config = ensureConfig();
+		const preset = config.presets[name];
+		if (preset === void 0) throw createConfigError(`Preset "${name}" not found`, ErrorCodes.PRESET_NOT_FOUND, { availablePresets: Object.keys(config.presets) });
+		return preset;
+	};
+	const listPresets = () => {
+		if (cachedConfig === null) return [];
+		return Object.entries(cachedConfig.presets).map(([key, preset]) => ({
+			key,
+			name: preset.name,
+			description: preset.description
+		}));
+	};
+	const getDefaultPreset = () => {
+		const config = ensureConfig();
+		if (config.presets.default !== void 0) return config.presets.default;
+		const firstKey = Object.keys(config.presets)[0];
+		if (typeof firstKey !== "string" || firstKey.length === 0) throw createConfigError("No presets defined", ErrorCodes.PRESET_NOT_FOUND);
+		return config.presets[firstKey];
+	};
+	return {
+		setConfigPath,
+		loadConfig,
+		getPreset,
+		listPresets,
+		getDefaultPreset
+	};
+};
+const createPresetManager = (options = {}) => {
+	const state = createState(options);
+	return {
+		setConfigPath: state.setConfigPath,
+		loadConfig: state.loadConfig,
+		getPreset: state.getPreset,
+		listPresets: state.listPresets,
+		getDefaultPreset: state.getDefaultPreset
+	};
+};
+
+//#endregion
+//#region src/utils/logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["ERROR"] = 0] = "ERROR";
+	LogLevel$1[LogLevel$1["WARN"] = 1] = "WARN";
+	LogLevel$1[LogLevel$1["INFO"] = 2] = "INFO";
+	LogLevel$1[LogLevel$1["DEBUG"] = 3] = "DEBUG";
+	return LogLevel$1;
+}({});
+const resolveDefaultLogLevel = () => {
+	if (process.env.VDE_DEBUG === "true") return LogLevel.DEBUG;
+	if (process.env.VDE_VERBOSE === "true") return LogLevel.INFO;
+	return LogLevel.WARN;
+};
+const formatMessage = (prefix, message) => {
+	return prefix ? `${prefix} ${message}` : message;
+};
+const createLogger = (options = {}) => {
+	const level = options.level ?? resolveDefaultLogLevel();
+	const prefix = options.prefix ?? "";
+	const build = (nextPrefix, nextLevel) => {
+		const resolvedPrefix = nextPrefix;
+		return {
+			level: nextLevel,
+			prefix: resolvedPrefix,
+			error(message, error) {
+				if (nextLevel >= LogLevel.ERROR) {
+					console.error(chalk.red(formatMessage(resolvedPrefix, `Error: ${message}`)));
+					if (error && process.env.VDE_DEBUG === "true") console.error(chalk.gray(error.stack));
+				}
+			},
+			warn(message) {
+				if (nextLevel >= LogLevel.WARN) console.warn(chalk.yellow(formatMessage(resolvedPrefix, message)));
+			},
+			info(message) {
+				if (nextLevel >= LogLevel.INFO) console.log(formatMessage(resolvedPrefix, message));
+			},
+			debug(message) {
+				if (nextLevel >= LogLevel.DEBUG) console.log(chalk.gray(formatMessage(resolvedPrefix, `[DEBUG] ${message}`)));
+			},
+			success(message) {
+				console.log(chalk.green(formatMessage(resolvedPrefix, message)));
+			},
+			createChild(suffix) {
+				const childPrefix = resolvedPrefix ? `${resolvedPrefix} ${suffix}` : suffix;
+				return build(childPrefix, nextLevel);
+			}
+		};
+	};
+	return build(prefix, level);
+};
+
+//#endregion
+//#region src/executor/real-executor.ts
+const parseCommand$1 = (commandOrArgs) => {
+	return typeof commandOrArgs === "string" ? commandOrArgs.split(" ").filter((segment) => segment.length > 0).slice(1) : commandOrArgs;
+};
+const toCommandString$1 = (args) => {
+	return ["tmux", ...args].join(" ");
+};
+const createRealExecutor = (options = {}) => {
+	const verbose = options.verbose ?? false;
+	const logger = createLogger({
+		level: verbose ? LogLevel.INFO : LogLevel.WARN,
+		prefix: "[tmux]"
+	});
+	const execute = async (commandOrArgs) => {
+		const args = parseCommand$1(commandOrArgs);
+		const commandString = toCommandString$1(args);
+		logger.info(`Executing: ${commandString}`);
+		try {
+			return (await execa("tmux", args)).stdout;
+		} catch (error) {
+			const execaError = error;
+			throw createTmuxError("Failed to execute tmux command", ErrorCodes.TMUX_COMMAND_FAILED, {
+				command: commandString,
+				exitCode: execaError.exitCode,
+				stderr: execaError.stderr
+			});
+		}
+	};
+	return {
+		execute,
+		async executeMany(commandsList) {
+			for (const args of commandsList) await execute(args);
+		},
+		isDryRun() {
+			return false;
+		},
+		logCommand(command) {
+			logger.info(`Executing: ${command}`);
+		}
+	};
+};
+
+//#endregion
+//#region src/executor/dry-run-executor.ts
+const parseCommand = (commandOrArgs) => {
+	return typeof commandOrArgs === "string" ? commandOrArgs.split(" ").filter((segment) => segment.length > 0).slice(1) : commandOrArgs;
+};
+const toCommandString = (args) => {
+	return ["tmux", ...args].join(" ");
+};
+const createDryRunExecutor = (options = {}) => {
+	const verbose = options.verbose ?? false;
+	const logger = createLogger({
+		level: verbose ? LogLevel.INFO : LogLevel.WARN,
+		prefix: "[tmux] [DRY RUN]"
+	});
+	const execute = async (commandOrArgs) => {
+		const args = parseCommand(commandOrArgs);
+		const commandString = toCommandString(args);
+		logger.info(`Would execute: ${commandString}`);
+		return "";
+	};
+	return {
+		execute,
+		async executeMany(commandsList) {
+			for (const args of commandsList) await execute(args);
+		},
+		isDryRun() {
+			return true;
+		},
+		logCommand(command) {
+			logger.info(`Would execute: ${command}`);
+		}
+	};
+};
+
+//#endregion
+//#region src/core/errors.ts
+const createFunctionalError = (kind, error) => ({
+	kind,
+	code: error.code,
+	message: error.message,
+	source: error.source,
+	path: error.path,
+	details: error.details
+});
+const isFunctionalCoreError = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return (candidate.kind === "compile" || candidate.kind === "plan" || candidate.kind === "emit" || candidate.kind === "execution") && typeof candidate.code === "string" && typeof candidate.message === "string";
+};
+
+//#endregion
+//#region src/executor/plan-runner.ts
+const DOUBLE_QUOTE = "\"";
+const ESCAPED_DOUBLE_QUOTE = "\\\"";
+const executePlan = async ({ emission, executor, windowName }) => {
+	const initialVirtualPaneId = emission.summary.initialPaneId;
+	if (typeof initialVirtualPaneId !== "string" || initialVirtualPaneId.length === 0) raiseExecutionError("INVALID_PLAN", {
+		message: "Plan emission is missing initial pane metadata",
+		path: "plan.initialPaneId"
+	});
+	const paneMap = /* @__PURE__ */ new Map();
+	const newWindowCommand = [
+		"new-window",
+		"-P",
+		"-F",
+		"#{pane_id}"
+	];
+	if (typeof windowName === "string" && windowName.trim().length > 0) newWindowCommand.push("-n", windowName.trim());
+	const initialPaneId = normalizePaneId(await executeCommand(executor, newWindowCommand, {
+		code: ErrorCodes.TMUX_COMMAND_FAILED,
+		message: "Failed to create tmux window",
+		path: initialVirtualPaneId
+	}));
+	registerPane(paneMap, initialVirtualPaneId, initialPaneId);
+	let executedSteps = 0;
+	for (const step of emission.steps) {
+		if (step.kind === "split") await executeSplitStep({
+			step,
+			executor,
+			paneMap
+		});
+		else if (step.kind === "focus") await executeFocusStep({
+			step,
+			executor,
+			paneMap
+		});
+		executedSteps += 1;
+	}
+	await executeTerminalCommands({
+		terminals: emission.terminals,
+		executor,
+		paneMap
+	});
+	const finalRealFocus = resolvePaneId(paneMap, emission.summary.focusPaneId);
+	if (typeof finalRealFocus === "string" && finalRealFocus.length > 0) await executeCommand(executor, [
+		"select-pane",
+		"-t",
+		finalRealFocus
+	], {
+		code: ErrorCodes.TMUX_COMMAND_FAILED,
+		message: "Failed to restore focus",
+		path: emission.summary.focusPaneId
+	});
+	return { executedSteps };
+};
+const executeSplitStep = async ({ step, executor, paneMap }) => {
+	const targetVirtualId = ensureNonEmpty(step.targetPaneId, () => raiseExecutionError("MISSING_TARGET", {
+		message: "Split step missing target pane metadata",
+		path: step.id
+	}));
+	const targetRealId = ensureNonEmpty(resolvePaneId(paneMap, targetVirtualId), () => raiseExecutionError("UNKNOWN_PANE", {
+		message: `Unknown target pane: ${targetVirtualId}`,
+		path: step.id
+	}));
+	const panesBefore = await listPaneIds(executor, step);
+	const splitCommand = replaceTarget(step.command, targetRealId);
+	await executeCommand(executor, splitCommand, {
+		code: ErrorCodes.TMUX_COMMAND_FAILED,
+		message: `Failed to execute split step ${step.id}`,
+		path: step.id,
+		details: { command: splitCommand }
+	});
+	const panesAfter = await listPaneIds(executor, step);
+	const newPaneId = ensureNonEmpty(findNewPaneId(panesBefore, panesAfter), () => raiseExecutionError("UNKNOWN_PANE", {
+		message: "Unable to determine newly created pane",
+		path: step.id
+	}));
+	const createdVirtualId = step.createdPaneId;
+	if (typeof createdVirtualId === "string" && createdVirtualId.length > 0) registerPane(paneMap, createdVirtualId, newPaneId);
+};
+const executeFocusStep = async ({ step, executor, paneMap }) => {
+	const targetVirtualId = ensureNonEmpty(step.targetPaneId, () => raiseExecutionError("MISSING_TARGET", {
+		message: "Focus step missing target pane metadata",
+		path: step.id
+	}));
+	const targetRealId = ensureNonEmpty(resolvePaneId(paneMap, targetVirtualId), () => raiseExecutionError("UNKNOWN_PANE", {
+		message: `Unknown focus pane: ${targetVirtualId}`,
+		path: step.id
+	}));
+	const command = replaceTarget(step.command, targetRealId);
+	await executeCommand(executor, command, {
+		code: ErrorCodes.TMUX_COMMAND_FAILED,
+		message: `Failed to execute focus step ${step.id}`,
+		path: step.id,
+		details: { command }
+	});
+};
+const executeTerminalCommands = async ({ terminals, executor, paneMap }) => {
+	for (const terminal of terminals) {
+		const realPaneId = ensureNonEmpty(resolvePaneId(paneMap, terminal.virtualPaneId), () => raiseExecutionError("UNKNOWN_PANE", {
+			message: `Unknown terminal pane: ${terminal.virtualPaneId}`,
+			path: terminal.virtualPaneId
+		}));
+		if (typeof terminal.cwd === "string" && terminal.cwd.length > 0) {
+			const escapedCwd = terminal.cwd.split(DOUBLE_QUOTE).join(ESCAPED_DOUBLE_QUOTE);
+			await executeCommand(executor, [
+				"send-keys",
+				"-t",
+				realPaneId,
+				`cd "${escapedCwd}"`,
+				"Enter"
+			], {
+				code: ErrorCodes.TMUX_COMMAND_FAILED,
+				message: `Failed to change directory for pane ${terminal.virtualPaneId}`,
+				path: terminal.virtualPaneId,
+				details: { cwd: terminal.cwd }
+			});
+		}
+		if (terminal.env !== void 0) for (const [key, value] of Object.entries(terminal.env)) {
+			const escaped = String(value).split(DOUBLE_QUOTE).join(ESCAPED_DOUBLE_QUOTE);
+			await executeCommand(executor, [
+				"send-keys",
+				"-t",
+				realPaneId,
+				`export ${key}="${escaped}"`,
+				"Enter"
+			], {
+				code: ErrorCodes.TMUX_COMMAND_FAILED,
+				message: `Failed to set environment variable ${key}`,
+				path: terminal.virtualPaneId
+			});
+		}
+		if (typeof terminal.command === "string" && terminal.command.length > 0) await executeCommand(executor, [
+			"send-keys",
+			"-t",
+			realPaneId,
+			terminal.command,
+			"Enter"
+		], {
+			code: ErrorCodes.TMUX_COMMAND_FAILED,
+			message: `Failed to execute command for pane ${terminal.virtualPaneId}`,
+			path: terminal.virtualPaneId,
+			details: { command: terminal.command }
+		});
+	}
+};
+const executeCommand = async (executor, command, context) => {
+	try {
+		return await executor.execute([...command]);
+	} catch (error) {
+		if (error instanceof Error && "code" in error && "message" in error) {
+			const candidate = error;
+			throw createFunctionalError("execution", {
+				code: typeof candidate.code === "string" ? candidate.code : context.code,
+				message: candidate.message ?? context.message,
+				path: context.path,
+				details: candidate.details ?? context.details
+			});
+		}
+		throw createFunctionalError("execution", {
+			code: context.code,
+			message: context.message,
+			path: context.path,
+			details: context.details
+		});
+	}
+};
+const listPaneIds = async (executor, step) => {
+	return (await executeCommand(executor, [
+		"list-panes",
+		"-F",
+		"#{pane_id}"
+	], {
+		code: ErrorCodes.TMUX_COMMAND_FAILED,
+		message: "Failed to list tmux panes",
+		path: step.id
+	})).split("\n").map((pane) => pane.trim()).filter((pane) => pane.length > 0);
+};
+const findNewPaneId = (before, after) => {
+	const beforeSet = new Set(before);
+	return after.find((id) => !beforeSet.has(id));
+};
+const replaceTarget = (command, realTarget) => {
+	const next = [...command];
+	const targetIndex = next.findIndex((value, index) => value === "-t" && index + 1 < next.length);
+	if (targetIndex >= 0) {
+		next[targetIndex + 1] = realTarget;
+		return next;
+	}
+	if (next.length > 0) next[next.length - 1] = realTarget;
+	return next;
+};
+const normalizePaneId = (raw) => {
+	const trimmed = raw.trim();
+	return trimmed.length === 0 ? "%0" : trimmed;
+};
+const registerPane = (paneMap, virtualId, realId) => {
+	paneMap.set(virtualId, realId);
+};
+const resolvePaneId = (paneMap, virtualId) => {
+	const direct = paneMap.get(virtualId);
+	if (typeof direct === "string" && direct.length > 0) return direct;
+	let ancestor = virtualId;
+	while (ancestor.includes(".")) {
+		ancestor = ancestor.slice(0, ancestor.lastIndexOf("."));
+		const candidate = paneMap.get(ancestor);
+		if (typeof candidate === "string" && candidate.length > 0) {
+			paneMap.set(virtualId, candidate);
+			return candidate;
+		}
+	}
+	for (const [key, value] of paneMap.entries()) if (key.startsWith(`${virtualId}.`)) {
+		if (typeof value === "string" && value.length > 0) {
+			paneMap.set(virtualId, value);
+			return value;
+		}
+	}
+};
+const ensureNonEmpty = (value, buildError) => {
+	if (value === void 0 || value.length === 0) return buildError();
+	return value;
+};
+const raiseExecutionError = (code, error) => {
+	throw createFunctionalError("execution", {
+		code,
+		message: error.message,
+		path: error.path,
+		details: error.details
+	});
+};
+
+//#endregion
+//#region src/core/diagnostics.ts
+const severityRank = {
+	high: 3,
+	medium: 2,
+	low: 1
+};
+const createAccumulator = () => {
+	const findings = [];
+	const nextSteps = /* @__PURE__ */ new Set();
+	const backlog = /* @__PURE__ */ new Map();
+	return {
+		findings,
+		nextSteps,
+		backlog,
+		add: ({ path: path$1, severity, description, nextStep }) => {
+			findings.push({
+				path: path$1,
+				severity,
+				description
+			});
+			if (typeof nextStep === "string" && nextStep.length > 0) nextSteps.add(nextStep);
+			const existing = backlog.get(path$1);
+			const existingActions = new Set(existing?.actions ?? []);
+			existingActions.add(description);
+			if (typeof nextStep === "string" && nextStep.length > 0) existingActions.add(nextStep);
+			const mergedSeverity = existing !== void 0 ? maxSeverity(existing.severity, severity) : severity;
+			const summary = existing !== void 0 && severityRank[existing.severity] >= severityRank[severity] ? existing.summary : description;
+			backlog.set(path$1, {
+				id: path$1,
+				severity: mergedSeverity,
+				summary,
+				actions: Array.from(existingActions)
+			});
+		}
+	};
+};
+const runDiagnostics = (input) => {
+	const accumulator = createAccumulator();
+	const knownIssues = input.knownIssues ?? [];
+	let parsedPreset;
+	try {
+		parsedPreset = parse(input.presetDocument);
+	} catch (error) {
+		accumulator.add({
+			path: "presetDocument",
+			severity: "high",
+			description: `プリセットYAMLの解析に失敗しました: ${error.message}`,
+			nextStep: "プリセットYAMLを構文チェックし、Functional Coreリライト前に整合性を確保する"
+		});
+		return {
+			findings: sortBySeverity(accumulator.findings),
+			nextSteps: Array.from(accumulator.nextSteps),
+			backlog: sortBacklog(accumulator.backlog)
+		};
+	}
+	if (parsedPreset === null || typeof parsedPreset !== "object") accumulator.add({
+		path: "preset",
+		severity: "high",
+		description: "プリセット定義がオブジェクト形式ではありません",
+		nextStep: "プリセットYAMLをオブジェクト構造に整形し整合性を確保する"
+	});
+	else {
+		const presetObject = parsedPreset;
+		checkFocusDuplications(presetObject, accumulator);
+		collectLowPrioritySignals(presetObject, accumulator);
+	}
+	knownIssues.forEach((issue, index) => {
+		const trimmed = issue.trim();
+		if (trimmed.length === 0) return;
+		accumulator.add({
+			path: `codebase.knownIssues[${index}]`,
+			severity: "medium",
+			description: trimmed,
+			nextStep: `tmux依存や副作用をFunctional Core境界で切り離す: ${trimmed}`
+		});
+	});
+	return {
+		findings: sortBySeverity(accumulator.findings),
+		nextSteps: Array.from(accumulator.nextSteps),
+		backlog: sortBacklog(accumulator.backlog)
+	};
+};
+const checkFocusDuplications = (preset, accumulator) => {
+	const layout = preset.layout;
+	if (layout === void 0 || layout === null) return;
+	if (countFocusFlags(layout) > 1) accumulator.add({
+		path: "preset.layout",
+		severity: "high",
+		description: "複数のペインでfocus: trueが指定されています",
+		nextStep: "focusは単一ペインに限定しPlan生成時に一貫するようFunctional Coreで制御する"
+	});
+};
+const collectLowPrioritySignals = (preset, accumulator) => {
+	const layout = preset.layout;
+	if (layout === void 0 || layout === null) {
+		accumulator.add({
+			path: "preset.layout",
+			severity: "low",
+			description: "layout定義が存在しません（単一ペイン運用が前提）",
+			nextStep: "単一ペイン前提でもPlan出力に影響しないことをFunctional Coreで確認する"
+		});
+		return;
+	}
+	if (!Array.isArray(layout.panes)) accumulator.add({
+		path: "preset.layout.panes",
+		severity: "low",
+		description: "panes配列が存在しないか配列ではありません",
+		nextStep: "レイアウト定義の構造を正規化し、Plan生成の入力契約を明示する"
+	});
+};
+const countFocusFlags = (node) => {
+	if (Array.isArray(node)) return node.reduce((sum, child) => sum + countFocusFlags(child), 0);
+	if (node === null || typeof node !== "object") return 0;
+	const record = node;
+	const selfFocus = record.focus === true ? 1 : 0;
+	const childFocus = Array.isArray(record.panes) ? record.panes.reduce((sum, child) => sum + countFocusFlags(child), 0) : 0;
+	return selfFocus + childFocus;
+};
+const sortBySeverity = (findings) => {
+	return [...findings].sort((a, b) => severityRank[b.severity] - severityRank[a.severity]);
+};
+const sortBacklog = (backlog) => {
+	return [...backlog.values()].sort((a, b) => severityRank[b.severity] - severityRank[a.severity]);
+};
+const maxSeverity = (left, right) => {
+	return severityRank[left] >= severityRank[right] ? left : right;
+};
+
+//#endregion
+//#region src/core/compile.ts
+const compilePreset = ({ document, source }) => {
+	let parsed;
+	try {
+		parsed = parse(document);
+	} catch (error) {
+		throw compileError("PRESET_PARSE_ERROR", {
+			source,
+			message: `YAMLの解析に失敗しました: ${error.message}`,
+			details: { reason: error instanceof Error ? error.message : String(error) }
+		});
+	}
+	if (!isRecord(parsed)) throw compileError("PRESET_INVALID_DOCUMENT", {
+		source,
+		message: "プリセット定義がオブジェクトではありません",
+		path: "preset"
+	});
+	const name = typeof parsed.name === "string" && parsed.name.trim().length > 0 ? parsed.name : "Unnamed preset";
+	const layout = parseLayoutNode(parsed.layout, {
+		source,
+		path: "preset.layout"
+	});
+	return { preset: {
+		name,
+		version: "legacy",
+		command: typeof parsed.command === "string" ? parsed.command : void 0,
+		layout: layout ?? void 0,
+		metadata: { source }
+	} };
+};
+const parseLayoutNode = (node, context) => {
+	if (node === void 0 || node === null) return null;
+	if (!isRecord(node)) throw compileError("LAYOUT_INVALID_NODE", {
+		source: context.source,
+		message: "レイアウトノードの形式が不正です",
+		path: context.path,
+		details: { node }
+	});
+	if (typeof node.type === "string" && Array.isArray(node.panes)) return parseSplitPane(node, context);
+	if (typeof node.name === "string") return parseTerminalPane(node);
+	throw compileError("LAYOUT_INVALID_NODE", {
+		source: context.source,
+		message: "レイアウトノードの形式が不正です",
+		path: context.path,
+		details: { node }
+	});
+};
+const parseSplitPane = (node, context) => {
+	const orientation = node.type;
+	if (orientation !== "horizontal" && orientation !== "vertical") throw compileError("LAYOUT_INVALID_ORIENTATION", {
+		source: context.source,
+		message: "layout.type は horizontal か vertical である必要があります",
+		path: `${context.path}.type`,
+		details: { type: orientation }
+	});
+	if (!Array.isArray(node.panes) || node.panes.length === 0) throw compileError("LAYOUT_PANES_MISSING", {
+		source: context.source,
+		message: "panes 配列が存在しません",
+		path: `${context.path}.panes`
+	});
+	if (!Array.isArray(node.ratio) || node.ratio.length === 0) throw compileError("LAYOUT_RATIO_MISSING", {
+		source: context.source,
+		message: "ratio 配列が存在しません",
+		path: `${context.path}.ratio`
+	});
+	if (node.ratio.length !== node.panes.length) throw compileError("LAYOUT_RATIO_MISMATCH", {
+		source: context.source,
+		message: "ratio 配列と panes 配列の長さが一致しません",
+		path: context.path,
+		details: {
+			ratioLength: node.ratio.length,
+			panesLength: node.panes.length
+		}
+	});
+	const ratio = node.ratio.map((value, index) => {
+		if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) throw compileError("RATIO_INVALID_VALUE", {
+			source: context.source,
+			message: "ratio の値が正の数値ではありません",
+			path: `${context.path}.ratio[${index}]`,
+			details: { value }
+		});
+		return value;
+	});
+	const panes = node.panes.map((child, index) => parseLayoutNode(child, {
+		source: context.source,
+		path: `${context.path}.panes[${index}]`
+	}));
+	return {
+		kind: "split",
+		orientation,
+		ratio,
+		panes: panes.filter((pane) => pane !== null)
+	};
+};
+const parseTerminalPane = (node) => {
+	const name = typeof node.name === "string" ? node.name : "";
+	const command = typeof node.command === "string" ? node.command : void 0;
+	const cwd = typeof node.cwd === "string" ? node.cwd : void 0;
+	const focus = node.focus === true ? true : void 0;
+	const env = normalizeEnv(node.env);
+	const options = collectOptions(node, new Set([
+		"name",
+		"command",
+		"cwd",
+		"env",
+		"focus",
+		"options",
+		"title",
+		"delay"
+	]));
+	return {
+		kind: "terminal",
+		name,
+		command,
+		cwd,
+		env,
+		focus,
+		options
+	};
+};
+const normalizeEnv = (env) => {
+	if (!isRecord(env)) return;
+	const entries = Object.entries(env).reduce((accumulator, [key, value]) => {
+		if (typeof value === "string") accumulator[key] = value;
+		return accumulator;
+	}, {});
+	return Object.keys(entries).length > 0 ? entries : void 0;
+};
+const collectOptions = (node, excludedKeys) => {
+	const optionsEntries = Object.entries(node).filter(([key]) => !excludedKeys.has(key));
+	if (optionsEntries.length === 0) return;
+	return optionsEntries.reduce((accumulator, [key, value]) => {
+		accumulator[key] = value;
+		return accumulator;
+	}, {});
+};
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null;
+};
+const compileError = (code, error) => {
+	return createFunctionalError("compile", {
+		code,
+		message: error.message,
+		source: error.source,
+		path: error.path,
+		details: error.details
+	});
+};
+
+//#endregion
+//#region src/core/planner.ts
+const createLayoutPlan = ({ preset }) => {
+	if (!preset.layout) {
+		const terminal = createTerminalNode({
+			id: "root",
+			terminal: {
+				kind: "terminal",
+				name: preset.name,
+				command: preset.command
+			},
+			focusOverride: true
+		});
+		return { plan: {
+			root: terminal,
+			focusPaneId: terminal.id
+		} };
+	}
+	const { node, focusPaneIds, terminalPaneIds } = buildLayoutNode(preset.layout, {
+		parentId: "root",
+		path: "preset.layout",
+		source: preset.metadata.source
+	});
+	if (focusPaneIds.length > 1) throw planError("FOCUS_CONFLICT", {
+		message: "複数のペインでfocusが指定されています",
+		path: "preset.layout",
+		source: preset.metadata.source,
+		details: { focusPaneIds }
+	});
+	if (terminalPaneIds.length === 0) throw planError("NO_TERMINAL_PANES", {
+		message: "ターミナルペインが存在しません",
+		path: "preset.layout",
+		source: preset.metadata.source
+	});
+	const focusPaneId = focusPaneIds[0] ?? terminalPaneIds[0];
+	return { plan: {
+		root: ensureFocus(node, focusPaneId),
+		focusPaneId
+	} };
+};
+const buildLayoutNode = (node, context) => {
+	if (node.kind === "split") return buildSplitNode(node, context);
+	return {
+		node: createTerminalNode({
+			id: context.parentId,
+			terminal: node
+		}),
+		focusPaneIds: node.focus === true ? [context.parentId] : [],
+		terminalPaneIds: [context.parentId]
+	};
+};
+const buildSplitNode = (node, context) => {
+	const ratio = normalizeRatio(node.ratio, context);
+	const panes = [];
+	const focusPaneIds = [];
+	const terminalPaneIds = [];
+	for (let index = 0; index < node.panes.length; index += 1) {
+		const childContext = {
+			parentId: `${context.parentId}.${index}`,
+			path: `${context.path}.panes[${index}]`,
+			source: context.source
+		};
+		const childResult = buildLayoutNode(node.panes[index], childContext);
+		panes.push(childResult.node);
+		focusPaneIds.push(...childResult.focusPaneIds);
+		terminalPaneIds.push(...childResult.terminalPaneIds);
+	}
+	return {
+		node: {
+			kind: "split",
+			id: context.parentId,
+			orientation: node.orientation,
+			ratio,
+			panes
+		},
+		focusPaneIds,
+		terminalPaneIds
+	};
+};
+const createTerminalNode = ({ id, terminal, focusOverride }) => {
+	return {
+		kind: "terminal",
+		id,
+		name: terminal.name,
+		command: terminal.command,
+		cwd: terminal.cwd,
+		env: terminal.env,
+		options: terminal.options,
+		focus: focusOverride === true ? true : terminal.focus === true
+	};
+};
+const ensureFocus = (node, focusPaneId) => {
+	if (node.kind === "terminal") return {
+		...node,
+		focus: node.id === focusPaneId
+	};
+	return {
+		...node,
+		panes: node.panes.map((pane) => ensureFocus(pane, focusPaneId))
+	};
+};
+const normalizeRatio = (ratio, context) => {
+	const total = ratio.reduce((sum, value, index) => {
+		if (typeof value !== "number" || !Number.isFinite(value) || value < 0) throw planError("RATIO_INVALID_VALUE", {
+			message: "ratio の値が非負の数値ではありません",
+			path: `${context.path}.ratio[${index}]`,
+			source: context.source,
+			details: { value }
+		});
+		return sum + value;
+	}, 0);
+	if (total === 0) return ratio.map(() => 1 / ratio.length);
+	return ratio.map((value) => value / total);
+};
+const planError = (code, error) => {
+	return createFunctionalError("plan", {
+		code,
+		message: error.message,
+		source: error.source,
+		path: error.path,
+		details: error.details
+	});
+};
+
+//#endregion
+//#region src/core/emitter.ts
+const emitPlan = ({ plan }) => {
+	const steps = [];
+	collectSplitSteps(plan.root, steps);
+	steps.push({
+		id: `${plan.focusPaneId}:focus`,
+		kind: "focus",
+		command: [
+			"select-pane",
+			"-t",
+			plan.focusPaneId
+		],
+		summary: `select pane ${plan.focusPaneId}`,
+		targetPaneId: plan.focusPaneId
+	});
+	const hash = createPlanHash(plan, steps);
+	const initialPaneId = determineInitialPaneId(plan.root);
+	const terminals = collectTerminals(plan.root);
+	return {
+		steps,
+		summary: {
+			stepsCount: steps.length,
+			focusPaneId: plan.focusPaneId,
+			initialPaneId
+		},
+		terminals,
+		hash
+	};
+};
+const collectSplitSteps = (node, steps) => {
+	if (node.kind === "terminal") return;
+	appendSplitSteps(node, steps);
+	node.panes.forEach((pane) => collectSplitSteps(pane, steps));
+};
+const appendSplitSteps = (node, steps) => {
+	const directionFlag = node.orientation === "horizontal" ? "-h" : "-v";
+	for (let index = 1; index < node.panes.length; index += 1) {
+		const remainingIncludingTarget = node.ratio.slice(index - 1).reduce((sum, value) => sum + value, 0);
+		const remainingAfterTarget = node.ratio.slice(index).reduce((sum, value) => sum + value, 0);
+		const desiredPercentage = remainingIncludingTarget === 0 ? 0 : remainingAfterTarget / remainingIncludingTarget * 100;
+		const percentage = Math.max(1, Math.round(desiredPercentage));
+		const targetPaneId = node.panes[index - 1]?.id ?? node.id;
+		const createdPaneId = node.panes[index]?.id;
+		steps.push({
+			id: `${node.id}:split:${index}`,
+			kind: "split",
+			command: [
+				"split-window",
+				directionFlag,
+				"-t",
+				targetPaneId,
+				"-p",
+				String(Math.min(percentage, 99))
+			],
+			summary: `split ${targetPaneId} (${directionFlag})`,
+			targetPaneId,
+			createdPaneId
+		});
+	}
+};
+const collectTerminals = (node) => {
+	if (node.kind === "terminal") return [{
+		virtualPaneId: node.id,
+		command: node.command,
+		cwd: node.cwd,
+		env: node.env,
+		focus: node.focus,
+		name: node.name
+	}];
+	return node.panes.flatMap((pane) => collectTerminals(pane));
+};
+const determineInitialPaneId = (node) => {
+	if (node.kind === "terminal") return node.id;
+	let current = node;
+	while (current.kind === "split") current = current.panes[0];
+	return current.id;
+};
+const createPlanHash = (plan, steps) => {
+	const digest = createHash("sha256");
+	const normalized = {
+		focusPaneId: plan.focusPaneId,
+		root: plan.root,
+		steps
+	};
+	digest.update(JSON.stringify(normalized));
+	return digest.digest("hex");
+};
+
+//#endregion
+//#region src/cli.ts
+const KNOWN_ISSUES = [
+	"LayoutEngineがtmux依存とI/Oを同一クラスで扱っている",
+	"dry-run実行と本番適用でPlan構造が共有されていない",
+	"Loggerが境界層とFunctional Coreの責務を混在させている"
+];
+const formatSeverityTag = (severity) => {
+	switch (severity) {
+		case "high": return chalk.red("[HIGH]");
+		case "medium": return chalk.yellow("[MEDIUM]");
+		case "low":
+		default: return chalk.blue("[LOW]");
+	}
+};
+const createCli = (options = {}) => {
+	const presetManager = options.presetManager ?? createPresetManager();
+	const createCommandExecutor = options.createCommandExecutor ?? ((opts) => {
+		if (opts.dryRun) return createDryRunExecutor({ verbose: opts.verbose });
+		return createRealExecutor({ verbose: opts.verbose });
+	});
+	const functionalCore = options.functionalCore ?? {
+		compilePreset,
+		createLayoutPlan,
+		emitPlan
+	};
+	const program = new Command();
+	const { version } = createRequire(import.meta.url)("../package.json");
+	let logger = createLogger();
+	const renderDiagnosticsReport = (report) => {
+		console.log(chalk.bold("\nFunctional Core Diagnostics\n"));
+		if (report.backlog.length > 0) {
+			console.log(chalk.bold("改善バックログ"));
+			report.backlog.forEach((item, index) => {
+				const prefix = `${index + 1}. ${formatSeverityTag(item.severity)}`;
+				console.log(`${prefix} ${item.summary}`);
+				item.actions.forEach((action) => {
+					console.log(`   - ${action}`);
+				});
+			});
+			console.log("");
+		}
+		if (report.findings.length > 0) {
+			console.log(chalk.bold("診断結果"));
+			report.findings.forEach((finding) => {
+				console.log(`${formatSeverityTag(finding.severity)} ${finding.path} :: ${finding.description}`);
+			});
+			console.log("");
+		}
+		if (report.nextSteps.length > 0) {
+			console.log(chalk.bold("次のアクション"));
+			report.nextSteps.forEach((step) => {
+				console.log(` - ${step}`);
+			});
+			console.log("");
+		}
+	};
+	const renderDryRun = (emission) => {
+		console.log(chalk.bold("\nPlanned tmux steps (dry-run)"));
+		emission.steps.forEach((step, index) => {
+			const commandString = step.command.join(" ");
+			console.log(` ${index + 1}. ${step.summary}: tmux ${commandString}`);
+		});
+	};
+	const buildPresetDocument = (preset, presetName) => {
+		const document = {
+			name: preset.name ?? presetName ?? "vde-layout",
+			command: preset.command,
+			layout: preset.layout
+		};
+		if (typeof preset.command !== "string" || preset.command.length === 0) delete document.command;
+		if (preset.layout === void 0 || preset.layout === null) delete document.layout;
+		return stringify(document);
+	};
+	const buildPresetSource = (presetName) => {
+		return typeof presetName === "string" && presetName.length > 0 ? `preset://${presetName}` : "preset://default";
+	};
+	const handleFunctionalError = (error) => {
+		const header = [`[${error.kind}]`, `[${error.code}]`];
+		if (typeof error.path === "string" && error.path.length > 0) header.push(`[${error.path}]`);
+		const lines = [`${header.join(" ")} ${error.message}`.trim()];
+		if (typeof error.source === "string" && error.source.length > 0) lines.push(`source: ${error.source}`);
+		const commandDetail = error.details?.command;
+		if (Array.isArray(commandDetail)) {
+			const tmuxCommand = commandDetail.filter((segment) => typeof segment === "string");
+			if (tmuxCommand.length > 0) lines.push(`command: tmux ${tmuxCommand.join(" ")}`);
+		} else if (typeof commandDetail === "string" && commandDetail.length > 0) lines.push(`command: ${commandDetail}`);
+		const stderrDetail = error.details?.stderr;
+		if (typeof stderrDetail === "string" && stderrDetail.length > 0) lines.push(`stderr: ${stderrDetail}`);
+		else if (stderrDetail !== void 0) lines.push(`stderr: ${String(stderrDetail)}`);
+		logger.error(lines.join("\n"));
+		process.exit(1);
+	};
+	const handleError = (error) => {
+		if (error instanceof Error) logger.error(error.message, error);
+		else logger.error("An unexpected error occurred");
+		process.exit(1);
+	};
+	const handlePipelineFailure = (error) => {
+		if (isFunctionalCoreError(error)) return handleFunctionalError(error);
+		return handleError(error);
+	};
+	const listPresets = async () => {
+		try {
+			await presetManager.loadConfig();
+			const presets = presetManager.listPresets();
+			if (presets.length === 0) {
+				logger.warn("No presets defined");
+				process.exit(0);
+			}
+			console.log(chalk.bold("Available presets:\n"));
+			const maxKeyLength = Math.max(...presets.map((p) => p.key.length));
+			presets.forEach((preset) => {
+				const paddedKey = preset.key.padEnd(maxKeyLength + 2);
+				const description = preset.description ?? "";
+				console.log(`  ${chalk.cyan(paddedKey)} ${description}`);
+			});
+			process.exit(0);
+		} catch (error) {
+			return handleError(error);
+		}
+	};
+	const diagnosePreset = async (presetName) => {
+		try {
+			await presetManager.loadConfig();
+			const preset = typeof presetName === "string" && presetName.length > 0 ? presetManager.getPreset(presetName) : presetManager.getDefaultPreset();
+			const presetDocument = stringify(preset ?? {});
+			const report = runDiagnostics({
+				presetDocument,
+				knownIssues: KNOWN_ISSUES
+			});
+			renderDiagnosticsReport(report);
+			process.exit(0);
+		} catch (error) {
+			return handleError(error);
+		}
+	};
+	const executePreset = async (presetName, options$1) => {
+		try {
+			await presetManager.loadConfig();
+			const preset = typeof presetName === "string" && presetName.length > 0 ? presetManager.getPreset(presetName) : presetManager.getDefaultPreset();
+			const tmuxEnv = process.env.TMUX;
+			if (!(typeof tmuxEnv === "string" && tmuxEnv.length > 0) && options$1.dryRun !== true) throw new Error("Must be run inside a tmux session");
+			const executor = createCommandExecutor({
+				verbose: options$1.verbose,
+				dryRun: options$1.dryRun
+			});
+			if (options$1.dryRun === true) console.log("[DRY RUN] No actual commands will be executed");
+			let compileResult;
+			let planResult;
+			let emission;
+			try {
+				compileResult = functionalCore.compilePreset({
+					document: buildPresetDocument(preset, presetName),
+					source: buildPresetSource(presetName)
+				});
+				planResult = functionalCore.createLayoutPlan({ preset: compileResult.preset });
+				emission = functionalCore.emitPlan({ plan: planResult.plan });
+			} catch (error) {
+				return handlePipelineFailure(error);
+			}
+			if (options$1.dryRun === true) renderDryRun(emission);
+			else try {
+				const executionResult = await executePlan({
+					emission,
+					executor,
+					windowName: preset.name ?? presetName ?? "vde-layout"
+				});
+				logger.info(`Executed ${executionResult.executedSteps} tmux steps`);
+			} catch (error) {
+				return handlePipelineFailure(error);
+			}
+			logger.success(`✓ Applied preset "${preset.name}"`);
+			process.exit(0);
+		} catch (error) {
+			return handleError(error);
+		}
+	};
+	const setupProgram = () => {
+		program.name("vde-layout").description("VDE (Vibrant Development Environment) Layout Manager - tmux pane layout management tool").version(version, "-V, --version", "Show version").helpOption("-h, --help", "Show help");
+		program.option("-v, --verbose", "Show detailed logs", false);
+		program.option("--dry-run", "Display commands without executing", false);
+		program.option("--config <path>", "Path to configuration file");
+		program.command("list").description("List available presets").action(async () => {
+			await listPresets();
+		});
+		program.command("diagnose").description("Functional Coreリライトに向けた診断レポートを表示する").argument("[preset]", "Preset name (defaults to \"default\" preset when omitted)").action(async (presetName) => {
+			await diagnosePreset(presetName);
+		});
+		program.argument("[preset]", "Preset name (defaults to \"default\" preset when omitted)").action(async (presetName) => {
+			const opts = program.opts();
+			await executePreset(presetName, {
+				verbose: opts.verbose === true,
+				dryRun: opts.dryRun === true
+			});
+		});
+	};
+	setupProgram();
+	const run = async (args = process.argv.slice(2)) => {
+		const requestedVersion = args.includes("--version") || args.includes("-V");
+		const requestedHelp = args.includes("--help") || args.includes("-h");
+		try {
+			await program.parseAsync(args, { from: "user" });
+			const opts = program.opts();
+			if (requestedVersion || requestedHelp) return;
+			if (opts.verbose === true) logger = createLogger({ level: LogLevel.INFO });
+			else logger = createLogger();
+			if (typeof opts.config === "string" && opts.config.length > 0 && typeof presetManager.setConfigPath === "function") presetManager.setConfigPath(opts.config);
+		} catch (error) {
+			if (error instanceof Error && error.message.includes("Process exited")) throw error;
+			handleError(error);
+		}
+	};
+	return { run };
+};
+
+//#endregion
+//#region src/index.ts
+/**
+* Main entry point
+* Launches the CLI application
+*/
+const main = async () => {
+	const cli = createCli();
+	try {
+		await cli.run(process.argv.slice(2));
+	} catch (error) {
+		if (error instanceof Error) {
+			console.error("Error:", error.message);
+			if (process.env.VDE_DEBUG === "true") console.error(error.stack);
+		} else console.error("An unexpected error occurred:", String(error));
+		process.exit(1);
+	}
+};
+main();
+
+//#endregion
+export {  };
 //# sourceMappingURL=index.js.map