merge-steward 0.8.12 → 0.9.0

package/dist/config.d.ts

@@ -31,6 +31,10 @@ export declare const stewardConfigSchema: z.ZodObject<{
     admissionLabel: z.ZodDefault<z.ZodString>;
     mergeQueueCheckName: z.ZodDefault<z.ZodString>;
     excludeBranches: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    autoResolvePatterns: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        glob: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>>;
     webhookSecret: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type StewardConfig = z.infer<typeof stewardConfigSchema>;

package/dist/config.js

@@ -33,6 +33,19 @@ export const stewardConfigSchema = z.object({
     mergeQueueCheckName: z.string().default(DEFAULT_MERGE_QUEUE_CHECK_NAME),
     /** Branch name patterns to exclude from admission (glob-style). */
     excludeBranches: z.array(z.string()).default(["release-please--*"]),
+    /**
+     * File patterns with regen commands for auto-resolving merge conflicts.
+     * When all conflicting files match a pattern, the command is run to regenerate them.
+     * Defaults to lockfile resolution for npm/pnpm/yarn.
+     */
+    autoResolvePatterns: z.array(z.object({
+        glob: z.string().min(1),
+        command: z.array(z.string()).min(1),
+    })).default([
+        { glob: "**/package-lock.json", command: ["npm", "install", "--package-lock-only"] },
+        { glob: "**/pnpm-lock.yaml", command: ["pnpm", "install", "--lockfile-only"] },
+        { glob: "**/yarn.lock", command: ["yarn", "install", "--mode", "update-lockfile"] },
+    ]),
     webhookSecret: z.string().optional(),
 });
 function readEnvFile(filePath) {

package/dist/github/shell-git.d.ts

@@ -4,14 +4,20 @@ export interface BotIdentity {
     name: string;
     email: string;
 }
+export interface AutoResolvePattern {
+    glob: string;
+    command: string[];
+}
 export declare class ShellGitOperations implements GitOperations, SpeculativeBranchBuilder {
     private readonly clonePath;
     private readonly repoFullName;
     private readonly gitBin;
     private readonly worktreeBase;
     private botIdentity;
+    private autoResolvePatterns;
     constructor(clonePath: string, repoFullName: string, gitBin?: string);
     setBotIdentity(identity: BotIdentity): void;
+    setAutoResolvePatterns(patterns: AutoResolvePattern[]): void;
     private git;
     /** Run a git command in a specific directory (worktree). */
     private gitIn;
@@ -27,10 +33,9 @@ export declare class ShellGitOperations implements GitOperations, SpeculativeBra
      */
     buildSpeculative(prBranch: string, baseBranch: string, specName: string, mergeMessage?: string): Promise<MergeResult>;
     /**
-     * During a merge conflict, check if the only unmerged files are lockfiles
-     * (package-lock.json). If so, resolve by regenerating from the merged
-     * package.json via `npm install --package-lock-only`.
+     * During a merge conflict, check if all unmerged files match a configured
+     * auto-resolve pattern. If so, regenerate them via the pattern's command.
      */
-    private tryResolveLockfileConflict;
+    private tryAutoResolveConflict;
     deleteSpeculative(specName: string): Promise<void>;
 }

package/dist/github/shell-git.js

@@ -12,12 +12,34 @@ function parseConflicts(stderr) {
     });
     return files.length > 0 ? files : undefined;
 }
+/** Check if a file path matches a glob pattern (simple suffix/wildcard match). */
+function matchesGlob(filePath, pattern) {
+    if (pattern.startsWith("**/")) {
+        return filePath.endsWith(pattern.slice(2));
+    }
+    if (pattern.startsWith("*/")) {
+        const name = filePath.split("/").pop() ?? filePath;
+        return name === pattern.slice(2);
+    }
+    return filePath === pattern || filePath.endsWith(`/${pattern}`);
+}
+/** If all conflicting files match a single auto-resolve pattern, return its command. */
+function detectAutoResolveCommand(conflictFiles, patterns) {
+    for (const pattern of patterns) {
+        if (conflictFiles.every((f) => matchesGlob(f, pattern.glob))) {
+            const [bin, ...args] = pattern.command;
+            return bin ? { bin, args } : undefined;
+        }
+    }
+    return undefined;
+}
 export class ShellGitOperations {
     clonePath;
     repoFullName;
     gitBin;
     worktreeBase;
     botIdentity;
+    autoResolvePatterns = [];
     constructor(clonePath, repoFullName, gitBin = "git") {
         this.clonePath = clonePath;
         this.repoFullName = repoFullName;
@@ -27,6 +49,9 @@ export class ShellGitOperations {
     setBotIdentity(identity) {
         this.botIdentity = identity;
     }
+    setAutoResolvePatterns(patterns) {
+        this.autoResolvePatterns = patterns;
+    }
     git(args, opts) {
         return exec(this.gitBin, ["-C", this.clonePath, ...args], {
             timeoutMs: opts?.timeoutMs ?? 120_000,
@@ -98,7 +123,7 @@ export class ShellGitOperations {
         if (result.exitCode !== 0) {
             const conflictFiles = parseConflicts(result.stderr);
             // Lockfile-only conflicts can be auto-resolved by regenerating.
-            if (await this.tryResolveLockfileConflict(wtPath)) {
+            if (await this.tryAutoResolveConflict(wtPath)) {
                 const sha = (await this.gitIn(wtPath, ["rev-parse", "HEAD"])).stdout.trim();
                 await this.git(["worktree", "remove", "--force", wtPath], { allowNonZero: true });
                 return { success: true, sha };
@@ -114,25 +139,28 @@ export class ShellGitOperations {
         return { success: true, sha };
     }
     /**
-     * During a merge conflict, check if the only unmerged files are lockfiles
-     * (package-lock.json). If so, resolve by regenerating from the merged
-     * package.json via `npm install --package-lock-only`.
+     * During a merge conflict, check if all unmerged files match a configured
+     * auto-resolve pattern. If so, regenerate them via the pattern's command.
      */
-    async tryResolveLockfileConflict(wtPath) {
+    async tryAutoResolveConflict(wtPath) {
+        if (this.autoResolvePatterns.length === 0)
+            return false;
         try {
             const unmerged = await this.gitIn(wtPath, ["diff", "--name-only", "--diff-filter=U"]);
             const files = unmerged.stdout.trim().split("\n").filter(Boolean);
-            if (files.length === 0 || !files.every((f) => f.endsWith("package-lock.json"))) {
+            if (files.length === 0)
+                return false;
+            const regenerate = detectAutoResolveCommand(files, this.autoResolvePatterns);
+            if (!regenerate)
                 return false;
-            }
             for (const file of files) {
                 await this.gitIn(wtPath, ["checkout", "--ours", "--", file]);
             }
-            const npmResult = await exec("npm", ["install", "--package-lock-only"], {
+            const result = await exec(regenerate.bin, regenerate.args, {
                 cwd: wtPath,
                 timeoutMs: 60_000,
             });
-            if (npmResult.exitCode !== 0)
+            if (result.exitCode !== 0)
                 return false;
             for (const file of files) {
                 await this.gitIn(wtPath, ["add", file]);

package/dist/server.js

@@ -24,6 +24,8 @@ async function createRepoInstance(config, logger, botIdentity) {
     const git = new ShellGitOperations(clone.path, config.repoFullName, config.gitBin);
     if (botIdentity)
         git.setBotIdentity(botIdentity);
+    if (config.autoResolvePatterns.length > 0)
+        git.setAutoResolvePatterns(config.autoResolvePatterns);
     const ci = new GitHubActionsRunner(config.repoFullName, config.requiredChecks);
     const github = new GitHubPRClient(config.repoFullName);
     const eviction = new GitHubCheckRunReporter(config.repoFullName, config.server.bind, config.server.port, config.server.publicBaseUrl, config.admissionLabel, config.mergeQueueCheckName);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "merge-steward",
-  "version": "0.8.12",
+  "version": "0.9.0",
   "description": "Serial merge queue for GitHub — rebase, CI-gate, and merge PRs one at a time",
   "type": "module",
   "repository": {