@mbluemer_2/gittyup 0.1.2 → 0.1.8

package/dist/program.js

@@ -1,293 +0,0 @@
-"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;
-    });
-}

package/dist/projects.js

@@ -1,308 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BARE_REPO_DIRNAME = void 0;
-exports.discoverProjects = discoverProjects;
-exports.diagnoseProjects = diagnoseProjects;
-exports.createProject = createProject;
-exports.cloneProject = cloneProject;
-exports.importProject = importProject;
-exports.renameProject = renameProject;
-exports.listProjectWorktrees = listProjectWorktrees;
-exports.addProjectWorktree = addProjectWorktree;
-exports.getProjectInit = getProjectInit;
-exports.configureProjectInit = configureProjectInit;
-exports.clearConfiguredProjectInit = clearConfiguredProjectInit;
-exports.getProjectWorktree = getProjectWorktree;
-exports.removeProjectWorktree = removeProjectWorktree;
-exports.getProjectStatuses = getProjectStatuses;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = __importDefault(require("node:path"));
-const config_1 = require("./config");
-Object.defineProperty(exports, "BARE_REPO_DIRNAME", { enumerable: true, get: function () { return config_1.BARE_REPO_DIRNAME; } });
-const errors_1 = require("./errors");
-const git_1 = require("./git");
-const metadata_1 = require("./metadata");
-const process_1 = require("./process");
-const tmux_1 = require("./tmux");
-async function pathExists(targetPath) {
-    try {
-        await (0, promises_1.access)(targetPath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isDirectory(targetPath) {
-    try {
-        const entries = await (0, promises_1.readdir)(targetPath);
-        return Array.isArray(entries);
-    }
-    catch {
-        return false;
-    }
-}
-async function loadProjectRecord(rootDir, projectName) {
-    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
-    if (!(await isDirectory(project.gitDir))) {
-        throw new errors_1.CliError(`Managed project '${project.name}' is missing ${config_1.BARE_REPO_DIRNAME} under ${project.rootPath}.`);
-    }
-    const [worktrees, hasCommits, defaultBranch, init] = await Promise.all([
-        (0, git_1.listLinkedWorktrees)(project.gitDir),
-        (0, git_1.repoHasCommits)(project.gitDir),
-        (0, git_1.getDefaultBranch)(project.gitDir),
-        (0, metadata_1.getProjectInitRecord)(rootDir, project.name),
-    ]);
-    void init;
-    return {
-        ...project,
-        defaultBranch,
-        hasCommits,
-        worktreeCount: worktrees.length,
-    };
-}
-async function inspectProject(rootDir, projectName) {
-    try {
-        return await loadProjectRecord(rootDir, projectName);
-    }
-    catch (error) {
-        const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
-        return {
-            name: project.name,
-            rootPath: project.rootPath,
-            ok: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
-async function runProjectInitCommand(rootDir, project, worktree) {
-    const init = await (0, metadata_1.getProjectInitRecord)(rootDir, project.name);
-    if (!init.initCommand) {
-        return;
-    }
-    try {
-        await (0, process_1.runShellCommand)(init.initCommand, { cwd: worktree.path });
-    }
-    catch (error) {
-        throw new errors_1.CliError(`Worktree '${worktree.alias}' was created, but project init command failed: ${init.initCommand}\n${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-function sortProjects(projects) {
-    return projects.sort((left, right) => left.name.localeCompare(right.name));
-}
-function sortWorktrees(worktrees) {
-    return worktrees.sort((left, right) => {
-        const projectCompare = left.project.localeCompare(right.project);
-        if (projectCompare !== 0) {
-            return projectCompare;
-        }
-        return left.alias.localeCompare(right.alias);
-    });
-}
-async function discoverProjects(rootDir) {
-    const diagnostics = await diagnoseProjects(rootDir);
-    return sortProjects(diagnostics.filter((entry) => 'gitDir' in entry));
-}
-async function diagnoseProjects(rootDir) {
-    if (!(await pathExists(rootDir))) {
-        return [];
-    }
-    const entries = await (0, promises_1.readdir)(rootDir, { withFileTypes: true });
-    const projectNames = entries
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => entry.name);
-    const projects = await Promise.all(projectNames.map((projectName) => inspectProject(rootDir, projectName)));
-    return sortProjects(projects);
-}
-async function createProject(rootDir, projectName) {
-    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
-    await (0, promises_1.mkdir)(rootDir, { recursive: true });
-    if (await pathExists(project.rootPath)) {
-        throw new errors_1.CliError(`Project path already exists: ${project.rootPath}`);
-    }
-    let createdRootPath = false;
-    try {
-        await (0, promises_1.mkdir)(project.rootPath, { recursive: false });
-        createdRootPath = true;
-        await (0, git_1.initBareRepo)(project.gitDir);
-        await (0, git_1.bootstrapBareRepo)(project.gitDir, config_1.MAIN_WORKTREE_ALIAS);
-        await (0, git_1.addWorktree)(project.gitDir, node_path_1.default.join(project.rootPath, config_1.MAIN_WORKTREE_ALIAS), config_1.MAIN_WORKTREE_ALIAS);
-        return loadProjectRecord(rootDir, project.name);
-    }
-    catch (error) {
-        if (createdRootPath) {
-            await (0, promises_1.rm)(project.rootPath, { recursive: true, force: true });
-        }
-        throw error;
-    }
-}
-async function cloneProject(rootDir, remote, projectName) {
-    const validatedRemote = (0, config_1.validateRemoteUrl)(remote);
-    const project = (0, config_1.buildProjectPaths)(rootDir, projectName ?? (0, config_1.inferProjectName)(validatedRemote));
-    await (0, promises_1.mkdir)(rootDir, { recursive: true });
-    if (await pathExists(project.rootPath)) {
-        throw new errors_1.CliError(`Project path already exists: ${project.rootPath}`);
-    }
-    let createdRootPath = false;
-    try {
-        await (0, promises_1.mkdir)(project.rootPath, { recursive: false });
-        createdRootPath = true;
-        await (0, git_1.cloneBareRepo)(validatedRemote, project.gitDir);
-        const defaultBranch = await (0, git_1.getDefaultBranch)(project.gitDir);
-        if ((await (0, git_1.repoHasCommits)(project.gitDir)) && defaultBranch) {
-            await (0, git_1.addWorktree)(project.gitDir, node_path_1.default.join(project.rootPath, config_1.MAIN_WORKTREE_ALIAS), defaultBranch);
-        }
-        return loadProjectRecord(rootDir, project.name);
-    }
-    catch (error) {
-        if (createdRootPath) {
-            await (0, promises_1.rm)(project.rootPath, { recursive: true, force: true });
-        }
-        throw error;
-    }
-}
-async function importProject(rootDir, sourcePath, projectName) {
-    const resolvedSourcePath = await (0, promises_1.realpath)(node_path_1.default.resolve(sourcePath));
-    const sourceTopLevel = await (0, promises_1.realpath)(node_path_1.default.resolve(await (0, git_1.getRepoTopLevel)(resolvedSourcePath)));
-    if (resolvedSourcePath !== sourceTopLevel) {
-        throw new errors_1.CliError(`Source path must be the repository root: ${sourceTopLevel}`);
-    }
-    if (await (0, git_1.isBareRepository)(resolvedSourcePath)) {
-        throw new errors_1.CliError('Source repository must be a non-bare working repository.');
-    }
-    const project = (0, config_1.buildProjectPaths)(rootDir, projectName ?? node_path_1.default.basename(sourceTopLevel));
-    await (0, promises_1.mkdir)(rootDir, { recursive: true });
-    if (await pathExists(project.rootPath)) {
-        throw new errors_1.CliError(`Project path already exists: ${project.rootPath}`);
-    }
-    let createdRootPath = false;
-    try {
-        await (0, promises_1.mkdir)(project.rootPath, { recursive: false });
-        createdRootPath = true;
-        await (0, git_1.cloneBareRepo)(sourceTopLevel, project.gitDir);
-        const defaultBranch = await (0, git_1.getDefaultBranch)(project.gitDir);
-        if ((await (0, git_1.repoHasCommits)(project.gitDir)) && defaultBranch) {
-            await (0, git_1.addWorktree)(project.gitDir, node_path_1.default.join(project.rootPath, config_1.MAIN_WORKTREE_ALIAS), defaultBranch);
-        }
-        return loadProjectRecord(rootDir, project.name);
-    }
-    catch (error) {
-        if (createdRootPath) {
-            await (0, promises_1.rm)(project.rootPath, { recursive: true, force: true });
-        }
-        throw error;
-    }
-}
-async function renameProject(rootDir, projectName, nextProjectName) {
-    const currentProject = await loadProjectRecord(rootDir, projectName);
-    const nextProject = (0, config_1.buildProjectPaths)(rootDir, nextProjectName);
-    if (currentProject.name === nextProject.name) {
-        throw new errors_1.CliError('New project name must be different from the current name.');
-    }
-    if (await pathExists(nextProject.rootPath)) {
-        throw new errors_1.CliError(`Project path already exists: ${nextProject.rootPath}`);
-    }
-    const currentRootPath = await (0, promises_1.realpath)(currentProject.rootPath);
-    const worktrees = await (0, git_1.listLinkedWorktrees)(currentProject.gitDir);
-    const currentWorktreePaths = worktrees.map((worktree) => worktree.path);
-    await (0, promises_1.rename)(currentProject.rootPath, nextProject.rootPath);
-    try {
-        const nextRootPath = await (0, promises_1.realpath)(nextProject.rootPath);
-        const repairedPaths = worktrees.map((worktree) => node_path_1.default.join(nextRootPath, node_path_1.default.relative(currentRootPath, worktree.path)));
-        if (repairedPaths.length > 0) {
-            await (0, git_1.repairWorktrees)(nextProject.gitDir, repairedPaths);
-        }
-    }
-    catch (error) {
-        await (0, promises_1.rename)(nextProject.rootPath, currentProject.rootPath);
-        if (currentWorktreePaths.length > 0) {
-            await (0, git_1.repairWorktrees)(currentProject.gitDir, currentWorktreePaths);
-        }
-        throw new errors_1.CliError(`Failed to rename project '${currentProject.name}' to '${nextProject.name}'. Changes were rolled back: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    return loadProjectRecord(rootDir, nextProject.name);
-}
-async function listProjectWorktrees(rootDir, projectName) {
-    const projects = projectName
-        ? [await loadProjectRecord(rootDir, projectName)]
-        : await discoverProjects(rootDir);
-    const worktrees = await Promise.all(projects.map(async (project) => {
-        const entries = await (0, git_1.listLinkedWorktrees)(project.gitDir);
-        return entries.map((entry) => ({
-            ...entry,
-            project: project.name,
-            rootPath: project.rootPath,
-            gitDir: project.gitDir,
-        }));
-    }));
-    return sortWorktrees(worktrees.flat());
-}
-async function addProjectWorktree(rootDir, projectName, branch, alias, from) {
-    const validatedBranch = (0, config_1.validateBranchName)(branch);
-    const project = await loadProjectRecord(rootDir, projectName);
-    const worktreeAlias = alias
-        ? (0, config_1.validateAlias)(alias)
-        : (0, config_1.deriveAlias)(validatedBranch);
-    const worktreePath = node_path_1.default.join(project.rootPath, worktreeAlias);
-    const existingWorktrees = await (0, git_1.listLinkedWorktrees)(project.gitDir);
-    if (!project.hasCommits) {
-        throw new errors_1.CliError(`Project '${project.name}' has no commits yet. Create the first commit before adding linked worktrees.`);
-    }
-    if (await pathExists(worktreePath)) {
-        throw new errors_1.CliError(`Worktree path already exists: ${worktreePath}`);
-    }
-    if (existingWorktrees.some((entry) => entry.alias === worktreeAlias)) {
-        throw new errors_1.CliError(`Worktree alias '${worktreeAlias}' already exists in project '${project.name}'.`);
-    }
-    await (0, git_1.addWorktree)(project.gitDir, worktreePath, validatedBranch, from);
-    const created = (await listProjectWorktrees(rootDir, project.name)).find((entry) => entry.alias === worktreeAlias);
-    if (!created) {
-        throw new errors_1.CliError(`Worktree '${worktreeAlias}' was created but could not be rediscovered.`);
-    }
-    await runProjectInitCommand(rootDir, project, created);
-    return created;
-}
-async function getProjectInit(rootDir, projectName) {
-    const project = await loadProjectRecord(rootDir, projectName);
-    return (0, metadata_1.getProjectInitRecord)(rootDir, project.name);
-}
-async function configureProjectInit(rootDir, projectName, command) {
-    const project = await loadProjectRecord(rootDir, projectName);
-    return (0, metadata_1.setProjectInitCommand)(rootDir, project.name, command);
-}
-async function clearConfiguredProjectInit(rootDir, projectName) {
-    const project = await loadProjectRecord(rootDir, projectName);
-    return (0, metadata_1.clearProjectInitCommand)(rootDir, project.name);
-}
-async function getProjectWorktree(rootDir, projectName, alias) {
-    const worktreeAlias = (0, config_1.validateAlias)(alias);
-    const worktrees = await listProjectWorktrees(rootDir, projectName);
-    const target = worktrees.find((entry) => entry.alias === worktreeAlias);
-    if (!target) {
-        throw new errors_1.CliError(`Worktree '${worktreeAlias}' was not found in project '${projectName}'.`);
-    }
-    return target;
-}
-async function removeProjectWorktree(rootDir, projectName, alias, force) {
-    if (alias === config_1.MAIN_WORKTREE_ALIAS) {
-        throw new errors_1.CliError("Cannot remove the 'main' worktree. It is the canonical linked worktree for managed projects.");
-    }
-    const project = await loadProjectRecord(rootDir, projectName);
-    const target = await getProjectWorktree(rootDir, project.name, alias);
-    await (0, git_1.removeWorktree)(project.gitDir, target.path, force);
-    await (0, tmux_1.killTmuxSessionIfExists)((0, tmux_1.buildTmuxSessionName)(target.project, target.alias));
-    return target;
-}
-async function getProjectStatuses(rootDir, projectName) {
-    const worktrees = await listProjectWorktrees(rootDir, projectName);
-    const statuses = await Promise.all(worktrees.map(async (worktree) => ({
-        ...(await (0, git_1.getWorktreeStatus)(worktree)),
-        project: worktree.project,
-        rootPath: worktree.rootPath,
-        gitDir: worktree.gitDir,
-    })));
-    return sortWorktrees(statuses);
-}