@mbluemer_2/gittyup 0.1.2

package/dist/projects.js

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

package/dist/tmux.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTmuxSessionName = buildTmuxSessionName;
+exports.isInsideTmux = isInsideTmux;
+exports.checkTmuxAvailable = checkTmuxAvailable;
+exports.checkFzfAvailable = checkFzfAvailable;
+exports.listTmuxSessions = listTmuxSessions;
+exports.tmuxSessionExists = tmuxSessionExists;
+exports.createDetachedTmuxSession = createDetachedTmuxSession;
+exports.attachTmuxSession = attachTmuxSession;
+exports.switchTmuxSession = switchTmuxSession;
+exports.launchTmuxSession = launchTmuxSession;
+exports.killTmuxSessionIfExists = killTmuxSessionIfExists;
+exports.pickTmuxSession = pickTmuxSession;
+const errors_1 = require("./errors");
+const process_1 = require("./process");
+function runTmux(args, options = {}) {
+    return (0, process_1.runCommand)('tmux', args, options);
+}
+function toTmuxSessionTarget(name) {
+    return `=${name}`;
+}
+function buildTmuxSessionName(project, alias) {
+    return `${project}_${alias}`;
+}
+function isInsideTmux() {
+    return Boolean(process.env.TMUX);
+}
+async function checkTmuxAvailable() {
+    try {
+        await runTmux(['-V']);
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError) {
+            throw new errors_1.CliError('tmux is not installed or not available in PATH. Please install tmux to use tmux session management.');
+        }
+        throw error;
+    }
+}
+async function checkFzfAvailable() {
+    try {
+        await (0, process_1.runCommand)('fzf', ['--version']);
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError) {
+            throw new errors_1.CliError('fzf is not installed or not available in PATH. Please install fzf to use the tmux session picker.');
+        }
+        throw error;
+    }
+}
+async function listTmuxSessions() {
+    try {
+        const output = await runTmux([
+            'list-sessions',
+            '-F',
+            '#{session_name}\t#{session_attached}',
+        ]);
+        if (!output.trim()) {
+            return [];
+        }
+        return output
+            .split('\n')
+            .filter(Boolean)
+            .map((line) => {
+            const [name, attached] = line.split('\t');
+            return {
+                name: name ?? '',
+                attached: attached === '1',
+            };
+        });
+    }
+    catch (error) {
+        const message = error instanceof errors_1.CliError ? error.message : '';
+        if (message.includes('no server running')) {
+            return [];
+        }
+        throw error;
+    }
+}
+async function tmuxSessionExists(name) {
+    const sessions = await listTmuxSessions();
+    return sessions.some((session) => session.name === name);
+}
+async function createDetachedTmuxSession(name, cwd) {
+    await runTmux(['new-session', '-d', '-s', name, '-c', cwd]);
+}
+async function attachTmuxSession(name) {
+    await runTmux(['attach-session', '-t', toTmuxSessionTarget(name)]);
+}
+async function switchTmuxSession(name) {
+    await runTmux(['switch-client', '-t', toTmuxSessionTarget(name)]);
+}
+async function launchTmuxSession(name, cwd) {
+    const exists = await tmuxSessionExists(name);
+    if (isInsideTmux()) {
+        if (!exists) {
+            await createDetachedTmuxSession(name, cwd);
+        }
+        await switchTmuxSession(name);
+        return;
+    }
+    if (exists) {
+        await attachTmuxSession(name);
+        return;
+    }
+    await runTmux(['new-session', '-s', name, '-c', cwd]);
+}
+async function killTmuxSessionIfExists(name) {
+    try {
+        await runTmux(['kill-session', '-t', toTmuxSessionTarget(name)]);
+        return true;
+    }
+    catch (error) {
+        const message = error instanceof errors_1.CliError ? error.message.toLowerCase() : '';
+        if (message.includes('no server running') ||
+            message.includes('failed to connect to server') ||
+            message.includes("can't find session") ||
+            message.includes('failed to run tmux')) {
+            return false;
+        }
+        throw error;
+    }
+}
+async function pickTmuxSession() {
+    const sessions = await listTmuxSessions();
+    if (sessions.length === 0) {
+        throw new errors_1.CliError('No tmux sessions are currently open.');
+    }
+    try {
+        const selection = await (0, process_1.runCommand)('fzf', ['--prompt', 'tmux session> '], {
+            stdin: `${sessions.map((session) => session.name).join('\n')}\n`,
+        });
+        const trimmed = selection.trim();
+        if (!trimmed) {
+            throw new errors_1.CliError('No tmux session selected.');
+        }
+        return trimmed;
+    }
+    catch (error) {
+        const message = error instanceof errors_1.CliError ? error.message : '';
+        if (message.includes('exit code 130')) {
+            throw new errors_1.CliError('No tmux session selected.');
+        }
+        throw error;
+    }
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@mbluemer_2/gittyup",
+  "version": "0.1.2",
+  "description": "Filesystem-driven CLI for managing bare git repositories and worktrees",
+  "main": "dist/cli.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "bin": {
+    "gu": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
+    "dev": "tsx src/cli.ts",
+    "format": "prettier . --write",
+    "format:check": "prettier . --check",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prepare": "husky",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "git",
+    "worktree",
+    "cli",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mbluemer/gittyup.git"
+  },
+  "homepage": "https://github.com/mbluemer/gittyup#readme",
+  "bugs": {
+    "url": "https://github.com/mbluemer/gittyup/issues"
+  },
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.33.0",
+  "dependencies": {
+    "cli-table3": "^0.6.5",
+    "commander": "^14.0.3"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.5.2",
+    "eslint": "^10.2.0",
+    "eslint-config-prettier": "^10.1.8",
+    "globals": "^17.4.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.4.0",
+    "prettier": "^3.8.2",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1",
+    "vitest": "^4.1.4"
+  },
+  "lint-staged": {
+    "*.{js,mjs,cjs,ts}": [
+      "eslint --fix --max-warnings=0",
+      "prettier --write"
+    ],
+    "*.{json,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  }
+}