automata-cli 0.12.0-develop.562 → 0.12.0-develop.567

package/dist/index.js

@@ -8696,6 +8696,39 @@ function coveredByWatchedIssue(watch, linkedPrs) {
   return covered;
 }
 
+// src/conductor/copilot.ts
+function isCopilotAuthor(author) {
+  return author.toLowerCase().includes("copilot");
+}
+function openCopilotThreads(surface) {
+  return surface.threads.filter(
+    (thread) => !thread.isResolved && thread.comments.length > 0 && isCopilotAuthor(thread.comments[0].author)
+  );
+}
+function newestCopilotAt(threads) {
+  let newest2 = null;
+  for (const comment of threads.flatMap((thread) => thread.comments)) {
+    if (isCopilotAuthor(comment.author) && (newest2 === null || comment.createdAt > newest2)) newest2 = comment.createdAt;
+  }
+  return newest2;
+}
+function renderCopilotBlock(number, threads, agentUser) {
+  const items = threads.map((thread) => {
+    const location = thread.line === null ? `${thread.path}:(file)` : `${thread.path}:${String(thread.line)}`;
+    const first = thread.comments[0];
+    const link = thread.url === null ? "" : ` (${thread.url})`;
+    return `- ${location}${link}
+  ${first.author}: ${first.body.trim().replaceAll("\n", "\n  ")}`;
+  });
+  return [
+    `Open Copilot review comments on pull request #${String(number)}:`,
+    "",
+    items.join("\n"),
+    "",
+    `Add to your reply an instruction to ${agentUser}: fix each comment above, and then resolve its review thread. Do not resolve a thread yourself.`
+  ].join("\n");
+}
+
 // src/conductor/replyDecision.ts
 function isWatchClosed(state) {
   return state === "closed";
@@ -8713,10 +8746,32 @@ function prConversation(surface) {
     kind: "pr",
     number: surface.pr.number,
     state: surface.pr.state === "OPEN" ? "open" : "closed",
-    messages: [...surface.messages, ...surface.threads.flatMap((thread) => thread.comments)]
+    messages: [...surface.messages, ...surface.threads.flatMap((thread) => thread.comments)],
+    copilotAt: newestCopilotAt(openCopilotThreads(surface))
   };
 }
 function decideConversation(conversation, p) {
+  const decision = decideByAgentMessage(conversation, p);
+  if (decision.kind === "reply") return decision;
+  return copilotTurn(conversation) ?? decision;
+}
+function copilotTurn(conversation) {
+  const copilotAt = conversation.copilotAt ?? null;
+  if (copilotAt === null || isWatchClosed(conversation.state)) return null;
+  let lastReply = "";
+  for (const message of conversation.messages) {
+    if (message.body.includes(REPLY_MARKER) && message.createdAt > lastReply) lastReply = message.createdAt;
+  }
+  if (copilotAt <= lastReply) return null;
+  return {
+    kind: "reply",
+    surface: conversation,
+    agentMessageAt: copilotAt,
+    copilot: true,
+    reason: `an unresolved Copilot review thread has a comment at ${copilotAt} that no conductor reply follows`
+  };
+}
+function decideByAgentMessage(conversation, p) {
   if (isWatchClosed(conversation.state)) {
     return { kind: "skip", surface: conversation, reason: "closed", detail: "the item is closed or merged" };
   }
@@ -8858,6 +8913,8 @@ function prSection(pr, participants) {
     lines.push("", `Unresolved review threads on pull request #${number}:`, "", threads.join("\n\n"));
   }
   lines.push("", `CI status of pull request #${number}:`, "", renderChecks(checks));
+  const copilot = openCopilotThreads(surface);
+  if (copilot.length > 0) lines.push("", renderCopilotBlock(surface.pr.number, copilot, participants.agentUser));
   return lines;
 }
 function composeConductorPrompt(input) {
@@ -8936,6 +8993,35 @@ function describeConductorExecution(execution) {
   return `${execution.executor}${model}${effort}`;
 }
 
+// src/conductor/automatic.ts
+var DEFAULT_INTERVAL_SECONDS = 60;
+function parseInterval(raw) {
+  if (raw === void 0) return DEFAULT_INTERVAL_SECONDS;
+  if (!/^\d+$/.test(raw.trim()) || !Number.isSafeInteger(Number(raw)) || Number(raw) < 1) {
+    return `--interval must be a positive whole number of seconds, got "${raw}".`;
+  }
+  return Number(raw);
+}
+async function runAutomatic(loop) {
+  if (loop.stopped()) {
+    loop.log("Conductor: stopped.");
+    return 0;
+  }
+  const result = await loop.tick();
+  if (result.open === 0) {
+    loop.log("Conductor: no open item is watched any more; leaving the loop.");
+    return 0;
+  }
+  if (loop.stopped()) {
+    loop.log("Conductor: stopped.");
+    return 0;
+  }
+  if (result.code !== 0) loop.log(`Conductor: the tick ended with exit code ${String(result.code)}; the next tick runs anyway.`);
+  loop.log(`Conductor: next tick in ${String(loop.intervalSeconds)} s.`);
+  await loop.sleep(loop.intervalSeconds);
+  return runAutomatic(loop);
+}
+
 // src/conductor/reply.ts
 function isComment(message) {
   return message.kind === "issue-comment" || message.kind === "pr-comment";
@@ -9304,6 +9390,10 @@ ${reply}
 `);
   return "replied";
 }
+function agentIsWorking(config) {
+  const status = inspectRunLock(config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes);
+  return status.kind === "held" || status.kind === "suspect";
+}
 async function conductItem(id, config, login2, participants, execution, dryRun, linkMap) {
   const label2 = `#${String(id)}`;
   let item;
@@ -9324,6 +9414,11 @@ async function conductItem(id, config, login2, participants, execution, dryRun,
     const stopped = verdict.decisions.find((decision) => decision.kind === "skip" && (decision.reason === "blocked" || decision.reason === "limit"));
     const why = stopped?.kind === "skip" ? `Conductor: ${label2} gets no reply: ${stopped.detail}.` : `Conductor: ${label2} needs no reply.`;
     process.stdout.write(`${why}
+`);
+    return "idle";
+  }
+  if (owed.kind === "reply" && owed.copilot === true && dryRun === void 0 && agentIsWorking(config)) {
+    process.stdout.write(`Conductor: ${label2} has open Copilot review threads, but the agent is working (the do-work run lock is held); waiting.
 `);
     return "idle";
   }
@@ -9600,17 +9695,63 @@ async function runConductor(options = {}) {
   }
 }
 async function runConductorTick(options) {
-  if (options.check === true && options.dryRun === true) {
-    return fail2("--check and --dry-run cannot be used together.");
-  }
+  const problem = optionsProblem(options);
+  if (problem !== null) return fail2(problem);
+  if (options.automatic === true) return runConductorAutomatic(options.interval);
   if (options.check === true) return runConductorCheck();
+  return (await runTick2(options)).code;
+}
+function optionsProblem(options) {
+  if (options.check === true && options.dryRun === true) return "--check and --dry-run cannot be used together.";
+  if (options.automatic !== true) {
+    return options.interval === void 0 ? null : "--interval needs --automatic.";
+  }
+  if (options.check === true || options.dryRun === true) return "--automatic cannot be used with --check or --dry-run.";
+  const interval = parseInterval(options.interval);
+  return typeof interval === "string" ? interval : null;
+}
+async function runConductorAutomatic(rawInterval) {
+  const intervalSeconds = parseInterval(rawInterval);
+  let stop = false;
+  let wake = null;
+  const onSignal = () => {
+    if (stop) process.exit(130);
+    stop = true;
+    process.stdout.write("Conductor: stopping after the current tick.\n");
+    wake?.();
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  try {
+    process.stdout.write(`Conductor: automatic mode, one tick every ${String(intervalSeconds)} s. Press Ctrl+C to stop.
+`);
+    return await runAutomatic({
+      intervalSeconds,
+      tick: () => runTick2({}),
+      stopped: () => stop,
+      log: (line) => process.stdout.write(`${line}
+`),
+      sleep: (seconds) => new Promise((resolve2) => {
+        const timer = setTimeout(resolve2, seconds * 1e3);
+        wake = () => {
+          clearTimeout(timer);
+          resolve2();
+        };
+      })
+    });
+  } finally {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+  }
+}
+async function runTick2(options) {
   const checked = preflight();
-  if ("problem" in checked) return fail2(checked.problem);
-  if (options.dryRun === true) return runConductorDryRun(checked);
+  if ("problem" in checked) return { code: fail2(checked.problem), open: null };
+  if (options.dryRun === true) return { code: await runConductorDryRun(checked), open: null };
   const { config, login: login2, participants, execution } = checked;
   const staleMinutes = config.doWork?.lockStaleMinutes ?? DEFAULT_DO_WORK.lockStaleMinutes;
   const lock = acquireConductorLock(staleMinutes);
-  if (!lock.ok) return reportHeldLock(lock.heldBy, lock.suspect, staleMinutes);
+  if (!lock.ok) return { code: reportHeldLock(lock.heldBy, lock.suspect, staleMinutes), open: null };
   try {
     process.stdout.write(`Conductor: running as ${login2}.
 `);
@@ -9633,7 +9774,7 @@ async function runConductorTick(options) {
         failed++;
       }
     }
-    return failed > 0 ? 1 : 0;
+    return { code: failed > 0 ? 1 : 0, open: watch.length };
   } finally {
     lock.handle.release();
   }
@@ -9643,7 +9784,7 @@ var conductorCommand = new Command7("conductor").description(
 ).option("--check", "Report what a tick would do, including pending prunes, and change nothing; exit 1 on a problem").option("--dry-run", "Run the model for each owed reply and print it instead of posting; no lock, no prune").option(
   "--verbose",
   "Trace every `git` and `gh` call with its duration and exit code, show the model's steps, and list the tool calls the run was denied"
-).action(async (options) => {
+).option("--automatic", "Run a tick every --interval seconds until no open item is watched (Ctrl+C stops it)").option("--interval <seconds>", "Seconds between two ticks with --automatic (default 60)").action(async (options) => {
   exitWith(await runConductor(options));
 });
 conductorCommand.command("add <id>").description("Watch an issue or pull request and make do-work pick it up (an issue also follows its linked PR)").action((id) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.12.0-develop.562",
+  "version": "0.12.0-develop.567",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {