@mbluemer_2/gittyup 0.1.2

package/dist/output.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printProjects = printProjects;
+exports.printProjectDiagnostics = printProjectDiagnostics;
+exports.printProjectInit = printProjectInit;
+exports.printWorktrees = printWorktrees;
+exports.printStatuses = printStatuses;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+function getTerminalWidth() {
+    return process.stdout.columns ?? 100;
+}
+function truncate(value, width) {
+    if (value.length <= width) {
+        return value;
+    }
+    if (width <= 1) {
+        return value.slice(0, width);
+    }
+    return `${value.slice(0, width - 1)}…`;
+}
+function buildColumnWidths(headers, rows, maxWidths) {
+    const gapWidth = 2;
+    const terminalWidth = getTerminalWidth();
+    const widths = headers.map((header, index) => {
+        const longestValue = Math.max(header.length, ...rows.map((row) => row[index]?.length ?? 0));
+        return Math.min(longestValue, maxWidths[index] ?? longestValue);
+    });
+    const usedWidth = widths.reduce((sum, width) => sum + width, 0) +
+        gapWidth * (headers.length - 1);
+    if (usedWidth <= terminalWidth) {
+        return widths;
+    }
+    const overflow = usedWidth - terminalWidth;
+    const lastColumn = widths.length - 1;
+    widths[lastColumn] = Math.max(headers[lastColumn]?.length ?? 4, widths[lastColumn] - overflow);
+    return widths;
+}
+function createTable(headers, colWidths) {
+    return new cli_table3_1.default({
+        head: headers,
+        colWidths,
+        wordWrap: true,
+        style: {
+            head: [],
+            border: [],
+            compact: true,
+            'padding-left': 0,
+            'padding-right': 0,
+        },
+        chars: {
+            top: '',
+            'top-mid': '',
+            'top-left': '',
+            'top-right': '',
+            bottom: '',
+            'bottom-mid': '',
+            'bottom-left': '',
+            'bottom-right': '',
+            left: '',
+            'left-mid': '',
+            mid: '',
+            'mid-mid': '',
+            right: '',
+            'right-mid': '',
+            middle: '  ',
+        },
+    });
+}
+function renderTable(headers, rows, maxWidths, detailLabel, formatRow) {
+    const mainHeaders = headers.slice(0, -1);
+    const mainRows = rows.map((row) => row.slice(0, -1));
+    const colWidths = buildColumnWidths(mainHeaders, mainRows, maxWidths);
+    const headerTable = createTable(mainHeaders, colWidths);
+    const divider = '-'.repeat(Math.min(getTerminalWidth(), colWidths.reduce((sum, width) => sum + width, 0) +
+        2 * (colWidths.length - 1)));
+    console.log(headerTable.toString());
+    console.log(divider);
+    for (const row of rows) {
+        const rowTable = createTable(undefined, colWidths);
+        const formattedRow = formatRow ? formatRow(row, colWidths) : row;
+        const detail = row[row.length - 1] ?? '';
+        rowTable.push(formattedRow.slice(0, -1));
+        console.log(rowTable.toString());
+        console.log(`  ${detailLabel}: ${detail}`);
+        console.log('');
+        console.log(divider);
+    }
+}
+function formatProjectRow(row, widths) {
+    return [
+        truncate(row[0] ?? '', widths[0] ?? 20),
+        truncate(row[1] ?? '', widths[1] ?? 16),
+        row[2] ?? 'no',
+        row[3] ?? '0',
+        row[4] ?? '',
+    ];
+}
+function formatWorktreeRow(row, widths) {
+    return [
+        truncate(row[0] ?? '', widths[0] ?? 18),
+        truncate(row[1] ?? '', widths[1] ?? 18),
+        truncate(row[2] ?? '', widths[2] ?? 18),
+        row[3] ?? 'no',
+        row[4] ?? 'no',
+        row[5] ?? '',
+    ];
+}
+function formatStatusRow(row, widths) {
+    return [
+        truncate(row[0] ?? '', widths[0] ?? 18),
+        truncate(row[1] ?? '', widths[1] ?? 18),
+        truncate(row[2] ?? '', widths[2] ?? 18),
+        row[3] ?? '-',
+        row[4] ?? '0',
+        row[5] ?? '-',
+        row[6] ?? '',
+    ];
+}
+function printProjects(projects, asJson) {
+    if (asJson) {
+        printJson(projects);
+        return;
+    }
+    if (projects.length === 0) {
+        console.log('No projects found.');
+        return;
+    }
+    renderTable(['project', 'branch', 'commits', 'worktrees', 'path'], projects.map((project) => [
+        project.name,
+        project.defaultBranch ?? '-',
+        project.hasCommits ? 'yes' : 'no',
+        String(project.worktreeCount),
+        project.rootPath,
+    ]), [20, 16, 7, 10], 'path', formatProjectRow);
+}
+function printProjectDiagnostics(diagnostics, asJson) {
+    if (asJson) {
+        printJson(diagnostics);
+        return;
+    }
+    if (diagnostics.length === 0) {
+        console.log('No projects found.');
+        return;
+    }
+    renderTable(['project', 'status', 'branch', 'worktrees', 'details'], diagnostics.map((entry) => {
+        if ('gitDir' in entry) {
+            return [
+                entry.name,
+                'ok',
+                entry.defaultBranch ?? '-',
+                String(entry.worktreeCount),
+                entry.rootPath,
+            ];
+        }
+        return [entry.name, 'broken', '-', '-', entry.error ?? entry.rootPath];
+    }), [20, 8, 16, 10], 'details', formatProjectRow);
+}
+function printProjectInit(init, asJson) {
+    if (asJson) {
+        printJson(init);
+        return;
+    }
+    if (init.initCommand) {
+        console.log(init.initCommand);
+        return;
+    }
+    console.log(`No init command configured for project '${init.project}'.`);
+}
+function printWorktrees(worktrees, asJson) {
+    if (asJson) {
+        printJson(worktrees);
+        return;
+    }
+    if (worktrees.length === 0) {
+        console.log('No linked worktrees found.');
+        return;
+    }
+    renderTable(['project', 'alias', 'branch', 'locked', 'prunable', 'path'], worktrees.map((worktree) => [
+        worktree.project,
+        worktree.alias,
+        worktree.branch ?? 'detached',
+        worktree.locked ? 'yes' : 'no',
+        worktree.prunable ? 'yes' : 'no',
+        worktree.path,
+    ]), [18, 18, 18, 6, 8], 'path', formatWorktreeRow);
+}
+function printStatuses(statuses, asJson) {
+    if (asJson) {
+        printJson(statuses);
+        return;
+    }
+    if (statuses.length === 0) {
+        console.log('No linked worktrees found.');
+        return;
+    }
+    renderTable(['project', 'alias', 'branch', 'state', 'changes', 'head', 'path'], statuses.map((status) => [
+        status.project,
+        status.alias,
+        status.branch ?? 'detached',
+        status.state,
+        String(status.changes),
+        status.head?.slice(0, 8) ?? '-',
+        status.path,
+    ]), [18, 18, 18, 7, 7, 8], 'path', formatStatusRow);
+}

package/dist/process.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runShellCommand = runShellCommand;
+exports.runCommand = runCommand;
+const node_child_process_1 = require("node:child_process");
+const errors_1 = require("./errors");
+function runShellCommand(command, options = {}) {
+    const shell = process.env.SHELL ?? 'sh';
+    return runCommand(shell, ['-lc', command], options);
+}
+function runCommand(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(command, args, {
+            cwd: options.cwd,
+            env: {
+                ...process.env,
+                ...options.env,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            reject(new errors_1.CliError(`Failed to run ${command}: ${error.message}`));
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                resolve(stdout.trimEnd());
+                return;
+            }
+            const message = stderr.trim() ||
+                `${command} ${args.join(' ')} failed with exit code ${code}`;
+            reject(new errors_1.CliError(message));
+        });
+        if (options.stdin) {
+            child.stdin.write(options.stdin);
+        }
+        child.stdin.end();
+    });
+}

package/dist/program.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgram = createProgram;
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const aliases_1 = require("./aliases");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+const git_1 = require("./git");
+const interactive_1 = require("./interactive");
+const projects_1 = require("./projects");
+const output_1 = require("./output");
+const tmux_1 = require("./tmux");
+const defaultServices = {
+    resolveRootDir: config_1.resolveRootDir,
+    checkGitAvailable: git_1.checkGitAvailable,
+    discoverProjects: projects_1.discoverProjects,
+    diagnoseProjects: projects_1.diagnoseProjects,
+    createProject: projects_1.createProject,
+    cloneProject: projects_1.cloneProject,
+    importProject: projects_1.importProject,
+    renameProject: projects_1.renameProject,
+    getProjectInit: projects_1.getProjectInit,
+    configureProjectInit: projects_1.configureProjectInit,
+    clearConfiguredProjectInit: projects_1.clearConfiguredProjectInit,
+    listProjectWorktrees: projects_1.listProjectWorktrees,
+    addProjectWorktree: projects_1.addProjectWorktree,
+    removeProjectWorktree: projects_1.removeProjectWorktree,
+    getProjectStatuses: projects_1.getProjectStatuses,
+    getProjectWorktree: projects_1.getProjectWorktree,
+    resolveWorktreeAddInput: interactive_1.resolveWorktreeAddInput,
+    resolveWorktreeRemoveInput: interactive_1.resolveWorktreeRemoveInput,
+    resolveTmuxLaunchInput: interactive_1.resolveTmuxLaunchInput,
+    printProjects: output_1.printProjects,
+    printProjectDiagnostics: output_1.printProjectDiagnostics,
+    printProjectInit: output_1.printProjectInit,
+    printWorktrees: output_1.printWorktrees,
+    printStatuses: output_1.printStatuses,
+    buildTmuxSessionName: tmux_1.buildTmuxSessionName,
+    checkTmuxAvailable: tmux_1.checkTmuxAvailable,
+    checkFzfAvailable: tmux_1.checkFzfAvailable,
+    launchTmuxSession: tmux_1.launchTmuxSession,
+    pickTmuxSession: tmux_1.pickTmuxSession,
+    stdout: console,
+    stderr: console,
+    cwd: () => process.cwd(),
+};
+function createServices(overrides = {}) {
+    return { ...defaultServices, ...overrides };
+}
+function createProgram(overrides = {}) {
+    const services = createServices(overrides);
+    const program = new commander_1.Command();
+    function requireGit(command) {
+        return command.hook('preAction', async () => {
+            await services.checkGitAvailable();
+        });
+    }
+    function getContext(command) {
+        const options = command.optsWithGlobals();
+        return {
+            rootDir: services.resolveRootDir(options.root),
+            json: Boolean(options.json),
+        };
+    }
+    async function runAction(action) {
+        try {
+            await action();
+        }
+        catch (error) {
+            services.stderr.error((0, errors_1.toErrorMessage)(error));
+            process.exitCode = error instanceof errors_1.CliError ? error.exitCode : 1;
+        }
+    }
+    program
+        .name('gittyup')
+        .description('Manage bare git projects and linked worktrees')
+        .version('0.0.1')
+        .showHelpAfterError()
+        .showSuggestionAfterError()
+        .option('--root <path>', 'root directory containing project folders', '~/src')
+        .option('--json', 'emit machine-readable JSON');
+    const projectCommand = program
+        .command('project')
+        .alias('p')
+        .description('Manage project roots');
+    const projectListCommand = requireGit(projectCommand
+        .command('list')
+        .description('List discovered projects under the root directory'));
+    projectListCommand.action(() => runAction(async () => {
+        const context = getContext(projectListCommand);
+        const projects = await services.discoverProjects(context.rootDir);
+        services.printProjects(projects, context.json);
+    }));
+    const projectDoctorCommand = requireGit(projectCommand
+        .command('doctor')
+        .description('Inspect managed project folders and surface broken entries'));
+    projectDoctorCommand.action(() => runAction(async () => {
+        const context = getContext(projectDoctorCommand);
+        const diagnostics = await services.diagnoseProjects(context.rootDir);
+        services.printProjectDiagnostics(diagnostics, context.json);
+    }));
+    const projectCreateCommand = requireGit(projectCommand
+        .command('create')
+        .description('Create a new local bare repository project')
+        .argument('<name>', 'project directory name'));
+    projectCreateCommand.action((name) => runAction(async () => {
+        const context = getContext(projectCreateCommand);
+        const project = await services.createProject(context.rootDir, name);
+        services.printProjects([project], context.json);
+    }));
+    const projectInitCommand = requireGit(projectCommand
+        .command('init')
+        .description('Manage the command run after new worktree creation'));
+    const projectInitGetCommand = projectInitCommand
+        .command('get')
+        .description('Show the configured init command for a project')
+        .argument('<project>', 'managed project name');
+    projectInitGetCommand.action((projectName) => runAction(async () => {
+        const context = getContext(projectInitGetCommand);
+        const init = await services.getProjectInit(context.rootDir, projectName);
+        services.printProjectInit(init, context.json);
+    }));
+    const projectInitSetCommand = projectInitCommand
+        .command('set')
+        .description('Set the init command run after new worktree creation')
+        .argument('<project>', 'managed project name')
+        .argument('<command>', 'shell command to run inside new worktrees');
+    projectInitSetCommand.action((projectName, command) => runAction(async () => {
+        const context = getContext(projectInitSetCommand);
+        const init = await services.configureProjectInit(context.rootDir, projectName, command);
+        services.printProjectInit(init, context.json);
+    }));
+    const projectInitClearCommand = projectInitCommand
+        .command('clear')
+        .description('Clear the configured init command for a project')
+        .argument('<project>', 'managed project name');
+    projectInitClearCommand.action((projectName) => runAction(async () => {
+        const context = getContext(projectInitClearCommand);
+        const init = await services.clearConfiguredProjectInit(context.rootDir, projectName);
+        services.printProjectInit(init, context.json);
+    }));
+    const projectCloneCommand = requireGit(projectCommand
+        .command('clone')
+        .description('Clone a remote into the bare-repo layout and create a main worktree')
+        .argument('<remote>', 'remote URL or path')
+        .argument('[name]', 'override the project directory name'));
+    projectCloneCommand.action((remote, name) => runAction(async () => {
+        const context = getContext(projectCloneCommand);
+        const project = await services.cloneProject(context.rootDir, remote, name);
+        services.printProjects([project], context.json);
+    }));
+    const projectImportCommand = requireGit(projectCommand
+        .command('import')
+        .description('Import an existing local git repo into the bare-repo layout in a new project directory')
+        .argument('<source>', 'path to an existing local git repository root')
+        .argument('[name]', 'override the managed project directory name'));
+    projectImportCommand.action((source, name) => runAction(async () => {
+        const context = getContext(projectImportCommand);
+        const project = await services.importProject(context.rootDir, source, name);
+        services.printProjects([project], context.json);
+    }));
+    const projectRenameCommand = requireGit(projectCommand
+        .command('rename')
+        .description('Rename a managed project directory and repair linked worktrees')
+        .argument('<project>', 'current managed project name')
+        .argument('<name>', 'new managed project name'));
+    projectRenameCommand.action((projectName, nextName) => runAction(async () => {
+        const context = getContext(projectRenameCommand);
+        const project = await services.renameProject(context.rootDir, projectName, nextName);
+        services.printProjects([project], context.json);
+    }));
+    const worktreeCommand = program
+        .command('worktree')
+        .alias('w')
+        .description('Manage linked worktrees');
+    const worktreeListCommand = requireGit(worktreeCommand
+        .command('list')
+        .description('List linked worktrees')
+        .argument('[project]', 'limit output to a single project'));
+    worktreeListCommand.action((projectName) => runAction(async () => {
+        const context = getContext(worktreeListCommand);
+        const worktrees = await services.listProjectWorktrees(context.rootDir, projectName);
+        services.printWorktrees(worktrees, context.json);
+    }));
+    const worktreeAddCommand = requireGit(worktreeCommand
+        .command('add')
+        .description('Create a linked worktree for a branch')
+        .argument('[project]', 'project name')
+        .argument('[branch]', 'branch name to check out or create')
+        .option('-a, --alias <alias>', 'friendly directory name for the worktree')
+        .option('--from <ref>', 'create a new branch from a specific start point')
+        .option('--tmux', 'launch or attach a tmux session for the new worktree'));
+    worktreeAddCommand.action((projectName, branch, options) => runAction(async () => {
+        const context = getContext(worktreeAddCommand);
+        const input = await services.resolveWorktreeAddInput({
+            rootDir: context.rootDir,
+            projectName,
+            branch,
+        });
+        const worktree = await services.addProjectWorktree(context.rootDir, input.projectName, input.branch, options.alias, options.from);
+        if (options.tmux) {
+            await services.checkTmuxAvailable();
+            if (context.json) {
+                services.printWorktrees([worktree], true);
+            }
+            await services.launchTmuxSession(services.buildTmuxSessionName(worktree.project, worktree.alias), worktree.path);
+            return;
+        }
+        services.printWorktrees([worktree], context.json);
+    }));
+    const worktreeRemoveCommand = requireGit(worktreeCommand
+        .command('remove')
+        .description('Remove a linked worktree by alias')
+        .argument('[project]', 'project name')
+        .argument('[alias]', 'worktree alias directory name')
+        .option('-f, --force', 'remove even if the worktree has local changes'));
+    worktreeRemoveCommand.action((projectName, alias, options) => runAction(async () => {
+        const context = getContext(worktreeRemoveCommand);
+        const input = await services.resolveWorktreeRemoveInput({
+            rootDir: context.rootDir,
+            projectName,
+            alias,
+        });
+        const removed = await services.removeProjectWorktree(context.rootDir, input.projectName, input.alias, Boolean(options.force));
+        if (context.json) {
+            services.printWorktrees([removed], true);
+            return;
+        }
+        services.stdout.log(`Removed worktree '${removed.alias}' from project '${removed.project}'.`);
+    }));
+    const statusCommand = requireGit(program
+        .command('status')
+        .alias('s')
+        .description('Show local status for linked worktrees')
+        .argument('[project]', 'limit output to a single project'));
+    statusCommand.action((projectName) => runAction(async () => {
+        const context = getContext(statusCommand);
+        const statuses = await services.getProjectStatuses(context.rootDir, projectName);
+        services.printStatuses(statuses, context.json);
+    }));
+    const tmuxCommand = program
+        .command('tmux')
+        .alias('t')
+        .description('Manage tmux sessions');
+    const tmuxLaunchCommand = requireGit(tmuxCommand
+        .command('launch')
+        .description('Launch or attach a tmux session for a worktree')
+        .argument('[project]', 'project name')
+        .argument('[worktree]', 'worktree alias directory name'));
+    tmuxLaunchCommand.action((projectName, worktreeAlias) => runAction(async () => {
+        const context = getContext(tmuxLaunchCommand);
+        await services.checkTmuxAvailable();
+        const input = await services.resolveTmuxLaunchInput({
+            rootDir: context.rootDir,
+            projectName,
+            alias: worktreeAlias,
+        });
+        const worktree = await services.getProjectWorktree(context.rootDir, input.projectName, input.alias);
+        const sessionName = services.buildTmuxSessionName(worktree.project, worktree.alias);
+        if (context.json) {
+            services.stdout.log(JSON.stringify({
+                session: sessionName,
+                project: worktree.project,
+                worktree: worktree.alias,
+                path: worktree.path,
+            }, null, 2));
+        }
+        await services.launchTmuxSession(sessionName, worktree.path);
+    }));
+    const tmuxSwitchCommand = tmuxCommand
+        .command('switch')
+        .description('Pick and switch to an open tmux session with fzf');
+    tmuxSwitchCommand.action(() => runAction(async () => {
+        const context = getContext(tmuxSwitchCommand);
+        await services.checkTmuxAvailable();
+        await services.checkFzfAvailable();
+        const sessionName = await services.pickTmuxSession();
+        if (context.json) {
+            services.stdout.log(JSON.stringify({ session: sessionName }, null, 2));
+        }
+        await services.launchTmuxSession(sessionName, services.cwd());
+    }));
+    return program;
+}
+async function runCli(argv = process.argv, overrides = {}) {
+    const services = createServices(overrides);
+    const program = createProgram(services);
+    await program.parseAsync((0, aliases_1.normalizeArgv)(argv)).catch((error) => {
+        services.stderr.error((0, errors_1.toErrorMessage)(error));
+        process.exitCode = error instanceof errors_1.CliError ? error.exitCode : 1;
+    });
+}