@mbluemer_2/gittyup 0.1.2

package/dist/git.js

@@ -0,0 +1,293 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkGitAvailable = checkGitAvailable;
+exports.runGit = runGit;
+exports.initBareRepo = initBareRepo;
+exports.cloneBareRepo = cloneBareRepo;
+exports.getRepoTopLevel = getRepoTopLevel;
+exports.isBareRepository = isBareRepository;
+exports.bootstrapBareRepo = bootstrapBareRepo;
+exports.repoHasCommits = repoHasCommits;
+exports.getDefaultBranch = getDefaultBranch;
+exports.localBranchExists = localBranchExists;
+exports.parseWorktreeList = parseWorktreeList;
+exports.listWorktrees = listWorktrees;
+exports.listLinkedWorktrees = listLinkedWorktrees;
+exports.addWorktree = addWorktree;
+exports.removeWorktree = removeWorktree;
+exports.repairWorktrees = repairWorktrees;
+exports.getCurrentBranch = getCurrentBranch;
+exports.getHeadShortSha = getHeadShortSha;
+exports.getWorktreeStatus = getWorktreeStatus;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const process_1 = require("./process");
+const MINIMUM_GIT_VERSION = '2.17.0';
+function compareVersions(a, b) {
+    const aParts = a.split('.').map(Number);
+    const bParts = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+        const aVal = aParts[i] ?? 0;
+        const bVal = bParts[i] ?? 0;
+        if (aVal > bVal)
+            return 1;
+        if (aVal < bVal)
+            return -1;
+    }
+    return 0;
+}
+async function checkGitAvailable() {
+    try {
+        const versionOutput = await runGit(['--version']);
+        const match = versionOutput.match(/git version (\d+\.\d+\.\d+)/);
+        if (!match) {
+            throw new errors_1.CliError('Unable to determine git version. Please ensure git is installed.');
+        }
+        const version = match[1];
+        if (compareVersions(version, MINIMUM_GIT_VERSION) < 0) {
+            throw new errors_1.CliError(`Git version ${MINIMUM_GIT_VERSION} or higher is required. Found version ${version}.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof errors_1.CliError) {
+            throw error;
+        }
+        throw new errors_1.CliError('Git is not installed or not available in PATH. Please install git to use gittyup.');
+    }
+}
+async function runGit(args, options = {}) {
+    return (0, process_1.runCommand)('git', args, options);
+}
+async function initBareRepo(gitDir) {
+    await runGit(['init', '--bare', '--initial-branch=main', gitDir]);
+}
+async function cloneBareRepo(remote, gitDir) {
+    await runGit(['clone', '--bare', remote, gitDir]);
+}
+async function getRepoTopLevel(repoPath) {
+    return runGit(['-C', repoPath, 'rev-parse', '--show-toplevel']);
+}
+async function isBareRepository(repoPath) {
+    const output = await runGit([
+        '-C',
+        repoPath,
+        'rev-parse',
+        '--is-bare-repository',
+    ]);
+    return output === 'true';
+}
+async function bootstrapBareRepo(gitDir, branch) {
+    const tempDir = await (0, promises_1.mkdtemp)(node_path_1.default.join(node_os_1.default.tmpdir(), 'gittyup-bootstrap-'));
+    try {
+        await runGit(['init', '--initial-branch', branch, tempDir]);
+        await runGit(['-C', tempDir, 'remote', 'add', 'origin', gitDir]);
+        await runGit([
+            '-C',
+            tempDir,
+            '-c',
+            'user.name=gittyup',
+            '-c',
+            'user.email=gittyup@local',
+            'commit',
+            '--allow-empty',
+            '-m',
+            'Initial commit',
+        ]);
+        await runGit(['-C', tempDir, 'push', 'origin', `${branch}:${branch}`]);
+    }
+    finally {
+        await (0, promises_1.rm)(tempDir, { recursive: true, force: true });
+    }
+}
+async function repoHasCommits(gitDir) {
+    try {
+        await runGit([
+            '--git-dir',
+            gitDir,
+            'rev-parse',
+            '--verify',
+            'HEAD^{commit}',
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function getDefaultBranch(gitDir) {
+    try {
+        return await runGit([
+            '--git-dir',
+            gitDir,
+            'symbolic-ref',
+            '--quiet',
+            '--short',
+            'HEAD',
+        ]);
+    }
+    catch {
+        return null;
+    }
+}
+async function localBranchExists(gitDir, branch) {
+    try {
+        await runGit([
+            '--git-dir',
+            gitDir,
+            'show-ref',
+            '--verify',
+            '--quiet',
+            `refs/heads/${branch}`,
+        ]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseWorktreeList(output) {
+    const normalized = output.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    const trimmed = normalized.trim();
+    if (!trimmed) {
+        return [];
+    }
+    return trimmed.split(/\n\s*\n/).map((block) => {
+        let worktreePath = '';
+        let head = null;
+        let branch = null;
+        let bare = false;
+        let locked = false;
+        let prunable = false;
+        let detached = false;
+        for (const line of block.split('\n')) {
+            if (line.startsWith('worktree ')) {
+                worktreePath = line.slice('worktree '.length);
+                continue;
+            }
+            if (line.startsWith('HEAD ')) {
+                head = line.slice('HEAD '.length);
+                continue;
+            }
+            if (line.startsWith('branch ')) {
+                branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+                continue;
+            }
+            if (line === 'bare') {
+                bare = true;
+                continue;
+            }
+            if (line === 'detached') {
+                detached = true;
+                continue;
+            }
+            if (line.startsWith('locked')) {
+                locked = true;
+                continue;
+            }
+            if (line.startsWith('prunable')) {
+                prunable = true;
+            }
+        }
+        return {
+            path: worktreePath,
+            alias: node_path_1.default.basename(worktreePath),
+            branch,
+            head,
+            bare,
+            locked,
+            prunable,
+            detached,
+        };
+    });
+}
+async function listWorktrees(gitDir) {
+    const output = await runGit([
+        '--git-dir',
+        gitDir,
+        'worktree',
+        'list',
+        '--porcelain',
+    ]);
+    return parseWorktreeList(output);
+}
+async function listLinkedWorktrees(gitDir) {
+    const worktrees = await listWorktrees(gitDir);
+    return worktrees.filter((entry) => !entry.bare);
+}
+async function addWorktree(gitDir, worktreePath, branch, startPoint) {
+    if (!(await repoHasCommits(gitDir))) {
+        throw new errors_1.CliError('Repository has no commits yet. Git cannot create a linked worktree for an empty bare repository.');
+    }
+    const args = ['--git-dir', gitDir, 'worktree', 'add'];
+    if (await localBranchExists(gitDir, branch)) {
+        args.push(worktreePath, branch);
+    }
+    else {
+        const resolvedStartPoint = startPoint ?? (await getDefaultBranch(gitDir));
+        if (!resolvedStartPoint) {
+            throw new errors_1.CliError(`Could not determine a start point for branch '${branch}'.`);
+        }
+        args.push('-b', branch, worktreePath, resolvedStartPoint);
+    }
+    await runGit(args);
+}
+async function removeWorktree(gitDir, worktreePath, force) {
+    const args = ['--git-dir', gitDir, 'worktree', 'remove'];
+    if (force) {
+        args.push('--force');
+    }
+    args.push(worktreePath);
+    await runGit(args);
+}
+async function repairWorktrees(gitDir, worktreePaths) {
+    const args = ['--git-dir', gitDir, 'worktree', 'repair', ...worktreePaths];
+    await runGit(args);
+}
+async function getCurrentBranch(worktreePath) {
+    try {
+        return await runGit([
+            '-C',
+            worktreePath,
+            'symbolic-ref',
+            '--quiet',
+            '--short',
+            'HEAD',
+        ]);
+    }
+    catch {
+        return null;
+    }
+}
+async function getHeadShortSha(worktreePath) {
+    return runGit(['-C', worktreePath, 'rev-parse', '--short', 'HEAD']);
+}
+async function getWorktreeStatus(worktree) {
+    const statusOutput = await runGit([
+        '-C',
+        worktree.path,
+        'status',
+        '--porcelain',
+    ]);
+    const changes = statusOutput
+        ? statusOutput.split('\n').filter(Boolean).length
+        : 0;
+    let branch = worktree.branch;
+    let detached = worktree.detached;
+    if (!branch) {
+        branch = await getCurrentBranch(worktree.path);
+        detached = branch === null;
+    }
+    return {
+        ...worktree,
+        branch,
+        detached,
+        head: worktree.head ?? (await getHeadShortSha(worktree.path)),
+        state: changes === 0 ? 'clean' : 'dirty',
+        changes,
+    };
+}

package/dist/interactive.js

@@ -0,0 +1,206 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWorktreeAddInput = resolveWorktreeAddInput;
+exports.resolveWorktreeRemoveInput = resolveWorktreeRemoveInput;
+exports.resolveTmuxLaunchInput = resolveTmuxLaunchInput;
+const readline = __importStar(require("node:readline/promises"));
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+const process_1 = require("./process");
+const projects_1 = require("./projects");
+const tmux_1 = require("./tmux");
+function isInteractiveTerminal() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+async function promptText(message) {
+    const terminal = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        return (await terminal.question(message)).trim();
+    }
+    finally {
+        terminal.close();
+    }
+}
+async function selectFromList(prompt, values) {
+    try {
+        const selection = await (0, process_1.runCommand)('fzf', ['--prompt', prompt], {
+            stdin: `${values.join('\n')}\n`,
+        });
+        return selection.trim();
+    }
+    catch (error) {
+        const message = error instanceof errors_1.CliError ? error.message : '';
+        if (message.includes('exit code 130')) {
+            throw new errors_1.CliError('No project selected.');
+        }
+        throw error;
+    }
+}
+const defaultServices = {
+    checkFzfAvailable: tmux_1.checkFzfAvailable,
+    discoverProjects: projects_1.discoverProjects,
+    listProjectWorktrees: projects_1.listProjectWorktrees,
+    isInteractive: isInteractiveTerminal,
+    promptText,
+    selectFromList,
+};
+async function selectProject(rootDir, services) {
+    await services.checkFzfAvailable();
+    const projects = await services.discoverProjects(rootDir);
+    if (projects.length === 0) {
+        throw new errors_1.CliError(`No projects found under ${rootDir}.`);
+    }
+    return services.selectFromList('project> ', projects.map((project) => project.name));
+}
+async function selectWorktree(options, services) {
+    await services.checkFzfAvailable();
+    const worktrees = options.projectName
+        ? await services.listProjectWorktrees(options.rootDir, options.projectName)
+        : (await Promise.all((await services.discoverProjects(options.rootDir)).map(async (project) => (await services.listProjectWorktrees(options.rootDir, project.name)).map((worktree) => ({
+            ...worktree,
+            project: project.name,
+        }))))).flat();
+    const filteredWorktrees = options.includeWorktree
+        ? worktrees.filter(options.includeWorktree)
+        : worktrees;
+    if (filteredWorktrees.length === 0) {
+        throw new errors_1.CliError(options.emptyMessage);
+    }
+    try {
+        const selection = await services.selectFromList('worktree> ', filteredWorktrees.map((worktree) => buildWorktreeLabel(worktree, options.projectName)));
+        const selected = filteredWorktrees.find((worktree) => buildWorktreeLabel(worktree, options.projectName) === selection);
+        if (!selected) {
+            throw new errors_1.CliError('Selected worktree was not found.');
+        }
+        const projectName = selected.project ?? options.projectName;
+        if (!projectName) {
+            throw new errors_1.CliError('Selected worktree did not include a project.');
+        }
+        return {
+            projectName,
+            alias: selected.alias,
+        };
+    }
+    catch (error) {
+        const message = error instanceof errors_1.CliError ? error.message : '';
+        if (message === 'No project selected.') {
+            throw new errors_1.CliError('No worktree selected.');
+        }
+        throw error;
+    }
+}
+function buildWorktreeLabel(worktree, fallbackProject) {
+    const project = worktree.project ?? fallbackProject;
+    if (!project) {
+        return worktree.alias;
+    }
+    return `${project}:${worktree.alias}`;
+}
+async function resolveWorktreeAddInput(options, services = defaultServices) {
+    let { projectName, branch } = options;
+    if (projectName && branch) {
+        return {
+            projectName,
+            branch: (0, config_1.validateBranchName)(branch),
+        };
+    }
+    if (!services.isInteractive()) {
+        throw new errors_1.CliError('worktree add requires <project> and <branch>, or an interactive terminal when omitted.');
+    }
+    if (!projectName) {
+        projectName = await selectProject(options.rootDir, services);
+    }
+    if (!branch) {
+        branch = await services.promptText('Branch name: ');
+    }
+    return {
+        projectName,
+        branch: (0, config_1.validateBranchName)(branch),
+    };
+}
+async function resolveWorktreeRemoveInput(options, services = defaultServices) {
+    let { projectName, alias } = options;
+    if (projectName && alias) {
+        return { projectName, alias };
+    }
+    if (!services.isInteractive()) {
+        throw new errors_1.CliError('worktree remove requires <project> and <alias>, or an interactive terminal when omitted.');
+    }
+    if (!alias) {
+        const selection = await selectWorktree({
+            rootDir: options.rootDir,
+            projectName,
+            emptyMessage: projectName
+                ? `No linked worktrees found in project '${projectName}'.`
+                : `No linked worktrees found under ${options.rootDir}.`,
+            includeWorktree: (worktree) => worktree.alias !== config_1.MAIN_WORKTREE_ALIAS,
+        }, services);
+        projectName = selection.projectName;
+        alias = selection.alias;
+    }
+    if (!projectName) {
+        throw new errors_1.CliError('Selected worktree did not include a project.');
+    }
+    return { projectName, alias };
+}
+async function resolveTmuxLaunchInput(options, services = defaultServices) {
+    const { projectName, alias } = options;
+    if (projectName && alias) {
+        return { projectName, alias };
+    }
+    if (!services.isInteractive()) {
+        throw new errors_1.CliError('tmux launch requires <project> and [worktree], or an interactive terminal when omitted.');
+    }
+    if (!projectName) {
+        const selection = await selectWorktree({
+            rootDir: options.rootDir,
+            emptyMessage: `No linked worktrees found under ${options.rootDir}.`,
+        }, services);
+        return selection;
+    }
+    if (!alias) {
+        const selection = await selectWorktree({
+            rootDir: options.rootDir,
+            projectName,
+            emptyMessage: `No linked worktrees found in project '${projectName}'.`,
+        }, services);
+        return selection;
+    }
+    return { projectName, alias };
+}

package/dist/metadata.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getProjectInitRecord = getProjectInitRecord;
+exports.setProjectInitCommand = setProjectInitCommand;
+exports.clearProjectInitCommand = clearProjectInitCommand;
+const promises_1 = require("node:fs/promises");
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+function normalizeInitCommand(value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new errors_1.CliError('Project init command must be a string when configured.');
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new errors_1.CliError('Project init command cannot be empty.');
+    }
+    return trimmed;
+}
+async function pathExists(targetPath) {
+    try {
+        await (0, promises_1.access)(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readProjectMetadataFile(rootDir, projectName) {
+    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
+    if (!(await pathExists(project.metadataPath))) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await (0, promises_1.readFile)(project.metadataPath, 'utf8'));
+    }
+    catch (error) {
+        throw new errors_1.CliError(`Project metadata at ${project.metadataPath} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new errors_1.CliError(`Project metadata at ${project.metadataPath} must be a JSON object.`);
+    }
+    return parsed;
+}
+async function getProjectInitRecord(rootDir, projectName) {
+    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
+    const metadata = await readProjectMetadataFile(rootDir, projectName);
+    return {
+        project: project.name,
+        initCommand: normalizeInitCommand(metadata.initCommand),
+    };
+}
+async function writeProjectMetadataFile(rootDir, projectName, metadata) {
+    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
+    const tempPath = `${project.metadataPath}.tmp`;
+    if (Object.keys(metadata).length === 0) {
+        await (0, promises_1.rm)(project.metadataPath, { force: true });
+        return;
+    }
+    await (0, promises_1.writeFile)(tempPath, `${JSON.stringify(metadata, null, 2)}
+`, 'utf8');
+    await (0, promises_1.rename)(tempPath, project.metadataPath);
+}
+async function setProjectInitCommand(rootDir, projectName, command) {
+    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
+    const initCommand = normalizeInitCommand(command);
+    await writeProjectMetadataFile(rootDir, project.name, { initCommand });
+    return {
+        project: project.name,
+        initCommand,
+    };
+}
+async function clearProjectInitCommand(rootDir, projectName) {
+    const project = (0, config_1.buildProjectPaths)(rootDir, projectName);
+    await writeProjectMetadataFile(rootDir, project.name, {});
+    return {
+        project: project.name,
+        initCommand: null,
+    };
+}