mergestorm 0.3.64 → 0.3.67

package/dist/commands/whoami.js

@@ -1,9 +1,8 @@
-import { getMe } from "../api.js";
-import { apiBase, configPath, loadConfig, resolveApiKey } from "../config.js";
+import { accountLabel, getMe } from "../api.js";
+import { apiBase, configPath, listAccounts, loadConfig, resolveApiKey, settleAccountName } from "../config.js";
 import { CommandError } from "../errors.js";
 import { ansi } from "../ui/ansi.js";
 import { present } from "../ui/present.js";
-import { canBrowse, openTabsBrowser } from "./browse.js";
 export async function cmdWhoami(args, opts = {}) {
     const asJson = args.includes("--json");
     const cfg = await loadConfig();
@@ -11,15 +10,17 @@ export async function cmdWhoami(args, opts = {}) {
     if (!key) {
         throw new CommandError("Not logged in. Run `mergestorm login` (agents: `mergestorm login --start`, then `--finish`).");
     }
-    if (!asJson && canBrowse()) {
-        await openTabsBrowser("status");
-        return;
-    }
     const me = await getMe(cfg);
     if (!me) {
         throw new CommandError("Live account details unavailable. Could not verify account with /me.");
     }
+    const account = (await settleAccountName(cfg, me)) ?? accountLabel(me.account);
+    const accounts = (await listAccounts()).map((a) => a.name);
     const payload = {
+        account,
+        accounts,
+        github_login: me.account?.github_login ?? null,
+        email: me.account?.email ?? null,
         key_prefix: me.key.prefix,
         key_name: me.key.name ?? null,
         plan_key: me.plan_key ?? null,
@@ -37,9 +38,12 @@ export async function cmdWhoami(args, opts = {}) {
         console.log(text);
         return;
     }
-    const lines = [
-        `  Key      ${ansi.bold(String(payload.key_prefix))}${payload.key_name ? ` (${payload.key_name})` : ""}`,
-    ];
+    const lines = [`  Account  ${account ? ansi.bold(account) : "unknown (API too old to say)"}`];
+    lines.push(`  Key      ${ansi.bold(String(payload.key_prefix))}${payload.key_name ? ` (${payload.key_name})` : ""}`);
+    const others = accounts.filter((name) => name !== account);
+    if (others.length > 0) {
+        lines.push(`  Others   ${others.join(", ")} ${ansi.dim("· mergestorm account use <name>")}`);
+    }
     if (payload.plan_key) {
         lines.push(`  Plan     ${payload.plan_label_key ?? payload.plan_key}`);
     }

package/dist/config.d.ts

@@ -1,16 +1,69 @@
 export declare const DEFAULT_API = "https://api.mergestorm.ai";
+export declare const ACCOUNT_LIMIT = 3;
 export type Config = {
     apiKey?: string;
     apiBase?: string;
     ignoreEnv?: boolean;
+    account?: string;
+};
+export type StoredAccount = {
+    apiKey: string;
+    apiBase?: string;
+};
+export type AccountStore = {
+    accounts: Record<string, StoredAccount>;
+    activeAccount?: string;
+    apiBase?: string;
+    ignoreEnv?: boolean;
+};
+type StoreFile = AccountStore & {
+    apiKey?: string;
+};
+export type AccountSummary = {
+    name: string;
+    active: boolean;
+    keyPrefix: string;
+    apiBase: string;
+};
+export type NamedMe = {
+    account?: {
+        github_login?: string | null;
+        email?: string | null;
+    } | null;
 };
 export declare function mergestormHome(env?: NodeJS.ProcessEnv): string;
 export declare function configPath(): string;
+export declare function provisionalAccountName(apiKey: string): string;
+export declare function accountNameFromMe(me: NamedMe | null | undefined): string | null;
+export declare function serializeStore(store: AccountStore): StoreFile;
+export declare function migrateStore(raw: unknown): {
+    store: AccountStore;
+    migrated: boolean;
+};
+export declare function writeStore(store: AccountStore): Promise<void>;
+export declare function readStore(): Promise<AccountStore>;
+export declare function withAccount<T>(name: string | undefined, fn: () => Promise<T>): Promise<T>;
+export declare function requestedAccount(store: AccountStore, env?: NodeJS.ProcessEnv): string | undefined;
+export declare function selectAccountName(store: AccountStore, requested: string | undefined): string | undefined;
+export declare function configFor(store: AccountStore, name: string | undefined): Config;
 export declare function loadConfig(): Promise<Config>;
-export declare function saveConfig(cfg: Config): Promise<void>;
-export declare function clearConfig(): Promise<void>;
+export declare function accountLimitMessage(store: AccountStore): string;
+export declare function saveAccount(name: string, account: StoredAccount, opts?: {
+    activate?: boolean;
+}): Promise<AccountStore>;
+export declare function useAccount(name: string): Promise<AccountStore>;
+export declare function removeAccount(name: string): Promise<AccountStore>;
+export declare function renameAccount(from: string, to: string): Promise<AccountStore>;
+export declare function summarizeAccounts(store: AccountStore): AccountSummary[];
+export declare function listAccounts(): Promise<AccountSummary[]>;
+export declare function settleAccountName(cfg: Config, me: NamedMe | null | undefined): Promise<string | undefined>;
+export declare function splitAccountFlag(args: readonly string[]): {
+    account?: string;
+    args: string[];
+};
 export declare function apiBase(cfg: Config): string;
 export declare function resolveChatId(cfg: Config): string | undefined;
 export declare function resolveApiKey(cfg: Config): string | undefined;
 /** Short display form of a stored key (prefix only). */
 export declare function keyDisplay(key: string | undefined): string | null;
+export {};

package/dist/config.js

@@ -1,7 +1,10 @@
-import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
+import { CommandError } from "./errors.js";
 export const DEFAULT_API = "https://api.mergestorm.ai";
+export const ACCOUNT_LIMIT = 3;
+const KEY_PREFIX_LENGTH = "msk_live_".length + 4;
 export function mergestormHome(env = process.env) {
     const override = env.MERGESTORM_HOME?.trim();
     return override ? path.resolve(override) : path.join(homedir(), ".mergestorm");
@@ -9,25 +12,273 @@ export function mergestormHome(env = process.env) {
 export function configPath() {
     return path.join(mergestormHome(), "config.json");
 }
-export async function loadConfig() {
-    try {
-        const raw = await readFile(configPath(), "utf8");
-        return JSON.parse(raw);
+export function provisionalAccountName(apiKey) {
+    return apiKey.slice(0, KEY_PREFIX_LENGTH);
+}
+export function accountNameFromMe(me) {
+    const login = me?.account?.github_login?.trim();
+    if (login)
+        return login;
+    const email = me?.account?.email?.trim();
+    return email || null;
+}
+function cleanString(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function compact(store) {
+    const out = { accounts: store.accounts };
+    if (store.activeAccount && store.accounts[store.activeAccount])
+        out.activeAccount = store.activeAccount;
+    if (store.apiBase)
+        out.apiBase = store.apiBase;
+    if (store.ignoreEnv)
+        out.ignoreEnv = true;
+    return out;
+}
+function storedAccount(apiKey, apiBase) {
+    return apiBase ? { apiKey, apiBase } : { apiKey };
+}
+export function serializeStore(store) {
+    const out = compact(store);
+    const active = out.activeAccount ? out.accounts[out.activeAccount] : undefined;
+    if (!active)
+        return out;
+    out.apiKey = active.apiKey;
+    if (active.apiBase)
+        out.apiBase = active.apiBase;
+    else
+        delete out.apiBase;
+    return out;
+}
+export function migrateStore(raw) {
+    const obj = raw && typeof raw === "object" ? raw : {};
+    const ignoreEnv = obj.ignoreEnv === true ? true : undefined;
+    const apiBase = cleanString(obj.apiBase);
+    const apiKey = cleanString(obj.apiKey);
+    if (obj.accounts && typeof obj.accounts === "object") {
+        const accounts = {};
+        for (const [name, value] of Object.entries(obj.accounts)) {
+            const entry = value && typeof value === "object" ? value : {};
+            const key = cleanString(entry.apiKey);
+            if (!key)
+                continue;
+            accounts[name] = storedAccount(key, cleanString(entry.apiBase));
+        }
+        const requested = cleanString(obj.activeAccount);
+        let activeAccount = requested && Object.hasOwn(accounts, requested) ? requested : Object.keys(accounts)[0];
+        let migrated = false;
+        if (apiKey) {
+            const owner = Object.keys(accounts).find((name) => accounts[name].apiKey === apiKey);
+            if (!owner) {
+                if (Object.keys(accounts).length < ACCOUNT_LIMIT) {
+                    const name = provisionalAccountName(apiKey);
+                    accounts[name] = storedAccount(apiKey, apiBase);
+                    activeAccount = name;
+                    migrated = true;
+                }
+            }
+            else if (owner !== activeAccount) {
+                activeAccount = owner;
+                migrated = true;
+            }
+        }
+        else if (activeAccount) {
+            migrated = true;
+        }
+        const store = compact({ accounts, activeAccount, apiBase: activeAccount ? undefined : apiBase, ignoreEnv });
+        return { store, migrated };
     }
-    catch {
-        return {};
+    if (!apiKey) {
+        return { store: compact({ accounts: {}, apiBase, ignoreEnv }), migrated: Object.keys(obj).length > 0 };
     }
+    const name = provisionalAccountName(apiKey);
+    return {
+        store: compact({ accounts: { [name]: storedAccount(apiKey, apiBase) }, activeAccount: name, ignoreEnv }),
+        migrated: true,
+    };
 }
-export async function saveConfig(cfg) {
-    const dir = path.dirname(configPath());
-    await mkdir(dir, { recursive: true });
-    await writeFile(configPath(), JSON.stringify(cfg, null, 2) + "\n", {
+export async function writeStore(store) {
+    const file = configPath();
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(serializeStore(store), null, 2) + "\n", {
         encoding: "utf8",
         mode: 0o600,
     });
 }
-export async function clearConfig() {
-    await rm(configPath(), { force: true });
+export async function readStore() {
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(configPath(), "utf8"));
+    }
+    catch {
+        return { accounts: {} };
+    }
+    const { store, migrated } = migrateStore(raw);
+    if (migrated) {
+        try {
+            await writeStore(store);
+        }
+        catch {
+            return store;
+        }
+    }
+    return store;
+}
+function accountNames(store) {
+    return Object.keys(store.accounts);
+}
+function unknownAccountMessage(name, store) {
+    const names = accountNames(store);
+    if (names.length === 0) {
+        return `No account named "${name}". Nobody is logged in; run \`mergestorm login\`.`;
+    }
+    return `No account named "${name}". Accounts: ${names.join(", ")}.`;
+}
+let accountOverride;
+export async function withAccount(name, fn) {
+    if (!name)
+        return fn();
+    const previous = accountOverride;
+    accountOverride = name;
+    try {
+        return await fn();
+    }
+    finally {
+        accountOverride = previous;
+    }
+}
+export function requestedAccount(store, env = process.env) {
+    if (accountOverride)
+        return accountOverride;
+    if (store.ignoreEnv)
+        return undefined;
+    return env.MERGESTORM_ACCOUNT?.trim() || undefined;
+}
+export function selectAccountName(store, requested) {
+    if (!requested)
+        return store.activeAccount;
+    if (Object.hasOwn(store.accounts, requested))
+        return requested;
+    throw new CommandError(unknownAccountMessage(requested, store));
+}
+export function configFor(store, name) {
+    const account = name ? store.accounts[name] : undefined;
+    const cfg = {};
+    if (account && name) {
+        cfg.apiKey = account.apiKey;
+        cfg.account = name;
+    }
+    const base = account?.apiBase ?? store.apiBase;
+    if (base)
+        cfg.apiBase = base;
+    if (store.ignoreEnv)
+        cfg.ignoreEnv = true;
+    return cfg;
+}
+export async function loadConfig() {
+    const store = await readStore();
+    return configFor(store, selectAccountName(store, requestedAccount(store)));
+}
+export function accountLimitMessage(store) {
+    return `Already ${ACCOUNT_LIMIT} accounts: ${accountNames(store).join(", ")}. Remove one with \`mergestorm account remove <name>\` first.`;
+}
+export async function saveAccount(name, account, opts = {}) {
+    const store = await readStore();
+    if (!Object.hasOwn(store.accounts, name) && accountNames(store).length >= ACCOUNT_LIMIT) {
+        throw new CommandError(accountLimitMessage(store), 1, "account_limit");
+    }
+    store.accounts[name] = storedAccount(account.apiKey, account.apiBase);
+    if (opts.activate || !store.activeAccount)
+        store.activeAccount = name;
+    await writeStore(store);
+    return store;
+}
+export async function useAccount(name) {
+    const store = await readStore();
+    if (!Object.hasOwn(store.accounts, name))
+        throw new CommandError(unknownAccountMessage(name, store));
+    store.activeAccount = name;
+    await writeStore(store);
+    return store;
+}
+export async function removeAccount(name) {
+    const store = await readStore();
+    if (!Object.hasOwn(store.accounts, name))
+        throw new CommandError(unknownAccountMessage(name, store));
+    delete store.accounts[name];
+    if (store.activeAccount === name)
+        store.activeAccount = accountNames(store)[0];
+    await writeStore(store);
+    return store;
+}
+export async function renameAccount(from, to) {
+    const store = await readStore();
+    const account = store.accounts[from];
+    if (!account || from === to)
+        return store;
+    if (Object.hasOwn(store.accounts, to)) {
+        throw new CommandError(`An account named "${to}" already exists, so ${from} keeps its name.`);
+    }
+    delete store.accounts[from];
+    store.accounts[to] = account;
+    if (store.activeAccount === from)
+        store.activeAccount = to;
+    await writeStore(store);
+    return store;
+}
+export function summarizeAccounts(store) {
+    return Object.entries(store.accounts).map(([name, account]) => ({
+        name,
+        active: name === store.activeAccount,
+        keyPrefix: provisionalAccountName(account.apiKey),
+        apiBase: (account.apiBase ?? store.apiBase ?? DEFAULT_API).replace(/\/$/, ""),
+    }));
+}
+export async function listAccounts() {
+    return summarizeAccounts(await readStore());
+}
+export async function settleAccountName(cfg, me) {
+    if (!cfg.account || !cfg.apiKey || resolveApiKey(cfg) !== cfg.apiKey)
+        return cfg.account;
+    if (cfg.account !== provisionalAccountName(cfg.apiKey))
+        return cfg.account;
+    const name = accountNameFromMe(me);
+    if (!name || name === cfg.account)
+        return cfg.account;
+    try {
+        await renameAccount(cfg.account, name);
+    }
+    catch {
+        return cfg.account;
+    }
+    return name;
+}
+export function splitAccountFlag(args) {
+    const rest = [];
+    let account;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        let value;
+        if (arg === "--account") {
+            value = args[i + 1];
+            if (value === undefined || value.startsWith("-"))
+                value = "";
+            else
+                i += 1;
+        }
+        else if (arg.startsWith("--account=")) {
+            value = arg.slice("--account=".length);
+        }
+        else {
+            rest.push(arg);
+            continue;
+        }
+        if (!value.trim()) {
+            throw new CommandError("--account needs an account name. `mergestorm account list` shows them.", 1, "usage");
+        }
+        account = value.trim();
+    }
+    return account ? { account, args: rest } : { args: rest };
 }
 export function apiBase(cfg) {
     const fromEnv = cfg.ignoreEnv ? undefined : process.env.MERGESTORM_API_URL?.trim();

package/dist/errors.d.ts

@@ -2,7 +2,7 @@
  * Stable machine codes for CommandError control flow.
  * UX copy in `message` may change freely; match on `code`, never on message text.
  */
-export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "implicit_stack" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention" | "head_changed" | "base_changed" | "tree_mismatch" | "protected_branch" | "payload_too_large" | "unsupported_publication" | "publication_failed" | "git_failed" | "unknown_label" | "invalid_input" | "memory_off" | "memory_full" | "memory_unavailable";
+export type CommandErrorCode = "auth_invalid" | "api_timeout" | "not_a_repo" | "not_found" | "missing_api_key" | "registered_parent" | "implicit_stack" | "usage" | "review_quota" | "review_failed" | "review_timeout" | "rate_limited" | "cyclone_not_installed" | "pr_merged" | "pr_closed" | "not_stacked" | "draft" | "reserved_branch" | "supabase_unconfigured" | "cyclone_not_connected" | "account_limit" | "surge_other_account" | "cyclone_permission_missing" | "busy" | "adopt_failed" | "github_unreadable" | "stack_attention" | "head_changed" | "base_changed" | "tree_mismatch" | "protected_branch" | "payload_too_large" | "unsupported_publication" | "publication_failed" | "git_failed" | "unknown_label" | "invalid_input" | "memory_off" | "memory_full" | "memory_similar" | "memory_unavailable" | "web_unavailable" | "issue_not_approved" | "issue_review_unavailable";
 /** Stable one-shot exit codes for machine callers of `mergestorm review`. */
 export declare const REVIEW_EXIT: {
     readonly success: 0;

package/dist/gh.d.ts

@@ -10,7 +10,6 @@ export type GhResult = {
 };
 export type GhRunner = (args: string[], input?: string) => GhResult;
 export type GithubApi = "graphql" | "rest";
-export declare const GITHUB_API_ENV = "MERGESTORM_GITHUB_API";
 export declare function githubApiFromEnv(env?: NodeJS.ProcessEnv): GithubApi;
 export declare function isGraphqlEndpointBlocked(text: string): boolean;
 export declare class GraphqlBlockedError extends CommandError {
@@ -34,7 +33,6 @@ export declare function findOpenPrNumber(owner: string, repo: string, headBranch
     api?: GithubApi;
     gh?: GhRunner;
 }): number | null;
-export declare function findOpenPrNumberViaRest(owner: string, repo: string, headBranch: string, gh: GhRunner): number | null;
 export type NewPr = {
     base: string;
     head: string;
@@ -63,13 +61,11 @@ type GraphqlSpawn = (command: string, args: string[], options: {
     encoding: "utf8";
     input: string;
 }) => GraphqlSpawnResult;
-export declare const CREATE_PR_BATCH_SIZE = 5;
 export declare function ghGraphql(request: GraphqlRequest, cwd?: string, spawn?: GraphqlSpawn): GraphqlResponse;
 export declare function chunkCreatePrs<T>(items: readonly T[], size?: number): T[][];
 export declare function buildCreatePrsMutation(repositoryId: string, prs: readonly NewPr[]): GraphqlRequest;
 export declare function fetchRepositoryId(owner: string, repo: string, graphql: GraphqlRunner): string;
 export declare function createPrsOnRepository(repositoryId: string, prs: readonly NewPr[], graphql: GraphqlRunner): number[];
-export declare function createPrsViaRest(owner: string, repo: string, prs: readonly NewPr[], gh: GhRunner, opened?: readonly number[]): number[];
 export declare function createPrs(input: {
     owner: string;
     repo: string;

package/dist/gh.js

@@ -1,6 +1,6 @@
 import { spawnSync } from "node:child_process";
 import { CommandError } from "./errors.js";
-export const GITHUB_API_ENV = "MERGESTORM_GITHUB_API";
+const GITHUB_API_ENV = "MERGESTORM_GITHUB_API";
 export function githubApiFromEnv(env = process.env) {
     return env[GITHUB_API_ENV]?.trim().toLowerCase() === "rest" ? "rest" : "graphql";
 }
@@ -83,7 +83,7 @@ function findOpenPrNumberViaGraphql(owner, repo, headBranch, gh) {
     }
     return firstPrNumber(res.stdout);
 }
-export function findOpenPrNumberViaRest(owner, repo, headBranch, gh) {
+function findOpenPrNumberViaRest(owner, repo, headBranch, gh) {
     const res = gh([
         "api",
         "-X",
@@ -111,7 +111,7 @@ function firstPrNumber(stdout) {
         throw new CommandError(`Failed to parse PR list response: ${e instanceof Error ? e.message : String(e)}`);
     }
 }
-export const CREATE_PR_BATCH_SIZE = 5;
+const CREATE_PR_BATCH_SIZE = 5;
 export function ghGraphql(request, cwd = process.cwd(), spawn = spawnSync) {
     const result = spawn("gh", ["api", "graphql", "--input", "-"], {
         cwd,
@@ -231,7 +231,7 @@ function restErrorText(res) {
         return body.message.trim();
     return res.stderr;
 }
-export function createPrsViaRest(owner, repo, prs, gh, opened = []) {
+function createPrsViaRest(owner, repo, prs, gh, opened = []) {
     const numbers = [...opened];
     for (const pr of prs.slice(numbers.length)) {
         const res = gh(["api", "-X", "POST", `repos/${owner}/${repo}/pulls`, "--input", "-"], JSON.stringify({ title: pr.title, head: pr.head, base: pr.base, body: pr.body }));

package/dist/git.d.ts

@@ -1,4 +1,4 @@
-export declare function git(args: string[], cwd?: string): string;
+export declare function git(args: string[], cwd?: string, env?: NodeJS.ProcessEnv): string;
 /** Parse `origin` remote into GitHub owner/repo when possible. */
 export declare function parseGithubOriginRepo(cwd?: string): {
     owner: string;

package/dist/git.js

@@ -2,9 +2,9 @@ import { spawnSync } from "node:child_process";
 import { realpathSync } from "node:fs";
 import { readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
-export function git(args, cwd = process.cwd()) {
+export function git(args, cwd = process.cwd(), env) {
     try {
-        const result = spawnSync("git", args, { cwd, encoding: "utf8" });
+        const result = spawnSync("git", args, { cwd, encoding: "utf8", env });
         if (result.status !== 0) {
             throw new Error(result.stderr?.trim() || `git ${args.join(" ")} failed`);
         }

package/dist/memory-api.d.ts

@@ -56,6 +56,7 @@ export declare function saveMemory(input: {
     kind: MemoryKind;
     repo?: string | null;
     chatId?: string | null;
+    keepBoth?: boolean;
 }, cfg?: Config): Promise<MemorySaved>;
 export declare function updateMemory(id: string, change: {
     text: string;

package/dist/memory-api.js

@@ -19,7 +19,7 @@ export function isMemoryKind(value) {
 export function isMemoryScope(value) {
     return typeof value === "string" && MEMORY_SCOPES.includes(value);
 }
-const KNOWN_CODES = new Set(["invalid_input", "not_found", "memory_off", "memory_full", "memory_unavailable", "payload_too_large"]);
+const KNOWN_CODES = new Set(["invalid_input", "not_found", "memory_off", "memory_full", "memory_similar", "memory_unavailable", "payload_too_large"]);
 function memoryFailure(status, body, retryAfterSeconds, action) {
     const row = (body && typeof body === "object" ? body : {});
     if (status === 429 || row.error === "rate_limited") {
@@ -52,7 +52,7 @@ export function searchMemories(input, cfg) {
     return call(cfg, `/api/v1/memories/search${query({ query: input.query, repo: input.repo, limit: input.limit, chat_id: input.chatId })}`, {}, [200], "Could not search memories");
 }
 export function saveMemory(input, cfg) {
-    const json = { text: input.text, kind: input.kind, ...(input.repo ? { repo: input.repo } : {}), ...(input.chatId ? { chat_id: input.chatId } : {}) };
+    const json = { text: input.text, kind: input.kind, ...(input.repo ? { repo: input.repo } : {}), ...(input.chatId ? { chat_id: input.chatId } : {}), ...(input.keepBoth ? { keep_both: true } : {}) };
     return call(cfg, "/api/v1/memories", { method: "POST", json }, [200, 201], "Could not save the memory");
 }
 export function updateMemory(id, change, cfg) {

package/dist/node-version.d.ts

@@ -1,5 +1,3 @@
-/** Mergestorm CLI requires Node 22+ (matches package.json engines). */
-export declare const MIN_NODE_MAJOR = 22;
 /** Parse major version from a Node version string (e.g. "22.22.3" → 22). */
 export declare function nodeMajor(version?: string): number;
 /**

package/dist/node-version.js

@@ -1,5 +1,5 @@
 /** Mergestorm CLI requires Node 22+ (matches package.json engines). */
-export const MIN_NODE_MAJOR = 22;
+const MIN_NODE_MAJOR = 22;
 /** Parse major version from a Node version string (e.g. "22.22.3" → 22). */
 export function nodeMajor(version = process.versions.node) {
     const major = Number.parseInt(version.split(".")[0] ?? "", 10);

package/dist/pr-body.d.ts

@@ -6,3 +6,7 @@
  * Turn `git log -1 --format=%B` output into a non-empty PR description.
  */
 export declare function buildPrBodyFromCommit(fullMessage: string): string;
+export declare function linkedIssueNumbers(repo: {
+    owner: string;
+    repo: string;
+}, ...texts: string[]): number[];

package/dist/pr-body.js

@@ -49,6 +49,21 @@ export function buildPrBodyFromCommit(fullMessage) {
     }
     return parts.join("\n") + "\n";
 }
+const LINKED_ISSUE_RE = /(?<![\w/#.-])(?:fix(?:es|ed)?|close[sd]?|resolve[sd]?)\s*:?\s+(?:([\w.-]+)\/([\w.-]+))?#(\d+)\b/gi;
+export function linkedIssueNumbers(repo, ...texts) {
+    const numbers = new Set();
+    const same = `${repo.owner}/${repo.repo}`.toLowerCase();
+    for (const text of texts) {
+        for (const match of text.matchAll(LINKED_ISSUE_RE)) {
+            if (match[1] && `${match[1]}/${match[2]}`.toLowerCase() !== same)
+                continue;
+            const n = Number(match[3]);
+            if (Number.isSafeInteger(n) && n > 0)
+                numbers.add(n);
+        }
+    }
+    return [...numbers].sort((a, b) => a - b);
+}
 function uniqueTrailers(trailers) {
     const seen = new Set();
     const out = [];

package/dist/repo-identity.d.ts

@@ -1,3 +1,5 @@
+/** Classify git "not a repo" failures once at the boundary; callers match on code. */
+export declare function isNotARepoGitError(detail: string): boolean;
 export declare function gitTopLevel(cwd?: string): string;
 /**
  * Each worktree has its own authoring state.
@@ -5,5 +7,4 @@ export declare function gitTopLevel(cwd?: string): string;
  */
 export declare function stableRepoId(cwd?: string): string;
 export declare function cliStacksRoot(): string;
-export declare function repoStateDir(cwd?: string, stacksRoot?: string): string;
 export declare function stackMetaPath(cwd?: string, stacksRoot?: string): string;

package/dist/repo-identity.js

@@ -5,16 +5,20 @@ import { mergestormHome } from "./config.js";
 import { CommandError } from "./errors.js";
 import { git } from "./git.js";
 /** Classify git "not a repo" failures once at the boundary; callers match on code. */
+export function isNotARepoGitError(detail) {
+    return /not a git repository|gitfile does not point to a valid repository/i.test(detail);
+}
+const classifierEnv = { ...process.env, LC_ALL: "C" };
 function rethrowIfNotARepo(err) {
     const detail = err instanceof Error ? err.message : String(err);
-    if (/not a git repository/i.test(detail)) {
+    if (isNotARepoGitError(detail)) {
         throw new CommandError(detail, 1, "not_a_repo");
     }
     throw err;
 }
 export function gitTopLevel(cwd = process.cwd()) {
     try {
-        return realpathSync(git(["rev-parse", "--show-toplevel"], cwd).trim());
+        return realpathSync(git(["rev-parse", "--show-toplevel"], cwd, classifierEnv).trim());
     }
     catch (err) {
         rethrowIfNotARepo(err);
@@ -27,7 +31,7 @@ export function gitTopLevel(cwd = process.cwd()) {
 export function stableRepoId(cwd = process.cwd()) {
     let raw;
     try {
-        raw = git(["rev-parse", "--git-dir"], cwd).trim();
+        raw = git(["rev-parse", "--git-dir"], cwd, classifierEnv).trim();
     }
     catch (err) {
         rethrowIfNotARepo(err);
@@ -41,7 +45,7 @@ export function stableRepoId(cwd = process.cwd()) {
 export function cliStacksRoot() {
     return path.join(mergestormHome(), "stacks");
 }
-export function repoStateDir(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
+function repoStateDir(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {
     return path.join(stacksRoot, stableRepoId(cwd));
 }
 export function stackMetaPath(cwd = process.cwd(), stacksRoot = cliStacksRoot()) {