automata-cli 0.11.0-develop.477 → 0.11.0-develop.485

package/dist/index.js

@@ -458,6 +458,7 @@ function parseOrigin(rawUrl) {
 
 // src/config/azdoService.ts
 import { spawnSync as spawnSync2 } from "child_process";
+var UNRESOLVED_THREAD_STATUSES = /* @__PURE__ */ new Set(["active", "pending"]);
 function run(cmd, args) {
   const result = spawnSync2(cmd, args, { encoding: "utf8" });
   if (result.error) {
@@ -564,6 +565,32 @@ function getPrInfo(branch) {
   }
   return toPrInfo(pr, (pr.checks ?? []).map(toPrCheck));
 }
+function getPrComments(branch) {
+  const listed = runJson(
+    ["pr", "list", "--branch", branch, "--status", "active"],
+    "Failed to list Azure DevOps pull requests. Is `azdo` installed and authenticated?"
+  );
+  const pr = listed.pullRequests[0];
+  if (pr === void 0) return null;
+  const output = runJson(
+    ["pr", "comments", "--pr-number", String(pr.id), "--exclude-resolved", "--code-related-only", "--exclude-system"],
+    "Failed to read the Azure DevOps pull request threads."
+  );
+  const comments = [];
+  for (const thread of output.threads) {
+    if (!UNRESOLVED_THREAD_STATUSES.has(thread.status) || thread.threadContext === null) continue;
+    const first = thread.comments.find((c) => c.commentType !== "system");
+    if (first === void 0) continue;
+    comments.push({
+      author: first.author ?? "Unknown",
+      body: first.content,
+      path: thread.threadContext,
+      line: thread.line,
+      createdAt: first.publishedAt ?? ""
+    });
+  }
+  return comments;
+}
 
 // src/remote/backend.ts
 var AZDO_GAP_DOC = "docs/azdo-gap.md";
@@ -1316,10 +1343,11 @@ function getPrCommentsGh(branch) {
     };
   });
 }
-function getPrComments(branch) {
+function getPrComments2(branch) {
   const config = readConfig();
   if (selectBackend(config) === "azdo") {
-    return "unsupported";
+    assertAzdoRemote();
+    return getPrComments(branch);
   }
   return getPrCommentsGh(branch);
 }
@@ -1332,11 +1360,10 @@ function resolveCurrentBranchComments() {
   }
   let raw;
   try {
-    raw = getPrComments(branch);
+    raw = getPrComments2(branch);
   } catch (err) {
     return { ok: false, kind: "error", message: err.message };
   }
-  if (raw === "unsupported") return { ok: false, kind: "unsupported" };
   if (raw === null) return { ok: false, kind: "no-pr", branch };
   return { ok: true, branch, comments: raw };
 }
@@ -1782,12 +1809,7 @@ var CONTROL_CHARS_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
 function sanitizeText(text) {
   return text.replace(ANSI_ESCAPE_RE, "").replace(CONTROL_CHARS_RE, "");
 }
-var getPrCommentsCmd = new Command2("get-pr-comments").description("List open (unresolved) review comments on the pull request for the current branch (GitHub only)").option("--json", "Output as JSON array").addHelpText(
-  "after",
-  `
-Only GitHub (remoteType: gh) is supported. Azure DevOps is not supported.
-See docs/azdo-gap.md for details.`
-).action((options) => {
+var getPrCommentsCmd = new Command2("get-pr-comments").description("List open (unresolved) review comments on the pull request for the current branch").option("--json", "Output as JSON array").action((options) => {
   let branch;
   try {
     branch = getCurrentBranch();
@@ -1798,19 +1820,12 @@ See docs/azdo-gap.md for details.`
   }
   let comments;
   try {
-    comments = getPrComments(branch);
+    comments = getPrComments2(branch);
   } catch (err) {
     process.stderr.write(`Error: ${err.message}
 `);
     process.exit(1);
   }
-  if (comments === "unsupported") {
-    process.stderr.write(
-      `Error: ${azdoUnsupportedMessage("get-pr-comments")}
-`
-    );
-    process.exit(1);
-  }
   if (comments === null) {
     process.stderr.write(`Error: No pull request found for branch: ${branch}
 `);
@@ -2528,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(
@@ -3452,13 +3500,6 @@ var executeFixCommentsCmd = addAiOptions(
 `);
       process.exit(1);
     }
-    if (result.kind === "unsupported") {
-      process.stderr.write(
-        `Error: ${azdoUnsupportedMessage("fix-comments")}
-`
-      );
-      process.exit(1);
-    }
     process.stderr.write(`Error: No pull request found for branch: ${result.branch}
 `);
     process.exit(1);
@@ -8244,11 +8285,135 @@ function toPlanJson(decision) {
 
 // src/commands/conductor.ts
 import { Command as Command7 } from "commander";
+
+// 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 (target.state === "closed") {
+        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 {
@@ -8304,8 +8469,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();
@@ -8314,8 +8480,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.477",
+  "version": "0.11.0-develop.485",
   "description": "Automata CLI tool",
   "type": "module",
   "engines": {