@autoclawd/autoclawd 1.1.23 → 1.1.24

package/dist/index.js

@@ -56,6 +56,10 @@ var SafetyConfigSchema = z.object({
   branchPrefix: z.string().default("autoclawd/"),
   maxFileChanges: z.number().min(1).optional()
 });
+var IntegrationConfigSchema = z.object({
+  crossBranchValidate: z.boolean().default(true),
+  maxCrossBranchIterations: z.number().min(1).max(10).default(3)
+});
 var ConfigSchema = z.object({
   linear: LinearConfigSchema,
   github: GitHubConfigSchema,
@@ -63,6 +67,7 @@ var ConfigSchema = z.object({
   agent: AgentConfigSchema.default({}),
   webhook: WebhookConfigSchema.default({}),
   safety: SafetyConfigSchema.default({}),
+  integration: IntegrationConfigSchema.default({}),
   maxConcurrent: z.number().default(1),
   validate: z.array(z.string()).optional()
   // Global default validation commands
@@ -72,8 +77,9 @@ var RepoLocalConfigSchema = z.object({
   base: z.string().default("main"),
   agent: AgentConfigSchema.partial().optional(),
   docker: DockerConfigSchema.partial().optional(),
-  validate: z.array(z.string()).optional()
+  validate: z.array(z.string()).optional(),
   // Validation commands to run before PR
+  integration: IntegrationConfigSchema.partial().optional()
 });
 function resolveEnvVars(obj) {
   if (typeof obj === "string") {
@@ -135,8 +141,12 @@ function mergeConfigs(host, local) {
     ...host.docker,
     ...local?.docker
   });
+  const integration = IntegrationConfigSchema.parse({
+    ...host.integration,
+    ...local?.integration
+  });
   const validate = local?.validate ?? host.validate;
-  return { agent, docker: docker2, prompt: local?.prompt, validate };
+  return { agent, docker: docker2, prompt: local?.prompt, validate, integration };
 }
 function parseRepoFromLabels(labels) {
   for (const label of labels) {
@@ -411,6 +421,31 @@ async function addBranchLabel(client, ticketId, branchName) {
     log.debug(`Could not add branch label: ${err instanceof Error ? err.message : err}`);
   }
 }
+async function findTicketsWithLabel(client, teamId, labelName) {
+  const team = await client.team(teamId);
+  const teamLabels = await team.labels();
+  const label = teamLabels.nodes.find((l) => l.name === labelName);
+  if (!label) return [];
+  const issues = await label.issues({ first: 50 });
+  const tickets = [];
+  for (const issue of issues.nodes) {
+    const labels = await issue.labels();
+    const labelNames = labels.nodes.map((l) => l.name);
+    const repoUrl = parseRepoFromLabels(labelNames);
+    const baseBranch = parseBaseFromLabels(labelNames);
+    tickets.push({
+      id: issue.id,
+      identifier: issue.identifier,
+      title: issue.title,
+      description: issue.description ?? "",
+      labels: labelNames,
+      repoUrl,
+      baseBranch,
+      url: issue.url
+    });
+  }
+  return tickets;
+}
 async function failTicket(client, ticketId, reason) {
   await client.createComment({
     issueId: ticketId,
@@ -630,6 +665,21 @@ async function enableAutoMerge(octokit, opts) {
     }
   }, { label: "GitHub auto-merge", retryIf: isTransientError });
 }
+async function findSiblingPRs(octokit, opts) {
+  const { owner, repo } = parseRepoUrl(opts.repoUrl);
+  const { data: prs } = await octokit.rest.pulls.list({
+    owner,
+    repo,
+    base: opts.baseBranch,
+    state: "open"
+  });
+  return prs.filter((pr) => pr.head.ref !== opts.excludeHead && pr.head.ref.startsWith(opts.branchPrefix)).map((pr) => ({
+    number: pr.number,
+    head: pr.head.ref,
+    base: pr.base.ref,
+    title: pr.title
+  }));
+}
 async function retargetPR(octokit, opts) {
   return retry(async () => {
     const { owner, repo } = parseRepoUrl(opts.repoUrl);
@@ -1516,7 +1566,7 @@ function countRuns() {
 }
 
 // src/worker.ts
-function buildPrompt(ticket, repoPrompt) {
+function buildPrompt(ticket, repoPrompt, siblings) {
   const parts = [];
   if (repoPrompt) {
     parts.push(repoPrompt);
@@ -1527,6 +1577,17 @@ function buildPrompt(ticket, repoPrompt) {
   if (ticket.description) {
     parts.push(ticket.description);
   }
+  if (siblings && siblings.length > 0) {
+    parts.push("");
+    parts.push("## Related Tickets (being worked on in parallel branches)");
+    parts.push("The following tickets target the same codebase and may be worked on concurrently.");
+    parts.push("Ensure your implementation is compatible \u2014 use consistent type definitions, interfaces, and patterns.");
+    parts.push("");
+    for (const sib of siblings) {
+      const desc = sib.description ? sib.description.length > 300 ? sib.description.slice(0, 300) + "..." : sib.description : "(no description)";
+      parts.push(`- **${sib.identifier}: ${sib.title}** \u2014 ${desc}`);
+    }
+  }
   parts.push("");
   parts.push("## Instructions");
   parts.push("- Start by reading CLAUDE.md if it exists \u2014 it has project-specific guidance");
@@ -1665,6 +1726,97 @@ function buildValidationFixPrompt(failures) {
   parts.push("- When done, include [autoclawd:done] in your output");
   return parts.join("\n");
 }
+async function runCrossBranchValidation(container, validate, siblingBranches, ticketId) {
+  const results = [];
+  for (const siblingBranch of siblingBranches) {
+    log.ticket(ticketId, `Cross-branch check: trial merge with ${siblingBranch}`);
+    const fetchResult = await exec(container, ["git", "fetch", "origin", siblingBranch], {
+      user: "autoclawd",
+      env: ["HOME=/home/autoclawd"],
+      timeout: 6e4
+    });
+    if (fetchResult.exitCode !== 0) {
+      log.ticket(ticketId, `  Could not fetch ${siblingBranch}, skipping`);
+      continue;
+    }
+    const mergeResult = await exec(container, [
+      "git",
+      "merge",
+      "--no-commit",
+      "--no-ff",
+      `origin/${siblingBranch}`
+    ], {
+      user: "autoclawd",
+      env: ["HOME=/home/autoclawd"],
+      timeout: 6e4
+    });
+    if (mergeResult.exitCode !== 0) {
+      const mergeOutput = (mergeResult.stdout + mergeResult.stderr).trim();
+      const diffResult = await exec(container, ["git", "diff", "--diff-filter=U"], {
+        user: "autoclawd",
+        env: ["HOME=/home/autoclawd"],
+        timeout: 1e4
+      });
+      const conflictDetail = diffResult.stdout.trim();
+      const output = [
+        mergeOutput,
+        "",
+        "Conflict details (files with conflict markers):",
+        conflictDetail || "(no diff available)"
+      ].join("\n").slice(-3e3);
+      results.push({
+        branch: siblingBranch,
+        failures: [{
+          command: `git merge origin/${siblingBranch}`,
+          exitCode: mergeResult.exitCode,
+          output
+        }]
+      });
+      await exec(container, ["git", "merge", "--abort"], {
+        user: "autoclawd",
+        env: ["HOME=/home/autoclawd"],
+        timeout: 1e4
+      });
+      continue;
+    }
+    const failures = await runValidation(container, validate, ticketId);
+    results.push({ branch: siblingBranch, failures });
+    await exec(container, ["git", "merge", "--abort"], {
+      user: "autoclawd",
+      env: ["HOME=/home/autoclawd"],
+      timeout: 1e4
+    });
+  }
+  return results;
+}
+function buildCrossBranchFixPrompt(crossResults) {
+  const parts = [];
+  parts.push("## Cross-Branch Compatibility Issues");
+  parts.push("");
+  parts.push("Your branch was trial-merged with sibling branches that target the same codebase.");
+  parts.push("The following issues were found. You must fix YOUR code to be compatible \u2014 do not assume the sibling is wrong.");
+  parts.push("");
+  for (const { branch, failures } of crossResults) {
+    if (failures.length === 0) continue;
+    parts.push(`### Conflicts with \`${branch}\``);
+    for (const f of failures) {
+      parts.push(`#### \`${f.command}\` (exit code ${f.exitCode})`);
+      parts.push("```");
+      parts.push(f.output);
+      parts.push("```");
+      parts.push("");
+    }
+  }
+  parts.push("## Instructions");
+  parts.push("- Fix YOUR code to be compatible with the sibling branches");
+  parts.push("- Focus on: consistent type definitions, matching interfaces, compatible exports");
+  parts.push("- If there are merge conflicts in a file (e.g. src/index.ts), you MUST include BOTH your changes AND the sibling's changes in that file \u2014 fetch the sibling branch, look at their version of the file, and make yours include both sets of changes");
+  parts.push("- To see what the sibling added: run `git diff main..origin/<sibling-branch> -- <file>`");
+  parts.push("- Run validation commands to verify your fix");
+  parts.push('- Commit your fixes with: git add -A && git commit -m "fix: resolve cross-branch compatibility"');
+  parts.push("- When done, include [autoclawd:done] in your output");
+  return parts.join("\n");
+}
 async function executeTicket(opts) {
   const { ticket, config, linearClient, octokit, force } = opts;
   const startedAt = /* @__PURE__ */ new Date();
@@ -1792,7 +1944,7 @@ async function executeTicket(opts) {
     log.ticket(ticket.identifier, "Cloned repo");
     const repoLocal = loadRepoLocalConfig(workDir);
     const actualBase = ticket.baseBranch ?? repoLocal?.base ?? detectedBase;
-    const { agent, docker: docker2, prompt, validate } = mergeConfigs(config, repoLocal);
+    const { agent, docker: docker2, prompt, validate, integration } = mergeConfigs(config, repoLocal);
     if (repoLocal) {
       log.ticket(ticket.identifier, "Loaded .autoclawd.yaml from repo");
     }
@@ -1826,7 +1978,46 @@ async function executeTicket(opts) {
       name: containerName
     });
     await setupRepo(container, { branchName });
-    const agentPrompt = buildPrompt(ticket, prompt);
+    let siblings = [];
+    try {
+      const siblingPRs = await findSiblingPRs(octokit, {
+        repoUrl: ticket.repoUrl,
+        baseBranch: actualBase,
+        excludeHead: branchName,
+        branchPrefix: config.safety.branchPrefix
+      });
+      for (const spr of siblingPRs) {
+        const match = spr.head.match(/^(?:autoclawd\/)([A-Za-z]+-\d+)/);
+        if (!match) continue;
+        const sibTicket = await fetchTicket(linearClient, match[1]);
+        if (sibTicket && sibTicket.identifier !== ticket.identifier) {
+          siblings.push({
+            identifier: sibTicket.identifier,
+            title: sibTicket.title,
+            description: sibTicket.description
+          });
+        }
+      }
+      if (ticket.baseBranch && siblings.length === 0) {
+        const baseLabelName = `base:${ticket.baseBranch}`;
+        const siblingTickets = await findTicketsWithLabel(linearClient, config.linear.teamId, baseLabelName);
+        for (const sib of siblingTickets) {
+          if (sib.identifier !== ticket.identifier) {
+            siblings.push({
+              identifier: sib.identifier,
+              title: sib.title,
+              description: sib.description
+            });
+          }
+        }
+      }
+      if (siblings.length > 0) {
+        log.ticket(ticket.identifier, `Found ${siblings.length} sibling ticket(s): ${siblings.map((s) => s.identifier).join(", ")}`);
+      }
+    } catch (err) {
+      log.debug(`Could not discover siblings: ${err instanceof Error ? err.message : err}`);
+    }
+    const agentPrompt = buildPrompt(ticket, prompt, siblings.length > 0 ? siblings : void 0);
     let agentResult = await runAgentLoop({
       container,
       agentConfig: agent,
@@ -1967,6 +2158,78 @@ async function executeTicket(opts) {
         }
       }
     }
+    if (integration.crossBranchValidate && validate && validate.length > 0) {
+      try {
+        const siblingPRs = await findSiblingPRs(octokit, {
+          repoUrl: ticket.repoUrl,
+          baseBranch: actualBase,
+          excludeHead: branchName,
+          branchPrefix: config.safety.branchPrefix
+        });
+        const siblingBranches = siblingPRs.map((s) => s.head);
+        if (siblingBranches.length > 0) {
+          log.ticket(ticket.identifier, `Running cross-branch validation against ${siblingBranches.length} sibling(s)`);
+          let crossIterations = 0;
+          const maxCrossIterations = integration.maxCrossBranchIterations;
+          while (crossIterations < maxCrossIterations) {
+            const crossResults = await runCrossBranchValidation(
+              container,
+              validate,
+              siblingBranches,
+              ticket.identifier
+            );
+            const failing = crossResults.filter((r) => r.failures.length > 0);
+            if (failing.length === 0) {
+              log.ticket(ticket.identifier, "Cross-branch validation passed");
+              break;
+            }
+            crossIterations++;
+            log.ticket(ticket.identifier, `Cross-branch issues with ${failing.map((f) => f.branch).join(", ")} (attempt ${crossIterations}/${maxCrossIterations})`);
+            const fixPrompt = buildCrossBranchFixPrompt(failing);
+            const fixResult = await runAgentLoop({
+              container,
+              agentConfig: { ...agent, maxIterations: 1 },
+              prompt: fixPrompt,
+              ticketId: ticket.identifier
+            });
+            agentResult = {
+              iterations: agentResult.iterations + fixResult.iterations,
+              success: fixResult.success,
+              lastOutput: fixResult.lastOutput
+            };
+            await commitAndPush(container, {
+              branchName,
+              ticketId: ticket.identifier,
+              title: ticket.title,
+              repoUrl: ticket.repoUrl,
+              githubToken: config.github.token,
+              branchPrefix: config.safety.branchPrefix,
+              maxFileChanges: config.safety.maxFileChanges
+            });
+          }
+          const finalCross = await runCrossBranchValidation(
+            container,
+            validate,
+            siblingBranches,
+            ticket.identifier
+          );
+          const stillFailing = finalCross.filter((r) => r.failures.length > 0);
+          if (stillFailing.length > 0) {
+            const allFailures = stillFailing.flatMap(
+              (r) => r.failures.map((f) => ({ ...f, command: `[cross: ${r.branch}] ${f.command}` }))
+            );
+            log.ticket(ticket.identifier, "Cross-branch validation still failing \u2014 adding warnings to PR");
+            await updatePRBody(octokit, {
+              repoUrl: ticket.repoUrl,
+              prNumber: pr.number,
+              body: buildPRBody({ validationWarnings: allFailures, commitCount: gitResult.commitCount })
+            });
+          }
+        }
+      } catch (err) {
+        log.debug(`Cross-branch validation error: ${err instanceof Error ? err.message : err}`);
+      }
+    }
     await reviewTicket(linearClient, config, ticket.id, `PR opened: ${pr.url}`);
     await addBranchLabel(linearClient, ticket.id, branchName);
     log.success(`${ticket.identifier} done \u2014 ${pr.url}`);
@@ -2223,6 +2486,7 @@ var WebhookServer = class {
     } else {
       return;
     }
+    this.recentlyRequeued.clear();
     if (this.activeInMemory.has(data.id) || isTicketActive(data.id)) {
       log.debug(`${data.identifier}: already active, ignoring`);
       return;
@@ -2288,6 +2552,7 @@ var WebhookServer = class {
           log.ticket(ticket.identifier, "Re-queued (waiting for dependency branch)");
           finishRun(ticket.id, "failed", result.error);
           removeFromProcessed(ticket.id);
+          this.recentlyRequeued.add(ticket.id);
           enqueue(ticket);
         } else if (result.success) {
           finishRun(ticket.id, "success");
@@ -2303,14 +2568,33 @@ var WebhookServer = class {
       this.drainQueue();
     });
   }
+  // Track recently requeued tickets to prevent cycling in the same drain
+  recentlyRequeued = /* @__PURE__ */ new Set();
   drainQueue() {
     if (this.pausedUntil > Date.now()) return;
-    while (this.activeInMemory.size < this.config.maxConcurrent) {
+    const tickets = [];
+    while (true) {
       const next = dequeue();
       if (!next) break;
-      if (this.activeInMemory.has(next.id)) continue;
-      log.ticket(next.identifier, `Dequeued (${getQueueLength()} remaining)`);
-      this.dispatch(next);
+      tickets.push(next);
+    }
+    tickets.sort((a, b) => {
+      const aStacked = a.baseBranch ? 1 : 0;
+      const bStacked = b.baseBranch ? 1 : 0;
+      return aStacked - bStacked;
+    });
+    for (const ticket of tickets) {
+      if (this.activeInMemory.has(ticket.id)) continue;
+      if (ticket.baseBranch && this.recentlyRequeued.has(ticket.id)) {
+        enqueue(ticket);
+        continue;
+      }
+      if (this.activeInMemory.size >= this.config.maxConcurrent) {
+        enqueue(ticket);
+        continue;
+      }
+      log.ticket(ticket.identifier, `Dequeued (${getQueueLength()} remaining)`);
+      this.dispatch(ticket);
     }
   }
 };