@forceuser/git-profile-switcher 0.1.4

package/dist/runtime/cli/prompts.js

@@ -0,0 +1,389 @@
+import { createInterface as createLineInterface } from "node:readline";
+import { createInterface as createQuestionInterface } from "node:readline/promises";
+const CLEAR_SCREEN = "\x1b[2J";
+const CLEAR_LINE = "\x1b[2K";
+const CURSOR_HOME = "\x1b[H";
+const HIDE_CURSOR = "\x1b[?25l";
+const SHOW_CURSOR = "\x1b[?25h";
+const DEFAULT_TERMINAL_ROWS = 24;
+const PRODUCT_TITLE = "Git Profile Switcher";
+const COLORS = {
+    accent: "\x1b[36m",
+    dim: "\x1b[2m",
+    title: "\x1b[1;36m",
+};
+const RESET = "\x1b[0m";
+export class PromptCancelError extends Error {
+    constructor() {
+        super("Prompt cancelled.");
+    }
+}
+export class PromptInterruptError extends Error {
+    constructor() {
+        super("Prompt interrupted.");
+    }
+}
+export function isPromptCancelError(error) {
+    return error instanceof PromptCancelError;
+}
+export function isPromptInterruptError(error) {
+    return error instanceof PromptInterruptError;
+}
+export function createPromptSession(input = process.stdin, output = process.stdout) {
+    const lineRl = input.isTTY ? null : createLineInterface({ input, terminal: false });
+    const lines = [];
+    let isClosed = false;
+    let waiting = null;
+    lineRl?.on("line", (line) => {
+        if (waiting) {
+            const current = waiting;
+            waiting = null;
+            current.resolve(line);
+            return;
+        }
+        lines.push(line);
+    });
+    lineRl?.on("close", () => {
+        isClosed = true;
+        if (waiting) {
+            const current = waiting;
+            waiting = null;
+            current.reject(new Error("Input ended before a value was provided."));
+        }
+    });
+    return {
+        async ask(prompt) {
+            return (await readLine(input, output, lines, prompt, (pending) => {
+                waiting = pending;
+            }, isClosed)).trim();
+        },
+        async askRequired(prompt) {
+            for (;;) {
+                const value = (await readLine(input, output, lines, prompt, (pending) => {
+                    waiting = pending;
+                }, isClosed)).trim();
+                if (value) {
+                    return value;
+                }
+                output.write("Value is required.\n");
+            }
+        },
+        async selectOne(selection) {
+            if (selection.options.length === 0) {
+                throw new Error(selection.emptyMessage);
+            }
+            const interaction = { input, output };
+            if (canUseArrowKeys(interaction)) {
+                const choice = await promptMenu(interaction, selection.prompt.trimEnd(), selection.options.map((option) => selection.renderOption(option)), (selection.defaultIndex ?? 0) + 1);
+                if (choice === null) {
+                    throw new PromptCancelError();
+                }
+                return selection.options[choice - 1];
+            }
+            for (const [index, option] of selection.options.entries()) {
+                output.write(`${index + 1}. ${selection.renderOption(option)}\n`);
+            }
+            for (;;) {
+                const answer = (await readLine(input, output, lines, selection.prompt, (pending) => {
+                    waiting = pending;
+                }, isClosed)).trim();
+                if (answer === "" && selection.defaultIndex !== undefined) {
+                    const defaultOption = selection.options[selection.defaultIndex];
+                    if (defaultOption) {
+                        return defaultOption;
+                    }
+                }
+                const selectedByNumber = Number.parseInt(answer, 10);
+                if (Number.isInteger(selectedByNumber) &&
+                    selectedByNumber >= 1 &&
+                    selectedByNumber <= selection.options.length) {
+                    return selection.options[selectedByNumber - 1];
+                }
+                const selectedByValue = selection.options.find((option) => selection.getValue(option) === answer);
+                if (selectedByValue) {
+                    return selectedByValue;
+                }
+                output.write("Choose one of the listed options.\n");
+            }
+        },
+        close() {
+            lineRl?.close();
+        },
+    };
+}
+async function promptMenu(interaction, title, options, initialChoice = 1) {
+    if (!interaction.askLine && canUseArrowKeys(interaction)) {
+        return promptArrowMenu(interaction, title, options, initialChoice);
+    }
+    renderScreen(interaction, title);
+    for (const [index, option] of options.entries()) {
+        interaction.output.write(`  ${index + 1}. ${option}\n`);
+    }
+    const answer = interaction.askLine
+        ? await interaction.askLine("Choose number: ")
+        : await askLine(interaction, "Choose number: ");
+    if (!answer) {
+        clearScreenMessage(interaction);
+        return null;
+    }
+    const choice = Number.parseInt(answer, 10);
+    if (!Number.isInteger(choice) ||
+        String(choice) !== answer ||
+        choice < 1 ||
+        choice > options.length) {
+        clearScreenMessage(interaction);
+        interaction.output.write("Invalid choice.\n");
+        return null;
+    }
+    clearScreenMessage(interaction);
+    return choice;
+}
+async function promptArrowMenu(interaction, title, options, initialChoice) {
+    let selectedIndex = normalizeInitialChoice(initialChoice, options.length) - 1;
+    let firstVisibleIndex = 0;
+    const input = interaction.input;
+    const previousRawMode = input.isRaw;
+    input.setRawMode?.(true);
+    input.resume();
+    interaction.output.write(HIDE_CURSOR);
+    const render = () => {
+        const headerLines = [
+            color(interaction, "title", PRODUCT_TITLE),
+            "",
+            color(interaction, "accent", title),
+            color(interaction, "dim", "Use Up/Down and Enter. Press q or Esc to go back. Ctrl+C quits."),
+            ...renderScreenMessages(interaction),
+        ];
+        const menuRows = getMenuRowCapacity(interaction, headerLines.length);
+        const visibleMenu = getVisibleMenu(options, selectedIndex, firstVisibleIndex, menuRows);
+        firstVisibleIndex = visibleMenu.firstIndex;
+        const lines = [
+            ...headerLines,
+            ...visibleMenu.lines.map(({ option, index }) => renderMenuOption(interaction, option, index === selectedIndex)),
+        ];
+        interaction.output.write(`${CLEAR_SCREEN}${CURSOR_HOME}`);
+        interaction.output.write(lines.map((line) => `${CLEAR_LINE}${line}`).join("\n"));
+        interaction.output.write("\n");
+    };
+    render();
+    try {
+        return await new Promise((resolve, reject) => {
+            let finished = false;
+            const cleanup = () => {
+                input.off("data", onData);
+                interaction.output.off("resize", onResize);
+                input.setRawMode?.(previousRawMode ?? false);
+                input.pause();
+                interaction.output.write(SHOW_CURSOR);
+            };
+            const finish = (choice, error) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                cleanup();
+                clearScreenMessage(interaction);
+                if (error) {
+                    reject(error);
+                    return;
+                }
+                resolve(choice);
+            };
+            const onData = (chunk) => {
+                const key = String(chunk);
+                if (key === "\u0003") {
+                    finish(null, new PromptInterruptError());
+                    return;
+                }
+                if (key === "\x1b" || key === "q") {
+                    finish(null);
+                    return;
+                }
+                if (key === "\x1b[A") {
+                    selectedIndex = selectedIndex === 0 ? options.length - 1 : selectedIndex - 1;
+                    render();
+                    return;
+                }
+                if (key === "\x1b[B") {
+                    selectedIndex = selectedIndex === options.length - 1 ? 0 : selectedIndex + 1;
+                    render();
+                    return;
+                }
+                if (key === "\r" || key === "\n") {
+                    finish(selectedIndex + 1);
+                }
+            };
+            const onResize = () => {
+                if (!finished) {
+                    render();
+                }
+            };
+            input.on("data", onData);
+            interaction.output.on("resize", onResize);
+        });
+    }
+    finally {
+        interaction.output.write("\n");
+    }
+}
+async function askLine(interaction, prompt) {
+    if (interaction.askLine) {
+        interaction.output.write(prompt);
+        return (await interaction.askLine(prompt)).trim();
+    }
+    return await readTtyQuestion(interaction.input, interaction.output, prompt).then((answer) => answer.trim());
+}
+function canUseArrowKeys(interaction) {
+    return (interaction.input.isTTY &&
+        interaction.output.isTTY &&
+        typeof interaction.input.setRawMode === "function");
+}
+function getMenuRowCapacity(interaction, headerLineCount) {
+    const terminalRows = getTerminalRows(interaction);
+    return Math.max(1, terminalRows - headerLineCount - 2);
+}
+function getTerminalRows(interaction) {
+    const rows = interaction.output.rows ?? process.stdout.rows;
+    if (Number.isInteger(rows) && rows > 0) {
+        return rows;
+    }
+    return DEFAULT_TERMINAL_ROWS;
+}
+function getVisibleMenu(options, selectedIndex, firstVisibleIndex, rowCapacity) {
+    if (options.length <= rowCapacity) {
+        return {
+            firstIndex: 0,
+            lines: options.map((option, index) => ({ option, index })),
+        };
+    }
+    const canShowScrollHints = rowCapacity >= 3;
+    const visibleOptionCount = canShowScrollHints ? rowCapacity - 2 : rowCapacity;
+    let nextFirstVisibleIndex = firstVisibleIndex;
+    if (selectedIndex < nextFirstVisibleIndex) {
+        nextFirstVisibleIndex = selectedIndex;
+    }
+    if (selectedIndex >= nextFirstVisibleIndex + visibleOptionCount) {
+        nextFirstVisibleIndex = selectedIndex - visibleOptionCount + 1;
+    }
+    nextFirstVisibleIndex = clamp(nextFirstVisibleIndex, 0, Math.max(0, options.length - visibleOptionCount));
+    const visibleOptions = options
+        .slice(nextFirstVisibleIndex, nextFirstVisibleIndex + visibleOptionCount)
+        .map((option, offset) => ({
+        option,
+        index: nextFirstVisibleIndex + offset,
+    }));
+    const hasPrevious = nextFirstVisibleIndex > 0;
+    const hasNext = nextFirstVisibleIndex + visibleOptionCount < options.length;
+    return {
+        firstIndex: nextFirstVisibleIndex,
+        lines: canShowScrollHints
+            ? [
+                {
+                    option: hasPrevious ? "↑" : "",
+                    index: -1,
+                },
+                ...visibleOptions,
+                {
+                    option: hasNext ? "↓" : "",
+                    index: -1,
+                },
+            ]
+            : visibleOptions,
+    };
+}
+function clamp(value, min, max) {
+    return Math.min(Math.max(value, min), max);
+}
+function renderScreen(interaction, title) {
+    interaction.output.write(`${CLEAR_SCREEN}${CURSOR_HOME}`);
+    interaction.output.write(`${color(interaction, "title", PRODUCT_TITLE)}\n\n`);
+    interaction.output.write(`${color(interaction, "accent", title)}\n`);
+    for (const message of renderScreenMessages(interaction)) {
+        interaction.output.write(`${message}\n`);
+    }
+}
+function renderScreenMessages(interaction) {
+    const messages = interaction.screen?.messages ?? [];
+    if (messages.length === 0) {
+        return [""];
+    }
+    return ["", ...messages, ""];
+}
+function clearScreenMessage(interaction) {
+    if (interaction.screen) {
+        interaction.screen.messages = [];
+    }
+}
+function renderMenuOption(interaction, option, selected) {
+    if (!selected) {
+        return `  ${option}`;
+    }
+    return color(interaction, "accent", `› ${option}`);
+}
+function normalizeInitialChoice(initialChoice, optionCount) {
+    if (!Number.isInteger(initialChoice) || initialChoice < 1 || initialChoice > optionCount) {
+        return 1;
+    }
+    return initialChoice;
+}
+function color(interaction, colorName, value) {
+    if (!interaction.output.isTTY || process.env.NO_COLOR) {
+        return value;
+    }
+    return `${COLORS[colorName]}${value}${RESET}`;
+}
+function readLine(input, output, lines, prompt, setWaiting, isClosed) {
+    if (input.isTTY) {
+        return readTtyQuestion(input, output, prompt);
+    }
+    output.write(prompt);
+    const existing = lines.shift();
+    if (existing !== undefined) {
+        return Promise.resolve(existing);
+    }
+    if (isClosed) {
+        return Promise.reject(new Error("Input ended before a value was provided."));
+    }
+    return new Promise((resolve, reject) => {
+        setWaiting({ resolve, reject });
+    });
+}
+function readTtyQuestion(input, output, prompt) {
+    const questionRl = createQuestionInterface({ input, output });
+    input.resume();
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const cleanup = () => {
+            questionRl.off("SIGINT", onSigint);
+            input.off("data", onData);
+            questionRl.close();
+        };
+        const finish = (answer, error) => {
+            if (finished) {
+                return;
+            }
+            finished = true;
+            cleanup();
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(answer ?? "");
+        };
+        const onSigint = () => {
+            finish(null, new PromptInterruptError());
+        };
+        const onData = (chunk) => {
+            if (String(chunk) === "\x1b") {
+                finish(null, new PromptCancelError());
+            }
+        };
+        questionRl.once("SIGINT", onSigint);
+        input.on("data", onData);
+        questionRl.question(prompt).then((answer) => {
+            finish(answer);
+        }, (error) => {
+            finish(null, error instanceof Error ? error : new Error(String(error)));
+        });
+    });
+}

package/dist/runtime/config/paths.js

@@ -0,0 +1,39 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { realpathSync } from "node:fs";
+export function getAppPaths(env = process.env) {
+    const homeDir = env.HOME ? resolve(env.HOME) : homedir();
+    const baseConfigDir = env.GIP_APP_DATA_DIR ?? env.XDG_CONFIG_HOME;
+    const appDataDir = resolve(baseConfigDir
+        ? join(baseConfigDir, "git-profile-switcher")
+        : join(homeDir, ".config", "git-profile-switcher"));
+    return {
+        homeDir,
+        appDataDir,
+        profilesPath: join(appDataDir, "profiles.json"),
+        generatedGitConfigDir: join(appDataDir, "gitconfigs"),
+        globalGitConfigPath: env.GIP_GLOBAL_GITCONFIG ?? join(homeDir, ".gitconfig"),
+    };
+}
+export function expandHomePath(path, homeDir = homedir()) {
+    if (path === "~") {
+        return homeDir;
+    }
+    if (path.startsWith("~/")) {
+        return join(homeDir, path.slice(2));
+    }
+    return path;
+}
+export function normalizeDirectoryPath(path, homeDir = homedir()) {
+    let normalized = resolve(expandHomePath(path, homeDir));
+    try {
+        normalized = realpathSync.native(normalized);
+    }
+    catch {
+        // Directory rules may be created before the directory exists.
+    }
+    if (!normalized.endsWith("/")) {
+        normalized += "/";
+    }
+    return normalized;
+}

package/dist/runtime/git/config.js

@@ -0,0 +1,188 @@
+import { execFile, execFileSync } from "node:child_process";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+import { promisify } from "node:util";
+export const GIT_INCLUDE_BLOCK_START = "# >>> gip includeIf >>>";
+export const GIT_INCLUDE_BLOCK_END = "# <<< gip includeIf <<<";
+const GIT_INCLUDE_BLOCK_PATTERN = new RegExp(`${escapeRegExp(GIT_INCLUDE_BLOCK_START)}\\n[\\s\\S]*?\\n${escapeRegExp(GIT_INCLUDE_BLOCK_END)}\\n?`, "g");
+const execFileAsync = promisify(execFile);
+export async function applyGitProfileConfig(input) {
+    await mkdir(input.generatedGitConfigDir, { recursive: true });
+    const generatedFiles = [];
+    for (const profile of input.data.profiles) {
+        const path = getGeneratedProfileConfigPath(input.generatedGitConfigDir, profile.name);
+        await writeFile(path, renderProfileGitConfig(profile), { mode: 0o600 });
+        generatedFiles.push(path);
+    }
+    const current = await readOptionalText(input.globalGitConfigPath);
+    const next = appendManagedBlock(removeManagedIncludeBlock(current), renderIncludeBlock(input.data.rules, input.generatedGitConfigDir));
+    if (next === current) {
+        return {
+            globalGitConfigPath: input.globalGitConfigPath,
+            generatedFiles,
+            changed: false,
+        };
+    }
+    await mkdir(dirname(input.globalGitConfigPath), { recursive: true });
+    await writeFile(input.globalGitConfigPath, next, { mode: 0o600 });
+    return {
+        globalGitConfigPath: input.globalGitConfigPath,
+        generatedFiles,
+        changed: true,
+    };
+}
+export async function setGlobalGitIdentity(input) {
+    const currentName = await readGitConfigFileValue(input.globalGitConfigPath, "user.name");
+    const currentEmail = await readGitConfigFileValue(input.globalGitConfigPath, "user.email");
+    if (currentName === input.profile.userName && currentEmail === input.profile.userEmail) {
+        return {
+            globalGitConfigPath: input.globalGitConfigPath,
+            changed: false,
+        };
+    }
+    const before = await readOptionalText(input.globalGitConfigPath);
+    await mkdir(dirname(input.globalGitConfigPath), { recursive: true });
+    await writeGitConfigValue(input.globalGitConfigPath, "user.name", input.profile.userName);
+    await writeGitConfigValue(input.globalGitConfigPath, "user.email", input.profile.userEmail);
+    const after = await readOptionalText(input.globalGitConfigPath);
+    return {
+        globalGitConfigPath: input.globalGitConfigPath,
+        changed: before !== after,
+    };
+}
+export async function clearGlobalGitIdentity(globalGitConfigPath) {
+    const currentName = await readGitConfigFileValue(globalGitConfigPath, "user.name");
+    const currentEmail = await readGitConfigFileValue(globalGitConfigPath, "user.email");
+    if (!currentName && !currentEmail) {
+        return {
+            globalGitConfigPath,
+            changed: false,
+        };
+    }
+    const before = await readOptionalText(globalGitConfigPath);
+    if (!before) {
+        return {
+            globalGitConfigPath,
+            changed: false,
+        };
+    }
+    await unsetGitConfigValue(globalGitConfigPath, "user.name");
+    await unsetGitConfigValue(globalGitConfigPath, "user.email");
+    const after = await readOptionalText(globalGitConfigPath);
+    return {
+        globalGitConfigPath,
+        changed: before !== after,
+    };
+}
+export function findMatchingRule(data, cwd) {
+    const candidates = getDirectoryMatchCandidates(cwd);
+    return (data.rules
+        .filter((rule) => getDirectoryMatchCandidates(rule.directory).some((ruleDirectory) => candidates.some((candidate) => candidate.startsWith(ruleDirectory))))
+        .sort((left, right) => right.directory.length - left.directory.length)[0] ?? null);
+}
+export function renderProfileGitConfig(profile) {
+    return `[user]\n\tname = ${escapeGitConfigValue(profile.userName)}\n\temail = ${escapeGitConfigValue(profile.userEmail)}\n`;
+}
+export function renderIncludeBlock(rules, generatedGitConfigDir) {
+    const body = rules
+        .map((rule) => {
+        const path = getGeneratedProfileConfigPath(generatedGitConfigDir, rule.profileName);
+        return `[includeIf "gitdir:${rule.directory}"]\n\tpath = ${path}`;
+    })
+        .join("\n\n");
+    return `${GIT_INCLUDE_BLOCK_START}\n${body}\n${GIT_INCLUDE_BLOCK_END}\n`;
+}
+export function removeManagedIncludeBlock(text) {
+    return text
+        .replace(GIT_INCLUDE_BLOCK_PATTERN, "")
+        .replaceAll(/\n{3,}/g, "\n\n")
+        .trimEnd();
+}
+export function appendManagedBlock(text, block) {
+    const trimmed = text.trimEnd();
+    if (!trimmed) {
+        return block;
+    }
+    return `${trimmed}\n\n${block}`;
+}
+export function readActiveGitIdentity(cwd = process.cwd()) {
+    return {
+        userName: readGitConfigValue("user.name", cwd),
+        userEmail: readGitConfigValue("user.email", cwd),
+    };
+}
+export function getGeneratedProfileConfigPath(dir, profileName) {
+    return join(dir, `${safeFileName(profileName)}.gitconfig`);
+}
+async function readOptionalText(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function readGitConfigValue(key, cwd) {
+    try {
+        const value = execFileSync("git", ["config", key], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return value || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function writeGitConfigValue(path, key, value) {
+    await execFileAsync("git", ["config", "--file", path, key, value]);
+}
+async function readGitConfigFileValue(path, key) {
+    try {
+        const { stdout } = await execFileAsync("git", ["config", "--file", path, key], {
+            encoding: "utf8",
+        });
+        return stdout.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function unsetGitConfigValue(path, key) {
+    try {
+        await execFileAsync("git", ["config", "--file", path, "--unset", key]);
+    }
+    catch (error) {
+        if (isExpectedGitUnsetMiss(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isExpectedGitUnsetMiss(error) {
+    return error instanceof Error && "code" in error && (error.code === 5 || error.code === 1);
+}
+function safeFileName(value) {
+    return basename(value).replaceAll(/[^a-zA-Z0-9._-]/g, "_");
+}
+function escapeGitConfigValue(value) {
+    return value.replaceAll("\n", " ").trim();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getDirectoryMatchCandidates(path) {
+    const withSlash = path.endsWith("/") ? path : `${path}/`;
+    const candidates = new Set([withSlash]);
+    if (withSlash.startsWith("/private/var/")) {
+        candidates.add(withSlash.replace("/private/var/", "/var/"));
+    }
+    else if (withSlash.startsWith("/var/")) {
+        candidates.add(withSlash.replace("/var/", "/private/var/"));
+    }
+    return [...candidates];
+}