mergestorm 0.3.9 → 0.3.15

package/dist/commands/settings.js

@@ -0,0 +1,89 @@
+import { getSettings, patchSettings, } from "../api.js";
+import { loadConfig } from "../config.js";
+import { CommandError } from "../errors.js";
+import { present } from "../ui/present.js";
+import { buildConfigRows, canBrowse, openTabsBrowser } from "./browse.js";
+/**
+ * CLI flag → Bearer settings key. on|off only. The connected flags are
+ * read-only on the API and deliberately have no flag here.
+ */
+export const SETTINGS_FLAGS = {
+    "--auto-review": "auto_review_enabled",
+    "--auto-patch": "auto_patch_enabled",
+    "--vortex-thinking": "vortex_show_thinking_traces",
+    "--repo-overview": "repo_overview_enabled",
+    "--review-unit-land": "review_unit_land_prs_enabled",
+    "--cyclone-review-unit-land": "cyclone_review_unit_land_prs_enabled",
+    "--vortex-seam": "vortex_seam_specialist_enabled",
+};
+/** Parse `settings` argv. Accepts `--flag on|off` and `--flag=on|off`. */
+export function parseSettingsArgs(args) {
+    let json = false;
+    const patch = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        const eq = arg.indexOf("=");
+        const flag = eq >= 0 ? arg.slice(0, eq) : arg;
+        const key = SETTINGS_FLAGS[flag];
+        if (!key) {
+            throw new CommandError(`Unknown settings flag: ${flag}. See \`mergestorm --help\`.`, 2, "usage");
+        }
+        const value = eq >= 0 ? arg.slice(eq + 1) : args[++i];
+        if (value !== "on" && value !== "off") {
+            throw new CommandError(`${flag} takes on or off.`, 2, "usage");
+        }
+        patch[key] = value === "on";
+    }
+    return { json, patch };
+}
+/** Static printout of the GET/PATCH response shape (rows match the Config tab). */
+export function formatSettingsLines(settings) {
+    const rows = buildConfigRows(settings);
+    const labelWidth = Math.max(...rows.map((r) => r.label.length));
+    return rows.map((row) => {
+        const value = row.writable
+            ? row.value
+                ? "on"
+                : "off"
+            : row.value
+                ? "connected"
+                : "not connected";
+        return `  ${row.label.padEnd(labelWidth + 2)}${value}`;
+    });
+}
+export async function cmdSettings(args, opts = {}) {
+    const { json, patch } = parseSettingsArgs(args);
+    const hasPatch = Object.keys(patch).length > 0;
+    // Bare `settings` on a TTY: the tabbed browser, opened on Config.
+    if (!hasPatch && !json && canBrowse()) {
+        await openTabsBrowser("config");
+        return;
+    }
+    const cfg = await loadConfig();
+    let settings;
+    if (hasPatch) {
+        settings = await patchSettings(patch, cfg);
+    }
+    else {
+        const got = await getSettings(cfg);
+        if (!got) {
+            throw new CommandError("Settings are not available (offline or API too old). " +
+                "Try again or open https://mergestorm.ai/settings");
+        }
+        settings = got;
+    }
+    if (json) {
+        const text = JSON.stringify(settings, null, 2);
+        if (opts.mode === "shell") {
+            await present("Settings", text.split("\n"));
+            return;
+        }
+        console.log(text);
+        return;
+    }
+    await present("Settings", formatSettingsLines(settings));
+}

package/dist/commands/skill.d.ts

@@ -0,0 +1,20 @@
+export declare const SKILL_NAME = "mergestorm-review";
+export declare const PR_LOOP_SKILL_NAME = "mergestorm-pr-loop";
+export declare const SKILL_NAMES: readonly ["mergestorm-review", "mergestorm-pr-loop"];
+export type SkillName = (typeof SKILL_NAMES)[number];
+export declare const SKILL_USAGE = "usage:\n  mergestorm skill install --claude|--cursor [--json]\n\n  Copies mergestorm-review and mergestorm-pr-loop into this repo (git toplevel, else cwd):\n    --claude  .claude/skills/<name>/SKILL.md\n    --cursor  .cursor/skills/<name>/SKILL.md\n  Pass both flags to write both trees. Overwrites existing copies.";
+export type SkillTarget = "claude" | "cursor";
+export type SkillInstallRequest = {
+    help: boolean;
+    json: boolean;
+    targets: SkillTarget[];
+};
+export declare function parseSkillArgs(args: string[]): SkillInstallRequest;
+/** Prefer the git repo root so `mg skill install` from a subdir still lands in-project. */
+export declare function skillInstallRoot(cwd?: string): string;
+export declare function skillDestination(root: string, target: SkillTarget, name?: SkillName): string;
+export declare function resolveBundledSkillPath(fromFile?: string, name?: SkillName): string;
+export declare function writeSkillCopies(sourcePath: string, destinations: string[]): Promise<string[]>;
+export declare function cmdSkill(args: string[], opts?: {
+    cwd?: string;
+}): Promise<void>;

package/dist/commands/skill.js

@@ -0,0 +1,145 @@
+import { existsSync, readFileSync } from "node:fs";
+import { lstat, mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { CommandError, isCommandErrorCode } from "../errors.js";
+import { gitTopLevel } from "../repo-identity.js";
+import { present } from "../ui/present.js";
+export const SKILL_NAME = "mergestorm-review";
+export const PR_LOOP_SKILL_NAME = "mergestorm-pr-loop";
+export const SKILL_NAMES = [SKILL_NAME, PR_LOOP_SKILL_NAME];
+export const SKILL_USAGE = `usage:
+  mergestorm skill install --claude|--cursor [--json]
+
+  Copies mergestorm-review and mergestorm-pr-loop into this repo (git toplevel, else cwd):
+    --claude  .claude/skills/<name>/SKILL.md
+    --cursor  .cursor/skills/<name>/SKILL.md
+  Pass both flags to write both trees. Overwrites existing copies.`;
+export function parseSkillArgs(args) {
+    const [sub, ...rest] = args;
+    if (!sub || sub === "-h" || sub === "--help" || sub === "help") {
+        return { help: true, json: false, targets: [] };
+    }
+    if (sub !== "install") {
+        throw new CommandError(`${SKILL_USAGE}\nunknown skill subcommand: ${sub}`, 1, "usage");
+    }
+    let json = false;
+    const targets = [];
+    for (const arg of rest) {
+        if (arg === "--json") {
+            json = true;
+            continue;
+        }
+        if (arg === "--claude") {
+            if (!targets.includes("claude"))
+                targets.push("claude");
+            continue;
+        }
+        if (arg === "--cursor") {
+            if (!targets.includes("cursor"))
+                targets.push("cursor");
+            continue;
+        }
+        if (arg === "-h" || arg === "--help" || arg === "help") {
+            return { help: true, json: false, targets: [] };
+        }
+        throw new CommandError(`${SKILL_USAGE}\nunknown flag: ${arg}`, 1, "usage");
+    }
+    if (targets.length === 0) {
+        throw new CommandError(`${SKILL_USAGE}\npass --claude and/or --cursor`, 1, "usage");
+    }
+    return { help: false, json, targets };
+}
+/** Prefer the git repo root so `mg skill install` from a subdir still lands in-project. */
+export function skillInstallRoot(cwd = process.cwd()) {
+    try {
+        return gitTopLevel(cwd);
+    }
+    catch (err) {
+        if (isCommandErrorCode(err, "not_a_repo"))
+            return path.resolve(cwd);
+        throw err;
+    }
+}
+export function skillDestination(root, target, name = SKILL_NAME) {
+    if (target === "claude") {
+        return path.join(root, ".claude", "skills", name, "SKILL.md");
+    }
+    return path.join(root, ".cursor", "skills", name, "SKILL.md");
+}
+export function resolveBundledSkillPath(fromFile = import.meta.url, name = SKILL_NAME) {
+    const here = path.dirname(fileURLToPath(fromFile));
+    const packageRoot = path.resolve(here, "..", "..");
+    // The published package ships the review skill at skill/SKILL.md; extra
+    // skills sit beside it in per-name directories. The monorepo keeps every
+    // skill under skills/<name>/SKILL.md.
+    const candidates = name === SKILL_NAME
+        ? [
+            path.join(packageRoot, "skill", "SKILL.md"),
+            path.join(packageRoot, "..", "..", "skills", name, "SKILL.md"),
+        ]
+        : [
+            path.join(packageRoot, "skill", name, "SKILL.md"),
+            path.join(packageRoot, "..", "..", "skills", name, "SKILL.md"),
+        ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate))
+            return candidate;
+    }
+    throw new CommandError(`${name} skill is missing (looked in ${candidates.join(" and ")})`);
+}
+async function assertNoSymlink(dest) {
+    const parts = dest.split(path.sep);
+    const marker = parts.findIndex((p) => p === ".claude" || p === ".cursor");
+    const first = marker === -1 ? parts.length - 1 : marker;
+    for (let i = first; i < parts.length; i++) {
+        const candidate = parts.slice(0, i + 1).join(path.sep);
+        let stat;
+        try {
+            stat = await lstat(candidate);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        if (stat.isSymbolicLink()) {
+            throw new CommandError(`refusing to write skill through symlink: ${candidate}`);
+        }
+    }
+}
+export async function writeSkillCopies(sourcePath, destinations) {
+    const body = readFileSync(sourcePath, "utf8");
+    const written = [];
+    for (const dest of destinations) {
+        await assertNoSymlink(dest);
+        await mkdir(path.dirname(dest), { recursive: true });
+        await writeFile(dest, body, "utf8");
+        written.push(dest);
+    }
+    return written;
+}
+export async function cmdSkill(args, opts = {}) {
+    const req = parseSkillArgs(args);
+    if (req.help) {
+        await present("Skill", SKILL_USAGE.split("\n"));
+        return;
+    }
+    const root = skillInstallRoot(opts.cwd);
+    const sources = {};
+    const written = [];
+    for (const name of SKILL_NAMES) {
+        const source = resolveBundledSkillPath(undefined, name);
+        sources[name] = source;
+        const destinations = req.targets.map((t) => skillDestination(root, t, name));
+        written.push(...(await writeSkillCopies(source, destinations)));
+    }
+    if (req.json) {
+        await present("Skill", JSON.stringify({ names: SKILL_NAMES, sources, written }, null, 2).split("\n"));
+        return;
+    }
+    await present("Skill", [
+        `  Installed ${SKILL_NAMES.join(" and ")}`,
+        ...written.map((dest) => `  ${dest}`),
+    ]);
+}

package/dist/commands/stack.d.ts

@@ -1,10 +1,26 @@
-import { adoptStack } from "../api.js";
+import { adoptStack, ensureUpperPark, listStacks, type StackDto } from "../api.js";
 import { loadConfig } from "../config.js";
 import { createPr, findOpenPrNumber } from "../gh.js";
 import { parseGithubOriginRepo } from "../git.js";
-import { branchExists, commitsAheadOf, pushBranch, tipCommitMessage, tipCommitSubject } from "../git-stack.js";
+import { branchExists, commitsAheadOf, fetchRemoteBranch, pushBranch, tipCommitMessage, tipCommitSubject } from "../git-stack.js";
 import { buildPrBodyFromCommit } from "../pr-body.js";
 import { loadStackMeta, saveStackMeta } from "../stack-meta.js";
+/** A registered stack layer that would become the parent of a new layer. */
+export type RegisteredParentHit = {
+    stackId: string;
+    owner: string;
+    repo: string;
+    branch: string;
+    prNumber: number;
+    position: number;
+};
+/** Find a registered stack layer whose branch matches `parentBranch`. */
+export declare function findRegisteredParent(stacks: StackDto[], parentBranch: string, owner?: string, repo?: string): RegisteredParentHit | null;
+/**
+ * Refuse silently growing an already-registered stack.
+ * Local unsubmitted parents are fine; only API-listed layers trip this.
+ */
+export declare function assertMayParentOntoRegistered(parentBranch: string, stacks: StackDto[], extend: boolean, verb: "create" | "submit", owner?: string, repo?: string): RegisteredParentHit | null;
 export declare function requireStackId(raw: string | undefined, usage: string): string;
 /** Parse `owner/repo#12` or `owner/repo 12`. */
 export declare function parseAdoptTarget(args: string[]): {
@@ -12,14 +28,29 @@ export declare function parseAdoptTarget(args: string[]): {
     repo: string;
     prNumber: number;
 };
+/** Empty + populated bodies for the TTY `stack list` panel. */
+export declare function buildStackListLines(stacks: StackDto[]): string[];
 /** Parse `stack create` argv into options. Exported for tests. */
 export declare function parseStackCreateArgs(args: string[]): {
     name?: string;
     onto?: string;
     trunk?: string;
+    extend: boolean;
+    asJson: boolean;
+};
+/** Parse `stack submit` argv. Exported for tests. */
+export declare function parseStackSubmitArgs(args: string[]): {
+    extend: boolean;
     asJson: boolean;
 };
 export declare function parseStackResetArgs(args: string[]): void;
+/** Injectable seams for unit tests. Production callers omit deps. */
+export type StackCreateDeps = {
+    cwd?: string;
+    listStacks?: typeof listStacks;
+    loadConfig?: typeof loadConfig;
+    parseGithubOriginRepo?: typeof parseGithubOriginRepo;
+};
 /** Injectable seams for unit tests (STRUCT-04). Production callers omit deps. */
 export type StackSubmitDeps = {
     cwd?: string;
@@ -29,6 +60,7 @@ export type StackSubmitDeps = {
     parseGithubOriginRepo?: typeof parseGithubOriginRepo;
     requireGh?: (cwd?: string) => void;
     branchExists?: typeof branchExists;
+    fetchRemoteBranch?: typeof fetchRemoteBranch;
     pushBranch?: typeof pushBranch;
     findOpenPrNumber?: typeof findOpenPrNumber;
     commitsAheadOf?: typeof commitsAheadOf;
@@ -37,7 +69,9 @@ export type StackSubmitDeps = {
     buildPrBodyFromCommit?: typeof buildPrBodyFromCommit;
     createPr?: typeof createPr;
     loadConfig?: typeof loadConfig;
+    listStacks?: typeof listStacks;
     adoptStack?: typeof adoptStack;
+    ensureUpperPark?: typeof ensureUpperPark;
 };
 export declare function cmdStackSubmit(args: string[], deps?: StackSubmitDeps): Promise<void>;
 export declare function cmdStack(args: string[]): Promise<void>;