automata-cli 0.11.0-develop.484 → 0.11.0-develop.492

package/dist/index.js

@@ -2543,6 +2543,39 @@ function assignPrToAgent(prNumber, agentUser) {
     );
   }
 }
+function getWatchTarget(id) {
+  const { owner, repo } = getRepoSlug();
+  const raw = ghJson(["api", `repos/${owner}/${repo}/issues/${String(id)}`], `read #${String(id)}`);
+  return {
+    number: raw.number,
+    kind: raw.pull_request === void 0 ? "issue" : "pr",
+    state: raw.state === "closed" ? "closed" : "open",
+    title: raw.title
+  };
+}
+function applyDiscovery(target, technique, value) {
+  const edit = target.kind === "pr" ? "pr" : "issue";
+  let flag;
+  let arg;
+  switch (technique) {
+    case "label":
+      flag = "--add-label";
+      arg = value;
+      break;
+    case "assignee":
+      flag = "--add-assignee";
+      arg = value;
+      break;
+    default:
+      throw new Error(
+        "issueDiscoveryTechnique `title-contains` cannot be applied to an existing item; use `label` or `assignee`."
+      );
+  }
+  const { stderr, status } = run4("gh", [edit, "edit", String(target.number), flag, arg]);
+  if (status !== 0) {
+    throw new Error(stderr.trim() || `Failed to apply the discovery setting to #${String(target.number)}.`);
+  }
+}
 function postMarker(_surface, number, body) {
   const { owner, repo } = getRepoSlug();
   const raw = ghJson(
@@ -8252,11 +8285,140 @@ function toPlanJson(decision) {
 
 // src/commands/conductor.ts
 import { Command as Command7 } from "commander";
+
+// src/conductor/replyDecision.ts
+function isWatchClosed(state) {
+  return state === "closed";
+}
+
+// src/conductor/watchList.ts
+function parseWatchId(raw) {
+  const text = raw.trim().replace(/^#/, "");
+  if (!/^[1-9]\d*$/.test(text)) return null;
+  const value = Number(text);
+  return Number.isSafeInteger(value) ? value : null;
+}
+function normalizeWatch(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    if (typeof entry === "number" && Number.isSafeInteger(entry) && entry > 0) seen.add(entry);
+  }
+  return [...seen];
+}
+function withWatched(list, ...ids) {
+  return normalizeWatch([...list, ...ids]);
+}
+function withoutWatched(list, id) {
+  return list.filter((entry) => entry !== id);
+}
+
+// src/commands/conductor.ts
 function fail2(message) {
   process.stderr.write(`Error: ${message}
 `);
   return 1;
 }
+function updateWatch(change) {
+  const raw = readRawConfig();
+  const current = normalizeWatch(raw.conductor?.watch);
+  const next = change(current);
+  if (next.length === current.length && next.every((id, i) => id === current[i])) return;
+  writeConfig({ ...raw, conductor: { ...raw.conductor, watch: next } });
+}
+function describe(target) {
+  return `${target.kind === "pr" ? "PR" : "issue"} #${String(target.number)} (${target.state}): ${target.title}`;
+}
+function pruneWatchList(config) {
+  const watch = normalizeWatch(config.conductor?.watch);
+  const dropped = [];
+  for (const id of watch) {
+    try {
+      const target = getWatchTarget(id);
+      if (isWatchClosed(target.state)) {
+        process.stdout.write(
+          `Conductor: dropped ${target.kind === "pr" ? "PR" : "issue"} #${String(id)} from the watch list (closed).
+`
+        );
+        dropped.push(id);
+      }
+    } catch (err) {
+      process.stderr.write(`Warning: could not check #${String(id)}, keeping it watched: ${err.message}
+`);
+    }
+  }
+  if (dropped.length > 0) updateWatch((current) => current.filter((id) => !dropped.includes(id)));
+}
+function loadGitHubConfig() {
+  const config = readRawConfig();
+  if (!isExplicitGitHub(config)) {
+    return fail2(
+      azdoUnsupportedMessage(
+        "conductor",
+        "It needs the GitHub APIs; set the remote with `automata config set type gh`."
+      )
+    );
+  }
+  return config;
+}
+function runWatchAdd(rawId) {
+  const id = parseWatchId(rawId);
+  if (id === null) return fail2(`"${rawId}" is not an issue or pull request number.`);
+  const config = loadGitHubConfig();
+  if (typeof config === "number") return config;
+  const technique = config.issueDiscoveryTechnique;
+  if (!technique) return fail2("No issue discovery technique configured. Run `automata config`.");
+  const value = (config.issueDiscoveryValue ?? "").trim();
+  if (technique !== "title-contains" && value.length === 0) {
+    return fail2("No issue discovery value configured. Run `automata config`.");
+  }
+  try {
+    const target = getWatchTarget(id);
+    if (target.state === "closed") return fail2(`${describe(target)} is closed; nothing to watch.`);
+    const followed = target.kind === "issue" ? (getOpenPrLinkMap().byIssue.get(id) ?? []).map((pr) => pr.number) : [];
+    applyDiscovery(target, technique, value);
+    updateWatch((current) => withWatched(current, id, ...followed));
+    process.stdout.write(`Watching ${describe(target)}.
+`);
+    for (const pr of followed) process.stdout.write(`Also following linked PR #${String(pr)}.
+`);
+    return 0;
+  } catch (err) {
+    return fail2(err.message);
+  }
+}
+function runWatchRemove(rawId) {
+  const id = parseWatchId(rawId);
+  if (id === null) return fail2(`"${rawId}" is not an issue or pull request number.`);
+  const before = normalizeWatch(readRawConfig().conductor?.watch);
+  if (!before.includes(id)) return fail2(`#${String(id)} is not on the watch list.`);
+  updateWatch((current) => withoutWatched(current, id));
+  process.stdout.write(`Stopped watching #${String(id)}.
+`);
+  return 0;
+}
+function runWatchList() {
+  const config = loadGitHubConfig();
+  if (typeof config === "number") return config;
+  const watch = normalizeWatch(config.conductor?.watch);
+  if (watch.length === 0) {
+    process.stdout.write("The watch list is empty.\n");
+    return 0;
+  }
+  for (const id of watch) {
+    try {
+      process.stdout.write(`${describe(getWatchTarget(id))}
+`);
+    } catch (err) {
+      process.stdout.write(`#${String(id)}: unavailable (${err.message})
+`);
+    }
+  }
+  return 0;
+}
+function exitWith(code) {
+  if (code !== 0) process.exit(code);
+}
 function runConductor() {
   let config;
   try {
@@ -8312,8 +8474,9 @@ function runConductor() {
     return 0;
   }
   try {
-    process.stdout.write(`Conductor: running as ${login2 ?? ""}. Nothing to do yet.
+    process.stdout.write(`Conductor: running as ${login2 ?? ""}.
 `);
+    pruneWatchList(config);
     return 0;
   } finally {
     lock.handle.release();
@@ -8322,8 +8485,16 @@ function runConductor() {
 var conductorCommand = new Command7("conductor").description(
   "Run one conductor tick as an allowed (human) account: verify the identity, take the conductor's own run lock, then act"
 ).action(() => {
-  const exitCode = runConductor();
-  if (exitCode !== 0) process.exit(exitCode);
+  exitWith(runConductor());
+});
+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) => {
+  exitWith(runWatchAdd(id));
+});
+conductorCommand.command("remove <id>").description("Stop watching an issue or pull request (the discovery label/assignee is left alone)").action((id) => {
+  exitWith(runWatchRemove(id));
+});
+conductorCommand.command("list").description("List the watched issues and pull requests").action(() => {
+  exitWith(runWatchList());
 });
 
 // src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "automata-cli",
-  "version": "0.11.0-develop.484",
+  "version": "0.11.0-develop.492",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {