agentme 0.35.2 → 0.37.0

package/.xdrs/agentme/edrs/principles/skills/resolve-pr-comments/scripts/post-replies-github.js

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Applies resolve-pr-comments tracking-file drafts to a live GitHub PR, using the `gh`
+ * commands documented in github-connector's "Writing data" section. Delegates every
+ * tracking-file read/write to the sibling `update-section.js` script so there is exactly
+ * one place that understands the file format. Mirrors post-replies-azure-devops.js's
+ * interface and verify-after-write discipline for parity across both connectors.
+ *
+ * Every write is confirmed by an independent read-back before the tracking file is ever
+ * marked `pending-reply: applied` -- not because `gh` is known to exit 0 without persisting
+ * (unlike `az rest`, see azure-devops-connector's Known Issues), but so both scripts
+ * make the same guarantee and a GraphQL mutation's rarer partial-failure shape is still
+ * caught.
+ *
+ * Usage:
+ *   post-replies-github.js --pr-url <url> <tracking-file> [--dry-run] [--only <id>[,<id>...]]
+ *
+ * <url> is the PR's GitHub URL; owner/repo/PR number are all parsed from it.
+ * Processes every section whose `pending-reply:` is currently `drafted`, or exactly the
+ * `--only` ids (regardless of their current `pending-reply` state) when given. For each:
+ * skips posting if the exact reply text is already present (verified idempotency, never
+ * assumed), otherwise posts `reply-draft` per the section's `id` kind (`issue-comment` via
+ * the issue-comments endpoint, `review-comment` via the review-comments endpoint with
+ * `in_reply_to`) and verifies via a follow-up read; then, if `resolve-on-apply: true` and
+ * the kind is `review-comment` (the only resolvable kind), resolves the review thread via
+ * the `resolveReviewThread` GraphQL mutation and verifies `isResolved` too. Only after these
+ * checks pass does it mark `pending-reply: applied` (and `status: resolved`) via
+ * update-section.js. `GH_BIN` (default `gh`) overrides the CLI binary invoked, for testing
+ * with a stub.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const UPDATE_SECTION = path.join(__dirname, 'update-section.js');
+const [GH_BIN, ...GH_PREFIX_ARGS] = (process.env.GH_BIN || 'gh').split(' ');
+
+function parsePrUrl(url) {
+  const m = /^https:\/\/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/.exec(url);
+  if (!m) throw new Error(`unrecognized GitHub PR URL: ${url}`);
+  return { owner: m[1], repo: m[2], pr: m[3] };
+}
+
+// Rejoins hand-wrapped lines within a paragraph into one logical line, preserving genuine
+// blank-line paragraph breaks -- tolerant of drafts written either wrapped or unwrapped.
+function joinReplyDraft(rawText) {
+  const paragraphs = [];
+  let cur = [];
+  for (const line of rawText.split('\n')) {
+    if (line.trim() === '') {
+      if (cur.length) {
+        paragraphs.push(cur.join(' '));
+        cur = [];
+      }
+    } else {
+      cur.push(line.trimEnd());
+    }
+  }
+  if (cur.length) paragraphs.push(cur.join(' '));
+  return paragraphs.join('\n\n');
+}
+
+function parseArgs(argv) {
+  const args = { file: null, prUrl: null, dryRun: false, only: null };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--pr-url') args.prUrl = argv[++i];
+    else if (a === '--dry-run') args.dryRun = true;
+    else if (a === '--only') {
+      args.only = argv[++i]
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    } else rest.push(a);
+  }
+  [args.file] = rest;
+  return args;
+}
+
+function runUpdateSection(cmdArgs, input) {
+  return execFileSync('node', [UPDATE_SECTION, ...cmdArgs], { input, encoding: 'utf8' });
+}
+
+function listCandidateSections(file, only) {
+  const stdout = runUpdateSection(['list', file]);
+  const rows = [];
+  let cur = null;
+  for (const line of stdout.split('\n')) {
+    const idMatch = /^- id: (.*)$/.exec(line);
+    if (idMatch) {
+      if (cur) rows.push(cur);
+      cur = { id: idMatch[1] };
+      continue;
+    }
+    if (!cur) continue;
+    const fieldMatch = /^ {2}([\w-]+): ?(.*)$/.exec(line);
+    if (fieldMatch) cur[fieldMatch[1]] = fieldMatch[2];
+  }
+  if (cur) rows.push(cur);
+  return rows.filter((r) => (only ? only.includes(r.id) : r['pending-reply'] === 'drafted'));
+}
+
+function gh(args) {
+  return execFileSync(GH_BIN, [...GH_PREFIX_ARGS, ...args], { stdio: 'pipe' });
+}
+
+function ghJson(args) {
+  return JSON.parse(gh(args).toString());
+}
+
+function commentsEndpoint(ctx, kind) {
+  const { owner, repo, pr } = ctx;
+  return kind === 'review-comment' ? `repos/${owner}/${repo}/pulls/${pr}/comments` : `repos/${owner}/${repo}/issues/${pr}/comments`;
+}
+
+function findReviewThread(ctx, rootCommentId) {
+  const query = `query($owner:String!,$repo:String!,$pr:Int!){repository(owner:$owner,name:$repo){pullRequest(number:$pr){reviewThreads(first:100){nodes{id isResolved comments(first:1){nodes{databaseId}}}}}}}`;
+  const out = ghJson(['api', 'graphql', '-f', `query=${query}`, '-f', `owner=${ctx.owner}`, '-f', `repo=${ctx.repo}`, '-F', `pr=${ctx.pr}`]);
+  const nodes = out.data.repository.pullRequest.reviewThreads.nodes;
+  return nodes.find((n) => String(n.comments.nodes[0] && n.comments.nodes[0].databaseId) === String(rootCommentId));
+}
+
+function resolveReviewThread(nodeId) {
+  const mutation = `mutation($id:ID!){resolveReviewThread(input:{threadId:$id}){thread{isResolved}}}`;
+  return ghJson(['api', 'graphql', '-f', `query=${mutation}`, '-f', `id=${nodeId}`]);
+}
+
+function applySection(ctx, file, row) {
+  const m = /^(issue-comment|review-comment|review-summary)\/(\d+)$/.exec(row.id);
+  if (!m) return { id: row.id, ok: false, error: `id is not a <kind>/<numeric-id> value: ${row.id}` };
+  const [, kind, numericId] = m;
+  const resolveOnApply = row['resolve-on-apply'] === 'true' && kind === 'review-comment';
+  const rawDraft = runUpdateSection(['get', file, row.id, 'reply-draft']).replace(/\n$/, '');
+  const replyText = joinReplyDraft(rawDraft);
+  const endpoint = commentsEndpoint(ctx, kind);
+
+  try {
+    const isReviewComment = kind === 'review-comment';
+    const before = ghJson(['api', endpoint, '--paginate']);
+    let alreadyPosted = isReviewComment
+      ? before.some((c) => c.body === replyText && String(c.in_reply_to_id) === numericId)
+      : before.some((c) => c.body === replyText);
+
+    if (!alreadyPosted) {
+      const postArgs = ['api', endpoint, '-f', `body=${replyText}`];
+      if (isReviewComment) postArgs.push('-F', `in_reply_to=${numericId}`);
+      gh(postArgs);
+
+      // A 2xx exit is not proof the write persisted -- always read back to confirm.
+      const after = ghJson(['api', endpoint, '--paginate']);
+      alreadyPosted = isReviewComment
+        ? after.some((c) => c.body === replyText && String(c.in_reply_to_id) === numericId)
+        : after.some((c) => c.body === replyText);
+      if (!alreadyPosted) {
+        return { id: row.id, ok: false, error: 'gh api exited 0 but reply missing on read-back verification' };
+      }
+    }
+
+    let resolved = false;
+    if (resolveOnApply) {
+      const thread = findReviewThread(ctx, numericId);
+      if (!thread) return { id: row.id, ok: false, error: `no review thread found rooted at comment ${numericId}` };
+      if (thread.isResolved) {
+        resolved = true;
+      } else {
+        resolveReviewThread(thread.id);
+        const after = findReviewThread(ctx, numericId);
+        resolved = Boolean(after && after.isResolved);
+        if (!resolved) {
+          return { id: row.id, ok: false, error: 'resolveReviewThread exited 0 but isResolved false on read-back verification' };
+        }
+      }
+    }
+
+    // Only ever mark the tracking file after independent verification above, never on a
+    // bare `gh` exit code.
+    runUpdateSection(['set', file, row.id, 'pending-reply', 'applied']);
+    if (resolved) runUpdateSection(['set', file, row.id, 'status', 'resolved']);
+    return { id: row.id, ok: true, resolved };
+  } catch (e) {
+    return { id: row.id, ok: false, error: String(e.stderr || e.message) };
+  }
+}
+
+function main(argv) {
+  const args = parseArgs(argv);
+  if (!args.file || !args.prUrl) {
+    console.error('Usage: post-replies-github.js --pr-url <url> <tracking-file> [--dry-run] [--only <id>[,<id>...]]');
+    process.exit(1);
+    return;
+  }
+  const ctx = parsePrUrl(args.prUrl);
+
+  const rows = listCandidateSections(args.file, args.only);
+  if (rows.length === 0) {
+    console.log('No sections to apply (nothing pending-reply: drafted).');
+    return;
+  }
+
+  const results = [];
+  if (args.dryRun) {
+    for (const row of rows) {
+      const rawDraft = runUpdateSection(['get', args.file, row.id, 'reply-draft']).replace(/\n$/, '');
+      console.log(`\n=== ${row.id} (resolve=${row['resolve-on-apply'] === 'true'}) ===\n${joinReplyDraft(rawDraft)}`);
+      results.push({ id: row.id, ok: true, dryRun: true });
+    }
+  } else {
+    for (const row of rows) {
+      const result = applySection(ctx, args.file, row);
+      results.push(result);
+      if (result.ok) {
+        console.log(`OK   ${result.id} replied+verified${result.resolved ? ' + resolved+verified' : ''}`);
+      } else {
+        console.error(`FAIL ${result.id}: ${result.error}`);
+      }
+    }
+  }
+
+  console.log('\n--- SUMMARY ---');
+  console.log(JSON.stringify(results, null, 2));
+  if (results.some((r) => !r.ok)) process.exit(1);
+}
+
+if (require.main === module) {
+  try {
+    main(process.argv.slice(2));
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = { parsePrUrl, joinReplyDraft };

package/.xdrs/agentme/edrs/principles/skills/resolve-pr-comments/scripts/post-replies-github.test.js

@@ -0,0 +1,272 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { execFileSync } = require('node:child_process');
+
+const SCRIPT = path.join(__dirname, 'post-replies-github.js');
+const { parsePrUrl, joinReplyDraft } = require('./post-replies-github.js');
+
+const PR_URL = 'https://github.com/acme/widgets/pull/482';
+
+// Fake `gh` used via GH_BIN: reads/writes a JSON file (FAKE_GH_STATE) to simulate PR state,
+// so tests never touch the network. Supports the `api <path> [-f k=v...] [-F k=v...]
+// [--paginate]` and `api graphql -f query=<...> [-f/-F ...]` shapes the real script calls.
+const FAKE_GH_SRC = `
+'use strict';
+const fs = require('fs');
+const statePath = process.env.FAKE_GH_STATE;
+const state = JSON.parse(fs.readFileSync(statePath, 'utf8'));
+const argv = process.argv.slice(2);
+
+function fieldFlags(flag) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === flag) {
+      const raw = argv[i + 1];
+      const eq = raw.indexOf('=');
+      out[raw.slice(0, eq)] = raw.slice(eq + 1);
+    }
+  }
+  return out;
+}
+function save() { fs.writeFileSync(statePath, JSON.stringify(state)); }
+
+if (argv[1] === 'graphql') {
+  const f = fieldFlags('-f');
+  const query = f.query;
+  if (query.includes('resolveReviewThread')) {
+    const nodeId = f.id;
+    const entry = Object.values(state.threads).find((t) => t.nodeId === nodeId);
+    if (!entry) { console.error('unknown thread node ' + nodeId); process.exit(1); }
+    if (!(state.resolveBehavior && state.resolveBehavior[nodeId] === 'false-positive')) {
+      entry.isResolved = true;
+      save();
+    }
+    process.stdout.write(JSON.stringify({ data: { resolveReviewThread: { thread: { isResolved: entry.isResolved } } } }));
+  } else if (query.includes('reviewThreads')) {
+    const nodes = Object.entries(state.threads).map(([rootId, t]) => ({
+      id: t.nodeId,
+      isResolved: t.isResolved,
+      comments: { nodes: [{ databaseId: Number(rootId) }] },
+    }));
+    process.stdout.write(JSON.stringify({ data: { repository: { pullRequest: { reviewThreads: { nodes } } } } }));
+  } else {
+    console.error('unrecognized graphql query');
+    process.exit(1);
+  }
+} else {
+  const restPath = argv[1];
+  const f = fieldFlags('-f');
+  const cap = fieldFlags('-F');
+  const isPost = argv.includes('-f') || argv.includes('-F');
+
+  if (/\\/issues\\/\\d+\\/comments$/.test(restPath)) {
+    if (!isPost) {
+      process.stdout.write(JSON.stringify(state.issueComments));
+    } else {
+      if (state.failPost && state.failPost.includes('issue')) {
+        console.error('simulated hard POST failure for issue comment');
+        process.exit(1);
+      }
+      if (!(state.postBehavior && state.postBehavior.issue === 'false-positive')) {
+        state.issueComments.push({ id: state.issueComments.length + 1, body: f.body });
+        save();
+      }
+      process.stdout.write(JSON.stringify({ id: state.issueComments.length }));
+    }
+  } else if (/\\/pulls\\/\\d+\\/comments$/.test(restPath)) {
+    if (!isPost) {
+      process.stdout.write(JSON.stringify(state.reviewComments));
+    } else {
+      const key = cap.in_reply_to;
+      if (state.failPost && state.failPost.includes(key)) {
+        console.error('simulated hard POST failure for ' + key);
+        process.exit(1);
+      }
+      if (!(state.postBehavior && state.postBehavior[key] === 'false-positive')) {
+        state.reviewComments.push({ id: state.reviewComments.length + 1, body: f.body, in_reply_to_id: Number(key) });
+        save();
+      }
+      process.stdout.write(JSON.stringify({ id: state.reviewComments.length }));
+    }
+  } else {
+    console.error('unsupported fake gh call: ' + restPath);
+    process.exit(1);
+  }
+}
+`;
+
+const FIXTURE = `# PR #482
+
+### Rename the exported helper
+id: review-comment/91234
+status: open
+source: (PR conversation)
+comment-raw: |
+  suggestion: rename this to something clearer.
+replies-raw:
+possible-follow-ups:
+  - fix: rename per the suggestion
+action: fix
+resolve-on-apply: true
+pending-reply: drafted
+reply-draft: |
+  Fixed -- renamed per your suggestion, thanks! (resolve-pr-comments - guided)
+
+### General question about the release plan
+id: issue-comment/555
+status: open
+source: (PR conversation)
+comment-raw: |
+  What's the plan for releasing this?
+replies-raw:
+possible-follow-ups:
+action: reply
+resolve-on-apply: false
+pending-reply: drafted
+reply-draft: |
+  Targeting the next minor release once CI is green. (resolve-pr-comments -
+  guided)
+
+### Already handled comment, should never be touched
+id: review-comment/77777
+status: open
+source: (PR conversation)
+comment-raw: |
+  Unrelated comment still awaiting triage.
+replies-raw:
+possible-follow-ups:
+action:
+resolve-on-apply: false
+pending-reply: none
+reply-draft: |
+`;
+
+function setup(state) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'post-replies-gh-test-'));
+  const file = path.join(dir, 'review-pr-482.md');
+  fs.writeFileSync(file, FIXTURE);
+  const fakeGh = path.join(dir, 'fake-gh.js');
+  fs.writeFileSync(fakeGh, FAKE_GH_SRC);
+  const statePath = path.join(dir, 'state.json');
+  fs.writeFileSync(statePath, JSON.stringify(state));
+  return { file, statePath, env: { ...process.env, GH_BIN: `node ${fakeGh}`, FAKE_GH_STATE: statePath } };
+}
+
+function run(args, env) {
+  try {
+    const stdout = execFileSync('node', [SCRIPT, ...args], { encoding: 'utf8', env });
+    return { status: 0, stdout };
+  } catch (err) {
+    return { status: err.status, stdout: err.stdout, stderr: err.stderr };
+  }
+}
+
+function getField(file, id, field) {
+  return execFileSync('node', [path.join(__dirname, 'update-section.js'), 'get', file, id, field], { encoding: 'utf8' }).trim();
+}
+
+test('parsePrUrl extracts owner/repo/pr from a GitHub PR URL', () => {
+  assert.deepEqual(parsePrUrl(PR_URL), { owner: 'acme', repo: 'widgets', pr: '482' });
+});
+
+test('parsePrUrl rejects an unrecognized URL rather than guessing', () => {
+  assert.throws(() => parsePrUrl('https://example.com/not/github'), /unrecognized GitHub PR URL/);
+});
+
+test('joinReplyDraft rejoins hand-wrapped lines within a paragraph, preserving paragraph breaks', () => {
+  const raw = 'Line one\nstill line one.\n\nSecond paragraph\non two lines.';
+  assert.equal(joinReplyDraft(raw), 'Line one still line one.\n\nSecond paragraph on two lines.');
+});
+
+test('posts a review-comment reply, verifies via read-back, resolves the thread, and marks applied', () => {
+  const { file, env } = setup({
+    issueComments: [],
+    reviewComments: [],
+    threads: { 91234: { nodeId: 'PRT_1', isResolved: false } },
+  });
+  const { status, stdout } = run(['--pr-url', PR_URL, '--only', 'review-comment/91234', file], env);
+  assert.equal(status, 0, stdout);
+  assert.match(stdout, /OK {3}review-comment\/91234 replied\+verified \+ resolved\+verified/);
+  assert.equal(getField(file, 'review-comment/91234', 'pending-reply'), 'applied');
+  assert.equal(getField(file, 'review-comment/91234', 'status'), 'resolved');
+});
+
+test('posts an issue-comment reply, verifies via read-back, and never attempts a resolve', () => {
+  const { file, env } = setup({ issueComments: [], reviewComments: [], threads: {} });
+  const { status, stdout } = run(['--pr-url', PR_URL, '--only', 'issue-comment/555', file], env);
+  assert.equal(status, 0, stdout);
+  assert.match(stdout, /OK {3}issue-comment\/555 replied\+verified$/m);
+  assert.equal(getField(file, 'issue-comment/555', 'pending-reply'), 'applied');
+  assert.equal(getField(file, 'issue-comment/555', 'status'), 'open');
+});
+
+test('REGRESSION: does not mark pending-reply applied when the POST exits 0 but the reply never persists', () => {
+  const { file, env } = setup({
+    issueComments: [],
+    reviewComments: [],
+    threads: { 91234: { nodeId: 'PRT_1', isResolved: false } },
+    postBehavior: { 91234: 'false-positive' },
+  });
+  const { status, stderr } = run(['--pr-url', PR_URL, '--only', 'review-comment/91234', file], env);
+  assert.equal(status, 1);
+  assert.match(stderr, /FAIL review-comment\/91234: gh api exited 0 but reply missing on read-back verification/);
+  assert.equal(getField(file, 'review-comment/91234', 'pending-reply'), 'drafted');
+});
+
+test('REGRESSION: does not mark status resolved when the mutation exits 0 but isResolved never persists', () => {
+  const { file, env } = setup({
+    issueComments: [],
+    reviewComments: [],
+    threads: { 91234: { nodeId: 'PRT_1', isResolved: false } },
+    resolveBehavior: { PRT_1: 'false-positive' },
+  });
+  const { status, stderr } = run(['--pr-url', PR_URL, '--only', 'review-comment/91234', file], env);
+  assert.equal(status, 1);
+  assert.match(stderr, /FAIL review-comment\/91234: resolveReviewThread exited 0 but isResolved false on read-back verification/);
+  assert.equal(getField(file, 'review-comment/91234', 'pending-reply'), 'drafted');
+  assert.equal(getField(file, 'review-comment/91234', 'status'), 'open');
+});
+
+test('skips re-posting when the exact reply is already present, but still marks applied', () => {
+  const { file, env } = setup({
+    issueComments: [],
+    reviewComments: [{ id: 1, body: 'Fixed -- renamed per your suggestion, thanks! (resolve-pr-comments - guided)', in_reply_to_id: 91234 }],
+    threads: { 91234: { nodeId: 'PRT_1', isResolved: false } },
+    // If the script incorrectly tries to POST again, this makes it fail loudly.
+    failPost: ['91234'],
+  });
+  const { status, stdout } = run(['--pr-url', PR_URL, '--only', 'review-comment/91234', file], env);
+  assert.equal(status, 0, stdout);
+  assert.equal(getField(file, 'review-comment/91234', 'pending-reply'), 'applied');
+});
+
+test('never processes a section whose pending-reply is not drafted, when --only is not given', () => {
+  const { file, env } = setup({
+    issueComments: [],
+    reviewComments: [],
+    threads: {
+      91234: { nodeId: 'PRT_1', isResolved: false },
+      // 77777 deliberately absent: pending-reply is 'none' for it, so a correct run never
+      // references it at all -- if it did, the fake gh would fail with "no review thread
+      // found" and this test would catch it via the failPost trap below.
+    },
+    failPost: ['77777'],
+  });
+  const { status, stdout } = run(['--pr-url', PR_URL, file], env);
+  assert.equal(status, 0, stdout);
+  assert.equal(getField(file, 'review-comment/77777', 'pending-reply'), 'none');
+});
+
+test('--dry-run prints drafts without invoking gh or changing the tracking file', () => {
+  const { file, env } = setup({ issueComments: [], reviewComments: [], threads: {} }); // any gh call would throw
+  const { status, stdout } = run(['--pr-url', PR_URL, '--dry-run', file], env);
+  assert.equal(status, 0, stdout);
+  assert.match(stdout, /=== review-comment\/91234 \(resolve=true\) ===/);
+  assert.match(stdout, /=== issue-comment\/555 \(resolve=false\) ===/);
+  assert.equal(getField(file, 'review-comment/91234', 'pending-reply'), 'drafted');
+});