vde-layout/dist/cli.js

Terminal multiplexer layout management tool for VDE (Vibe Coding Development Environment)

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.CLI = void 0;
const commander_1 = require("commander");
const chalk_1 = __importDefault(require("chalk"));
const preset_1 = require("./layout/preset");
const engine_1 = require("./layout/engine");
const package_json_1 = require("../package.json");
const executor_1 = require("./executor");
const logger_1 = require("./utils/logger");
class CLI {
    program;
    presetManager;
    createLayoutEngine;
    createCommandExecutor;
    logger;
    constructor(options = {}) {
        this.program = new commander_1.Command();
        this.presetManager = options.presetManager || new preset_1.PresetManager();
        this.createLayoutEngine = options.createLayoutEngine || ((opts) => new engine_1.LayoutEngine(opts));
        this.createCommandExecutor =
            options.createCommandExecutor ||
                ((opts) => {
                    if (opts.dryRun) {
                        return new executor_1.DryRunExecutor({ verbose: opts.verbose });
                    }
                    return new executor_1.RealExecutor({ verbose: opts.verbose });
                });
        this.logger = new logger_1.Logger();
        this.setupCommands();
    }
    setupCommands() {
        this.program
            .name("vde-layout")
            .description("VDE (Vibrant Development Environment) Layout Manager - tmux pane layout management tool")
            .version(package_json_1.version, "-V, --version", "Show version")
            .helpOption("-h, --help", "Show help");
        this.program
            .option("-v, --verbose", "Show detailed logs", false)
            .option("--dry-run", "Display commands without executing", false);
        this.program
            .command("list")
            .description("List available presets")
            .action(async () => {
            await this.listPresets();
        });
        this.program
            .argument("[preset]", 'Preset name (defaults to "default" preset when omitted)')
            .action(async (presetName) => {
            const options = this.program.opts();
            await this.executePreset(presetName, {
                verbose: options.verbose,
                dryRun: options.dryRun,
            });
        });
    }
    async run(args = process.argv.slice(2)) {
        try {
            await this.program.parseAsync(args, { from: "user" });
            const opts = this.program.opts();
            if (opts.verbose === true) {
                this.logger = new logger_1.Logger({ level: logger_1.LogLevel.INFO });
            }
        }
        catch (error) {
            if (error instanceof Error && error.message.includes("Process exited")) {
                throw error;
            }
            this.handleError(error);
        }
    }
    async listPresets() {
        try {
            await this.presetManager.loadConfig();
            const presets = this.presetManager.listPresets();
            if (presets.length === 0) {
                this.logger.warn("No presets defined");
                process.exit(0);
            }
            console.log(chalk_1.default.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_1.default.cyan(paddedKey)} ${description}`);
            });
            process.exit(0);
        }
        catch (error) {
            this.handleError(error);
        }
    }
    async executePreset(presetName, options) {
        try {
            await this.presetManager.loadConfig();
            const preset = presetName !== undefined && presetName.length > 0
                ? this.presetManager.getPreset(presetName)
                : this.presetManager.getDefaultPreset();
            const forceDryRun = process.env.TMUX === undefined;
            const effectiveDryRun = options.dryRun || forceDryRun;
            const executor = this.createCommandExecutor({
                verbose: options.verbose,
                dryRun: effectiveDryRun,
            });
            const engine = this.createLayoutEngine({
                verbose: options.verbose,
                dryRun: effectiveDryRun,
                executor,
            });
            if (effectiveDryRun) {
                this.logger.warn("[DRY RUN] No actual commands will be executed");
                if (forceDryRun && !options.dryRun) {
                    this.logger.warn("(Automatically enabled because not in tmux session)");
                }
            }
            await engine.createLayout(preset);
            this.logger.success(`✓ Applied preset "${preset.name}"`);
            process.exit(0);
        }
        catch (error) {
            this.handleError(error);
        }
    }
    handleError(error) {
        if (error instanceof Error) {
            this.logger.error(error.message, error);
        }
        else {
            this.logger.error("An unexpected error occurred");
        }
        process.exit(1);
    }
}
exports.CLI = CLI;
//# sourceMappingURL=cli.js.map