@forceuser/git-profile-switcher 0.1.4

package/dist/runtime/profiles/repository.js

@@ -0,0 +1,183 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { normalizeDirectoryPath } from "#config/paths";
+import { createEmptyProfileStore, PROFILE_PROMPT_COLORS, } from "./types.js";
+export function createProfileRepository(path) {
+    async function read() {
+        try {
+            const raw = await readFile(path, "utf8");
+            const parsed = JSON.parse(raw);
+            return normalizeStore(parsed);
+        }
+        catch (error) {
+            if (isNotFoundError(error)) {
+                return createEmptyProfileStore();
+            }
+            throw error;
+        }
+    }
+    async function save(data) {
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, `${JSON.stringify(normalizeStore(data), null, 2)}\n`, {
+            mode: 0o600,
+        });
+    }
+    return {
+        read,
+        save,
+        async upsertProfile(input) {
+            const data = await read();
+            const now = new Date().toISOString();
+            const existing = data.profiles.find((profile) => profile.name === input.name);
+            if (existing) {
+                existing.userName = input.userName;
+                existing.userEmail = input.userEmail;
+                if (input.promptColor !== undefined) {
+                    existing.promptColor = input.promptColor;
+                }
+                existing.updatedAt = now;
+                await save(data);
+                return existing;
+            }
+            const profile = {
+                name: input.name,
+                userName: input.userName,
+                userEmail: input.userEmail,
+                ...(input.promptColor ? { promptColor: input.promptColor } : {}),
+                createdAt: now,
+                updatedAt: now,
+            };
+            data.profiles.push(profile);
+            sortStore(data);
+            await save(data);
+            return profile;
+        },
+        async setProfilePromptColor(input) {
+            const data = await read();
+            const profile = data.profiles.find((candidate) => candidate.name === input.name);
+            if (!profile) {
+                throw new Error(`Unknown profile: ${input.name}`);
+            }
+            if (input.promptColor) {
+                profile.promptColor = input.promptColor;
+            }
+            else {
+                delete profile.promptColor;
+            }
+            profile.updatedAt = new Date().toISOString();
+            await save(data);
+            return profile;
+        },
+        async removeProfile(name) {
+            const data = await read();
+            const nextProfiles = data.profiles.filter((profile) => profile.name !== name);
+            if (nextProfiles.length === data.profiles.length) {
+                return false;
+            }
+            data.profiles = nextProfiles;
+            data.rules = data.rules.filter((rule) => rule.profileName !== name);
+            await save(data);
+            return true;
+        },
+        async addRule(input) {
+            const data = await read();
+            if (!data.profiles.some((profile) => profile.name === input.profileName)) {
+                throw new Error(`Unknown profile: ${input.profileName}`);
+            }
+            const directory = normalizeDirectoryPath(input.directory, input.homeDir);
+            const existing = data.rules.find((rule) => rule.profileName === input.profileName && rule.directory === directory);
+            if (existing) {
+                return existing;
+            }
+            const rule = {
+                id: `rule_${randomUUID().replaceAll("-", "").slice(0, 12)}`,
+                profileName: input.profileName,
+                directory,
+                createdAt: new Date().toISOString(),
+            };
+            data.rules.push(rule);
+            sortStore(data);
+            await save(data);
+            return rule;
+        },
+        async setDirectoryProfile(input) {
+            const data = await read();
+            if (!data.profiles.some((profile) => profile.name === input.profileName)) {
+                throw new Error(`Unknown profile: ${input.profileName}`);
+            }
+            const directory = normalizeDirectoryPath(input.directory, input.homeDir);
+            const existing = data.rules.find((rule) => rule.profileName === input.profileName && rule.directory === directory);
+            if (existing) {
+                data.rules = data.rules.filter((rule) => rule.directory !== directory || rule.id === existing.id);
+                sortStore(data);
+                await save(data);
+                return existing;
+            }
+            const rule = {
+                id: `rule_${randomUUID().replaceAll("-", "").slice(0, 12)}`,
+                profileName: input.profileName,
+                directory,
+                createdAt: new Date().toISOString(),
+            };
+            data.rules = [...data.rules.filter((candidate) => candidate.directory !== directory), rule];
+            sortStore(data);
+            await save(data);
+            return rule;
+        },
+        async clearDirectoryProfile(input) {
+            const data = await read();
+            const directory = normalizeDirectoryPath(input.directory, input.homeDir);
+            const removed = data.rules.filter((rule) => rule.directory === directory);
+            if (removed.length === 0) {
+                return [];
+            }
+            data.rules = data.rules.filter((rule) => rule.directory !== directory);
+            await save(data);
+            return removed;
+        },
+        async removeRule(id) {
+            const data = await read();
+            const nextRules = data.rules.filter((rule) => rule.id !== id);
+            if (nextRules.length === data.rules.length) {
+                return false;
+            }
+            data.rules = nextRules;
+            await save(data);
+            return true;
+        },
+    };
+}
+function normalizeStore(input) {
+    const data = {
+        version: 1,
+        profiles: Array.isArray(input.profiles) ? input.profiles.map(normalizeProfile) : [],
+        rules: Array.isArray(input.rules) ? input.rules : [],
+    };
+    sortStore(data);
+    return data;
+}
+function normalizeProfile(profile) {
+    const { promptColor, ...profileWithoutPromptColor } = profile;
+    const normalizedPromptColor = normalizePromptColor(promptColor);
+    return {
+        ...profileWithoutPromptColor,
+        ...(normalizedPromptColor ? { promptColor: normalizedPromptColor } : {}),
+    };
+}
+export function normalizePromptColor(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    return PROFILE_PROMPT_COLORS.includes(normalized)
+        ? normalized
+        : null;
+}
+function sortStore(data) {
+    data.profiles.sort((left, right) => left.name.localeCompare(right.name));
+    data.rules.sort((left, right) => left.directory.localeCompare(right.directory));
+}
+function isNotFoundError(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}

package/dist/runtime/profiles/transfer.js

@@ -0,0 +1,111 @@
+import { createEmptyProfileStore, PROFILE_PROMPT_COLORS, } from "#profiles/types";
+export function createProfileExportBundle(data) {
+    return {
+        kind: "git-profile-switcher/profile-store",
+        version: 1,
+        exportedAt: new Date().toISOString(),
+        data: normalizeProfileStoreData(data),
+    };
+}
+export function parseProfileImportBundle(input) {
+    if (isRecord(input) && input.kind === "git-profile-switcher/profile-store") {
+        if (input.version !== 1) {
+            throw new Error(`Unsupported export bundle version: ${String(input.version)}`);
+        }
+        return normalizeProfileStoreData(input.data);
+    }
+    return normalizeProfileStoreData(input);
+}
+export function mergeProfileStoreData(current, incoming) {
+    const next = createEmptyProfileStore();
+    const profiles = new Map();
+    for (const profile of current.profiles) {
+        profiles.set(profile.name, profile);
+    }
+    for (const profile of incoming.profiles) {
+        profiles.set(profile.name, profile);
+    }
+    next.profiles = [...profiles.values()];
+    const knownProfiles = new Set(next.profiles.map((profile) => profile.name));
+    const rules = new Map();
+    for (const rule of [...current.rules, ...incoming.rules]) {
+        if (!knownProfiles.has(rule.profileName)) {
+            continue;
+        }
+        rules.set(rule.id, rule);
+    }
+    next.rules = [...rules.values()];
+    return sortProfileStoreData(next);
+}
+export function normalizeProfileStoreData(input) {
+    if (!isRecord(input)) {
+        throw new Error("Invalid profile store: expected an object.");
+    }
+    const version = input.version;
+    if (version !== 1) {
+        throw new Error(`Unsupported profile store version: ${String(version)}`);
+    }
+    const profiles = readArray(input.profiles, "profiles").map(parseProfile);
+    const profileNames = new Set(profiles.map((profile) => profile.name));
+    const rules = readArray(input.rules, "rules")
+        .map(parseRule)
+        .filter((rule) => profileNames.has(rule.profileName));
+    return sortProfileStoreData({ version: 1, profiles, rules });
+}
+function parseProfile(input) {
+    if (!isRecord(input)) {
+        throw new Error("Invalid profile: expected an object.");
+    }
+    return {
+        name: readString(input.name, "profile.name"),
+        userName: readString(input.userName, "profile.userName"),
+        userEmail: readString(input.userEmail, "profile.userEmail"),
+        ...readOptionalPromptColor(input.promptColor),
+        createdAt: readString(input.createdAt, "profile.createdAt"),
+        updatedAt: readString(input.updatedAt, "profile.updatedAt"),
+    };
+}
+function parseRule(input) {
+    if (!isRecord(input)) {
+        throw new Error("Invalid rule: expected an object.");
+    }
+    return {
+        id: readString(input.id, "rule.id"),
+        profileName: readString(input.profileName, "rule.profileName"),
+        directory: readString(input.directory, "rule.directory"),
+        createdAt: readString(input.createdAt, "rule.createdAt"),
+    };
+}
+function sortProfileStoreData(data) {
+    data.profiles.sort((left, right) => left.name.localeCompare(right.name));
+    data.rules.sort((left, right) => left.directory.localeCompare(right.directory));
+    return data;
+}
+function readArray(value, field) {
+    if (!Array.isArray(value)) {
+        throw new Error(`Invalid profile store: ${field} must be an array.`);
+    }
+    return value;
+}
+function readString(value, field) {
+    if (typeof value !== "string" || value.length === 0) {
+        throw new Error(`Invalid profile store: ${field} must be a non-empty string.`);
+    }
+    return value;
+}
+function readOptionalPromptColor(value) {
+    if (value === undefined || value === null || value === "") {
+        return {};
+    }
+    if (typeof value !== "string") {
+        throw new Error("Invalid profile store: profile.promptColor must be a string.");
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!PROFILE_PROMPT_COLORS.includes(normalized)) {
+        throw new Error(`Invalid profile store: unsupported profile.promptColor ${value}.`);
+    }
+    return { promptColor: normalized };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/runtime/profiles/types.js

@@ -0,0 +1,23 @@
+export const PROFILE_PROMPT_COLOR_CODES = {
+    red: "31",
+    green: "32",
+    yellow: "33",
+    blue: "34",
+    magenta: "35",
+    cyan: "36",
+    gray: "90",
+    "bright-red": "91",
+    "bright-green": "92",
+    "bright-yellow": "93",
+    "bright-blue": "94",
+    "bright-magenta": "95",
+    "bright-cyan": "96",
+};
+export const PROFILE_PROMPT_COLORS = Object.keys(PROFILE_PROMPT_COLOR_CODES);
+export function createEmptyProfileStore() {
+    return {
+        version: 1,
+        profiles: [],
+        rules: [],
+    };
+}

package/dist/runtime/prompt/status.js

@@ -0,0 +1,103 @@
+import { resolve } from "node:path";
+import { findMatchingRule, readActiveGitIdentity } from "#git/config";
+import { PROFILE_PROMPT_COLOR_CODES, } from "#profiles/types";
+export function getPromptStatus(input) {
+    const cwd = resolve(input.cwd ?? process.cwd());
+    const sessionIdentity = readSessionGitIdentity(input.env ?? process.env);
+    if (sessionIdentity.userName || sessionIdentity.userEmail || sessionIdentity.profileName) {
+        const sessionProfileByName = sessionIdentity.profileName
+            ? findProfileByName(input.data.profiles, sessionIdentity.profileName)
+            : null;
+        const sessionProfileByIdentity = findProfileByIdentity(input.data.profiles, {
+            userName: sessionIdentity.userName,
+            userEmail: sessionIdentity.userEmail,
+        });
+        return {
+            cwd,
+            profileName: sessionProfileByName?.name ??
+                sessionProfileByIdentity?.name ??
+                sessionIdentity.profileName ??
+                null,
+            profilePromptColor: sessionProfileByName?.promptColor ?? sessionProfileByIdentity?.promptColor ?? null,
+            userName: sessionIdentity.userName,
+            userEmail: sessionIdentity.userEmail,
+            ruleId: null,
+            directory: null,
+        };
+    }
+    const rule = findMatchingRule(input.data, cwd);
+    const gitIdentity = readActiveGitIdentity(cwd);
+    const ruleProfile = rule ? findProfileByName(input.data.profiles, rule.profileName) : null;
+    const identityProfile = findProfileByIdentity(input.data.profiles, {
+        userName: gitIdentity.userName,
+        userEmail: gitIdentity.userEmail,
+    });
+    return {
+        cwd,
+        profileName: ruleProfile?.name ?? rule?.profileName ?? identityProfile?.name ?? null,
+        profilePromptColor: ruleProfile?.promptColor ?? identityProfile?.promptColor ?? null,
+        userName: ruleProfile?.userName ?? gitIdentity.userName ?? null,
+        userEmail: ruleProfile?.userEmail ?? gitIdentity.userEmail ?? null,
+        ruleId: rule?.id ?? null,
+        directory: rule?.directory ?? null,
+    };
+}
+function readSessionGitIdentity(env) {
+    return {
+        profileName: env.GIP_PROFILE_NAME || null,
+        userName: env.GIT_AUTHOR_NAME || env.GIT_COMMITTER_NAME || null,
+        userEmail: env.GIT_AUTHOR_EMAIL || env.GIT_COMMITTER_EMAIL || null,
+    };
+}
+export function renderPromptStatus(status, format = "auto", shell = null) {
+    if (format === "profile") {
+        return renderProfilePrompt(status, shell);
+    }
+    if (format === "auto" && status.profileName) {
+        return renderProfilePrompt(status, shell);
+    }
+    if (format === "auto") {
+        return renderIdentityPrompt(status);
+    }
+    return renderIdentityPrompt(status);
+}
+function renderIdentityPrompt(status) {
+    if (!status.userName && !status.userEmail) {
+        return "";
+    }
+    if (status.userName && status.userEmail) {
+        return `${status.userName} <${status.userEmail}>`;
+    }
+    return status.userName ?? status.userEmail ?? "";
+}
+function renderProfilePrompt(status, shell) {
+    if (!status.profileName) {
+        return "";
+    }
+    const profileName = status.profilePromptColor
+        ? applyPromptColor(status.profileName, status.profilePromptColor, shell)
+        : status.profileName;
+    return `[gip ${profileName}]`;
+}
+function applyPromptColor(value, promptColor, shell) {
+    if (!shell) {
+        return value;
+    }
+    const code = PROFILE_PROMPT_COLOR_CODES[promptColor];
+    if (shell === "bash") {
+        return `\u0001\x1b[${code}m\u0002${value}\u0001\x1b[0m\u0002`;
+    }
+    if (shell === "zsh") {
+        return `%{\x1b[${code}m%}${value}%{\x1b[0m%}`;
+    }
+    return `\x1b[${code}m${value}\x1b[0m`;
+}
+function findProfileByName(profiles, name) {
+    return profiles.find((profile) => profile.name === name) ?? null;
+}
+function findProfileByIdentity(profiles, identity) {
+    if (!identity.userName || !identity.userEmail) {
+        return null;
+    }
+    return (profiles.find((profile) => profile.userName === identity.userName && profile.userEmail === identity.userEmail) ?? null);
+}

package/dist/runtime/shell/integration.js

@@ -0,0 +1,254 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { generateCompletionScript } from "#cli/completion";
+const PROMPT_BLOCK_START = "# >>> gip prompt >>>";
+const PROMPT_BLOCK_END = "# <<< gip prompt <<<";
+const COMPLETION_BLOCK_START = "# >>> gip completion >>>";
+const COMPLETION_BLOCK_END = "# <<< gip completion <<<";
+const SHELL_BLOCK_START = "# >>> gip shell >>>";
+const SHELL_BLOCK_END = "# <<< gip shell <<<";
+const PROMPT_BLOCK_PATTERN = new RegExp(`${escapeRegExp(PROMPT_BLOCK_START)}\\n[\\s\\S]*?\\n${escapeRegExp(PROMPT_BLOCK_END)}\\n?`, "g");
+const COMPLETION_BLOCK_PATTERN = new RegExp(`${escapeRegExp(COMPLETION_BLOCK_START)}\\n[\\s\\S]*?\\n${escapeRegExp(COMPLETION_BLOCK_END)}\\n?`, "g");
+const SHELL_BLOCK_PATTERN = new RegExp(`${escapeRegExp(SHELL_BLOCK_START)}\\n[\\s\\S]*?\\n${escapeRegExp(SHELL_BLOCK_END)}\\n?`, "g");
+export async function installShellPrompt(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    const next = appendManagedBlock(removeShellPromptBlock(current), renderPromptBlock(input.shell, input.promptFormat));
+    return await writeIfChanged(path, current, next);
+}
+export async function uninstallShellPrompt(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    return await writeIfChanged(path, current, removeShellPromptBlock(current));
+}
+export async function installShellCompletion(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    const next = appendManagedBlock(removeShellCompletionBlock(current), renderCompletionBlock(input.shell));
+    return await writeIfChanged(path, current, next);
+}
+export async function uninstallShellCompletion(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    return await writeIfChanged(path, current, removeShellCompletionBlock(current));
+}
+export async function installShellSession(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    const next = appendManagedBlock(removeShellSessionBlock(current), renderShellSessionBlock(input.shell));
+    return await writeIfChanged(path, current, next);
+}
+export async function uninstallShellSession(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    return await writeIfChanged(path, current, removeShellSessionBlock(current));
+}
+export async function installShellAll(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    const cleaned = removeShellSessionBlock(removeShellPromptBlock(removeShellCompletionBlock(current)));
+    const next = appendManagedBlock(appendManagedBlock(appendManagedBlock(cleaned, renderCompletionBlock(input.shell)), renderShellSessionBlock(input.shell)), renderPromptBlock(input.shell, input.promptFormat));
+    return await writeIfChanged(path, current, next);
+}
+export async function uninstallShellAll(input) {
+    const path = resolve(input.configPath ?? getDefaultShellConfigPath(input.shell));
+    const current = await readOptionalText(path);
+    const next = removeShellSessionBlock(removeShellPromptBlock(removeShellCompletionBlock(current)));
+    return await writeIfChanged(path, current, next);
+}
+export function detectShell(env = process.env) {
+    const shell = env.SHELL?.toLowerCase() ?? "";
+    if (shell.endsWith("/zsh") || env.ZSH_VERSION) {
+        return "zsh";
+    }
+    if (shell.endsWith("/bash") || env.BASH_VERSION) {
+        return "bash";
+    }
+    if (shell.endsWith("/fish") || env.FISH_VERSION) {
+        return "fish";
+    }
+    return null;
+}
+export function renderPromptBlock(shell, promptFormat = "auto") {
+    const promptCommand = renderPromptCommand(promptFormat);
+    if (shell === "fish") {
+        return `${PROMPT_BLOCK_START}
+if functions -q fish_prompt; and not functions -q __gip_original_fish_prompt
+    functions -c fish_prompt __gip_original_fish_prompt
+end
+
+function fish_prompt
+    set -lx GIP_PROMPT_SHELL fish
+    set -l gip_segment (${promptCommand} 2>/dev/null)
+    set -l gip_original_prompt
+    if functions -q __gip_original_fish_prompt
+        set gip_original_prompt (__gip_original_fish_prompt | string collect)
+    end
+
+    if test -n "$gip_segment"
+        if test -n "$gip_original_prompt"; and string match -q "*\\n*" "$gip_original_prompt"
+            printf "%s " "$gip_segment"
+        else
+            printf "%s\\n" "$gip_segment"
+        end
+    end
+
+    printf "%s" "$gip_original_prompt"
+end
+${PROMPT_BLOCK_END}
+`;
+    }
+    if (shell === "zsh") {
+        return `${PROMPT_BLOCK_START}
+setopt prompt_subst
+
+_gip_prompt_segment() {
+  local gip_segment
+  gip_segment="$(GIP_PROMPT_SHELL=zsh ${promptCommand} 2>/dev/null)" || return
+  if [ -n "$gip_segment" ]; then
+    case "$GIP_ORIGINAL_PROMPT" in
+      *$'\\n'*|*'\\n'*)
+        printf '%s ' "$gip_segment"
+        ;;
+      *)
+        printf '%s\\n%%{%%}' "$gip_segment"
+        ;;
+    esac
+  fi
+}
+
+if [ -z "\${GIP_ORIGINAL_PROMPT+x}" ]; then
+  GIP_ORIGINAL_PROMPT="$PROMPT"
+fi
+
+PROMPT='$(_gip_prompt_segment)'"\${GIP_ORIGINAL_PROMPT}"
+${PROMPT_BLOCK_END}
+`;
+    }
+    return `${PROMPT_BLOCK_START}
+_gip_prompt_segment() {
+  local gip_segment
+  if [ -n "\${GIP_PROMPT_DEBUG_LOG:-}" ]; then
+    gip_segment="$(GIP_PROMPT_SHELL=bash ${promptCommand} 2>>"\${GIP_PROMPT_DEBUG_LOG}")" || return
+  else
+    gip_segment="$(GIP_PROMPT_SHELL=bash ${promptCommand} 2>/dev/null)" || return
+  fi
+  if [ -n "$gip_segment" ]; then
+    case "$GIP_ORIGINAL_PS1" in
+      *$'\\n'*|*'\\n'*)
+        printf '%s ' "$gip_segment"
+        ;;
+      *)
+        printf '%s\\n\\001\\002' "$gip_segment"
+        ;;
+    esac
+  fi
+}
+
+if [ -z "\${GIP_ORIGINAL_PS1+x}" ]; then
+  GIP_ORIGINAL_PS1="$PS1"
+fi
+
+PS1='$(_gip_prompt_segment)'"\${GIP_ORIGINAL_PS1}"
+${PROMPT_BLOCK_END}
+`;
+}
+export function renderCompletionBlock(shell) {
+    return `${COMPLETION_BLOCK_START}
+${generateCompletionScript(shell).trimEnd()}
+${COMPLETION_BLOCK_END}
+`;
+}
+export function renderShellSessionBlock(shell) {
+    return `${SHELL_BLOCK_START}
+${renderSessionCommandWrapper(shell).trimEnd()}
+${SHELL_BLOCK_END}
+`;
+}
+function renderSessionCommandWrapper(shell) {
+    if (shell === "fish") {
+        return `function gip
+    if test (count $argv) -gt 0; and test "$argv[1]" = now; and not contains -- --help $argv; and not contains -- -h $argv
+        command gip $argv --exports --shell fish | source
+    else
+        command gip $argv
+    end
+end
+`;
+    }
+    const shellName = shell === "zsh" ? "zsh" : "bash";
+    return `gip() {
+  if [ "\${1:-}" = "now" ]; then
+    local gip_arg
+    for gip_arg in "$@"; do
+      case "$gip_arg" in
+        --help|-h)
+          command gip "$@"
+          return
+          ;;
+      esac
+    done
+    local gip_session
+    gip_session="$(command gip "$@" --exports --shell ${shellName})" || return
+    eval "$gip_session"
+  else
+    command gip "$@"
+  fi
+}
+`;
+}
+function renderPromptCommand(promptFormat) {
+    if (promptFormat === "auto") {
+        return "gip prompt";
+    }
+    return `gip prompt --format ${promptFormat}`;
+}
+export function removeShellPromptBlock(text) {
+    return text.replace(PROMPT_BLOCK_PATTERN, "").trimEnd();
+}
+export function removeShellCompletionBlock(text) {
+    return text.replace(COMPLETION_BLOCK_PATTERN, "").trimEnd();
+}
+export function removeShellSessionBlock(text) {
+    return text.replace(SHELL_BLOCK_PATTERN, "").trimEnd();
+}
+export function getDefaultShellConfigPath(shell) {
+    const home = homedir();
+    if (shell === "zsh") {
+        return join(home, ".zshrc");
+    }
+    if (shell === "bash") {
+        return join(home, ".bashrc");
+    }
+    return join(home, ".config", "fish", "config.fish");
+}
+function appendManagedBlock(text, block) {
+    const trimmed = text.trimEnd();
+    if (!trimmed) {
+        return block;
+    }
+    return `${trimmed}\n\n${block}`;
+}
+async function writeIfChanged(path, current, next) {
+    if (next === current) {
+        return { path, changed: false };
+    }
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, next);
+    return { path, changed: true };
+}
+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 escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}