agentme 0.35.1 → 0.36.0

package/.xdrs/agentme/edrs/principles/skills/400-pr-owner-assistant/scripts/update-section.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Safe read/update helper for a pr-owner-assistant tracking file
+ * (.tmp/review-pr-<N>.md), keyed by each section's stable `id:` value
+ * instead of its title text. See SKILL.md's "Editing the tracking file" note.
+ *
+ * Usage:
+ *   update-section.js list <file>
+ *   update-section.js get <file> <id> <field>
+ *   update-section.js set <file> <id> <field> <value...>
+ *   update-section.js set-block <file> <id> <field>   (new value read from stdin)
+ *   update-section.js set-list <file> <id> <field>    (new items read from stdin, one per line)
+ *
+ * <id> is the section's "id:" value (e.g. "review-comment/1935286030"), not the title.
+ */
+
+const fs = require('fs');
+
+const SCALAR_FIELDS = [
+  'id',
+  'status',
+  'source',
+  'author-raw',
+  'comment-url',
+  'type',
+  'possible-user-intention',
+  'suggested-fix-assessment',
+  'criticality',
+  'action',
+  'resolve-on-apply',
+  'pending-reply',
+];
+const BLOCK_FIELDS = ['source-lines', 'diff-hunk-raw', 'suggested-fix', 'comment-raw', 'reply-draft'];
+const LIST_FIELDS = ['replies-raw', 'possible-follow-ups'];
+const ALL_FIELDS = [...SCALAR_FIELDS, ...BLOCK_FIELDS, ...LIST_FIELDS];
+const NEXT_FIELD_RE = new RegExp(`^(?:${ALL_FIELDS.join('|')}):`);
+
+function usage() {
+  return `Usage:
+  update-section.js list <file>
+  update-section.js get <file> <id> <field>
+  update-section.js set <file> <id> <field> <value...>
+  update-section.js set-block <file> <id> <field>   (new value read from stdin)
+  update-section.js set-list <file> <id> <field>    (new items read from stdin, one per line)
+
+<id> is the section's "id:" value (e.g. "review-comment/1935286030"), not the title.
+Scalar fields: ${SCALAR_FIELDS.join(', ')}
+Block fields (use set-block): ${BLOCK_FIELDS.join(', ')}
+List fields (use set-list): ${LIST_FIELDS.join(', ')}`;
+}
+
+function headerIndices(lines) {
+  const idx = [];
+  lines.forEach((line, i) => {
+    if (line.startsWith('### ')) idx.push(i);
+  });
+  return idx;
+}
+
+function findSectionById(lines, id) {
+  const idx = headerIndices(lines);
+  const matches = [];
+  for (let s = 0; s < idx.length; s++) {
+    const start = idx[s];
+    const end = s + 1 < idx.length ? idx[s + 1] : lines.length;
+    for (let i = start; i < end; i++) {
+      const m = /^id:\s*(.*)$/.exec(lines[i]);
+      if (m && m[1].trim() === id) {
+        matches.push({ start, end, title: lines[start].slice(4).trim() });
+        break;
+      }
+    }
+  }
+  if (matches.length === 0) throw new Error(`no section found with id: ${id}`);
+  if (matches.length > 1) {
+    throw new Error(`ambiguous: ${matches.length} sections found with id: ${id}`);
+  }
+  return matches[0];
+}
+
+// Locates `field:`'s own line plus the line range of any indented content that follows it
+// (block-scalar `|` content or a `- ` list), stopping at the next known top-level field or
+// the next section header -- never at a bare blank line, since block content legitimately
+// contains blank lines.
+function findField(lines, start, end, field) {
+  const headRe = new RegExp(`^${field}:(.*)$`);
+  const occurrences = [];
+  for (let i = start; i < end; i++) {
+    if (headRe.test(lines[i])) occurrences.push(i);
+  }
+  if (occurrences.length === 0) throw new Error(`field "${field}" not found in matched section`);
+  if (occurrences.length > 1) {
+    throw new Error(
+      `field "${field}" appears ${occurrences.length} times in this section -- ambiguous, edit manually`,
+    );
+  }
+  const lineIdx = occurrences[0];
+  const suffix = headRe.exec(lines[lineIdx])[1].trim();
+  let contentEnd = lineIdx + 1;
+  let kind;
+  if (suffix === '|') {
+    kind = 'block';
+    while (contentEnd < end && !NEXT_FIELD_RE.test(lines[contentEnd]) && !lines[contentEnd].startsWith('### ')) {
+      contentEnd++;
+    }
+  } else if (suffix === '') {
+    if (lineIdx + 1 < end && /^ {2}- /.test(lines[lineIdx + 1])) {
+      kind = 'list';
+      while (contentEnd < end && /^ {2}- /.test(lines[contentEnd])) contentEnd++;
+    } else {
+      kind = 'scalar';
+    }
+  } else {
+    kind = 'scalar';
+  }
+  return { lineIdx, kind, suffix, contentStart: lineIdx + 1, contentEnd };
+}
+
+function requireKind(field, expectedKind, fieldSet, cmdHint) {
+  if (!fieldSet.includes(field)) {
+    throw new Error(`field "${field}" is not a ${expectedKind} field -- use ${cmdHint}`);
+  }
+}
+
+function readStdin() {
+  return fs.readFileSync(0, 'utf8');
+}
+
+function writeBack(file, lines, hadTrailingNewline) {
+  let text = lines.join('\n');
+  if (hadTrailingNewline && !text.endsWith('\n')) text += '\n';
+  fs.writeFileSync(file, text);
+}
+
+function main(argv) {
+  const [cmd, file, ...rest] = argv;
+  if (!cmd || cmd === '--help' || cmd === '-h' || !file) {
+    console.error(usage());
+    process.exit(cmd === '--help' || cmd === '-h' ? 0 : 1);
+    return;
+  }
+
+  const original = fs.readFileSync(file, 'utf8');
+  const hadTrailingNewline = original.endsWith('\n');
+  const lines = original.split('\n');
+
+  if (cmd === 'list') {
+    const idx = headerIndices(lines);
+    for (let s = 0; s < idx.length; s++) {
+      const start = idx[s];
+      const end = s + 1 < idx.length ? idx[s + 1] : lines.length;
+      const row = { id: '', status: '', action: '', 'pending-reply': '', 'resolve-on-apply': '' };
+      for (const key of Object.keys(row)) {
+        try {
+          const f = findField(lines, start, end, key);
+          row[key] = f.suffix;
+        } catch {
+          // field absent in a malformed section -- leave blank, never fail `list`
+        }
+      }
+      // Bullets avoid relying on column/tab alignment, which breaks once field values vary in width.
+      console.log(`- id: ${row.id}`);
+      console.log(`  title: ${lines[start].slice(4).trim()}`);
+      console.log(`  status: ${row.status}`);
+      console.log(`  action: ${row.action}`);
+      console.log(`  pending-reply: ${row['pending-reply']}`);
+      console.log(`  resolve-on-apply: ${row['resolve-on-apply']}`);
+    }
+    return;
+  }
+
+  const [id, field, ...valueParts] = rest;
+  if (!id || !field) {
+    console.error(usage());
+    process.exit(1);
+    return;
+  }
+  const section = findSectionById(lines, id);
+
+  if (cmd === 'get') {
+    const f = findField(lines, section.start, section.end, field);
+    if (f.kind === 'scalar') {
+      console.log(f.suffix);
+    } else if (f.kind === 'block') {
+      console.log(
+        lines
+          .slice(f.contentStart, f.contentEnd)
+          .map((l) => (l.startsWith('  ') ? l.slice(2) : l))
+          .join('\n'),
+      );
+    } else {
+      console.log(
+        lines
+          .slice(f.contentStart, f.contentEnd)
+          .map((l) => l.replace(/^ {2}- /, ''))
+          .join('\n'),
+      );
+    }
+    return;
+  }
+
+  if (cmd === 'set') {
+    requireKind(field, 'scalar', SCALAR_FIELDS, 'set-block/set-list');
+    const f = findField(lines, section.start, section.end, field);
+    const value = valueParts.join(' ');
+    lines[f.lineIdx] = value === '' ? `${field}:` : `${field}: ${value}`;
+    writeBack(file, lines, hadTrailingNewline);
+    console.log('OK');
+    return;
+  }
+
+  if (cmd === 'set-block') {
+    requireKind(field, 'block', BLOCK_FIELDS, 'set (scalar) or set-list');
+    const f = findField(lines, section.start, section.end, field);
+    const stdin = readStdin().replace(/\n$/, '');
+    const newContentLines = stdin.split('\n').map((l) => (l === '' ? '' : `  ${l}`));
+    lines.splice(f.lineIdx, f.contentEnd - f.lineIdx, `${field}: |`, ...newContentLines);
+    writeBack(file, lines, hadTrailingNewline);
+    console.log('OK');
+    return;
+  }
+
+  if (cmd === 'set-list') {
+    requireKind(field, 'list', LIST_FIELDS, 'set (scalar) or set-block');
+    const f = findField(lines, section.start, section.end, field);
+    const stdin = readStdin().replace(/\n$/, '');
+    const items = stdin.split('\n').filter((l) => l.trim() !== '');
+    const newContentLines = items.map((l) => `  - ${l}`);
+    lines.splice(f.lineIdx, f.contentEnd - f.lineIdx, `${field}:`, ...newContentLines);
+    writeBack(file, lines, hadTrailingNewline);
+    console.log('OK');
+    return;
+  }
+
+  console.error(usage());
+  process.exit(1);
+}
+
+try {
+  main(process.argv.slice(2));
+} catch (err) {
+  console.error(`Error: ${err.message}`);
+  process.exit(1);
+}

package/.xdrs/agentme/edrs/principles/skills/400-pr-owner-assistant/scripts/update-section.test.js

@@ -0,0 +1,199 @@
+'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, 'update-section.js');
+
+const FIXTURE = `# PR #482
+
+Some raw PR summary text.
+
+### Contributor offers to help
+id: issue-comment/111
+status: open
+source: (PR conversation)
+comment-raw: |
+  Thanks for this PR!
+
+  Happy to help test it.
+replies-raw:
+possible-follow-ups:
+  - reply thanking them
+action:
+resolve-on-apply: false
+pending-reply: none
+reply-draft: |
+
+### Naming taxonomy question
+id: review-comment/222
+status: open
+source: [lib/src/foo.ts:10-10](../lib/src/foo.ts#L10-L10)
+suggested-fix: |
+  const value = compute();
+suggested-fix-assessment: accept-as-is
+comment-raw: |
+  Shall we rename this?
+replies-raw:
+possible-follow-ups:
+  - "fix: rename for consistency"
+  - "mark won't-fix: keep current naming"
+action: fix
+resolve-on-apply: true
+pending-reply: drafted
+reply-draft: |
+  Renamed as suggested. (pr-owner-assistant skill - using defaults)
+`;
+
+function writeFixture(content = FIXTURE) {
+  const file = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'update-section-test-')), 'review-pr-482.md');
+  fs.writeFileSync(file, content);
+  return file;
+}
+
+function run(args, input) {
+  try {
+    const stdout = execFileSync('node', [SCRIPT, ...args], { input, encoding: 'utf8' });
+    return { status: 0, stdout };
+  } catch (err) {
+    return { status: err.status, stdout: err.stdout, stderr: err.stderr };
+  }
+}
+
+test('list renders one bullet block per section, not tab-aligned columns', () => {
+  const file = writeFixture();
+  const { status, stdout } = run(['list', file]);
+  assert.equal(status, 0);
+  assert.equal(stdout.includes('\t'), false, 'list output must not rely on tab alignment');
+  assert.match(stdout, /- id: issue-comment\/111/);
+  assert.match(stdout, /^ {2}title: Contributor offers to help$/m);
+  assert.match(stdout, /^ {2}status: open$/m);
+  assert.match(stdout, /- id: review-comment\/222/);
+  assert.match(stdout, /^ {2}action: fix$/m);
+  assert.match(stdout, /^ {2}pending-reply: drafted$/m);
+});
+
+test('get returns a scalar field value', () => {
+  const file = writeFixture();
+  const { status, stdout } = run(['get', file, 'review-comment/222', 'status']);
+  assert.equal(status, 0);
+  assert.equal(stdout.trim(), 'open');
+});
+
+test('get returns a block field value with blank lines preserved', () => {
+  const file = writeFixture();
+  const { status, stdout } = run(['get', file, 'issue-comment/111', 'comment-raw']);
+  assert.equal(status, 0);
+  assert.equal(stdout, 'Thanks for this PR!\n\nHappy to help test it.\n');
+});
+
+test('get returns a list field with dash prefixes stripped', () => {
+  const file = writeFixture();
+  const { status, stdout } = run(['get', file, 'review-comment/222', 'possible-follow-ups']);
+  assert.equal(status, 0);
+  assert.equal(stdout, '"fix: rename for consistency"\n"mark won\'t-fix: keep current naming"\n');
+});
+
+test('get returns the suggested-fix block field extracted for a comment', () => {
+  const file = writeFixture();
+  const { status, stdout } = run(['get', file, 'review-comment/222', 'suggested-fix']);
+  assert.equal(status, 0);
+  assert.equal(stdout, 'const value = compute();\n');
+});
+
+test('get returns the suggested-fix-assessment scalar field', () => {
+  const file = writeFixture();
+  const { status, stdout } = run(['get', file, 'review-comment/222', 'suggested-fix-assessment']);
+  assert.equal(status, 0);
+  assert.equal(stdout.trim(), 'accept-as-is');
+});
+
+test('set updates only the targeted scalar field, leaving the rest of the file untouched', () => {
+  const file = writeFixture();
+  const before = fs.readFileSync(file, 'utf8');
+  const { status } = run(['set', file, 'issue-comment/111', 'action', 'reply']);
+  assert.equal(status, 0);
+  const after = fs.readFileSync(file, 'utf8');
+  assert.equal(after, before.replace('action:\nresolve-on-apply: false\npending-reply: none', 'action: reply\nresolve-on-apply: false\npending-reply: none'));
+});
+
+test('set with an empty value clears a scalar field to "field:" with no trailing space', () => {
+  const file = writeFixture();
+  run(['set', file, 'review-comment/222', 'action', '']);
+  const { stdout } = run(['get', file, 'review-comment/222', 'action']);
+  assert.equal(stdout.trim(), '');
+  assert.match(fs.readFileSync(file, 'utf8'), /^action:$/m);
+});
+
+test('set-block replaces block content from stdin, preserving a blank line in the middle', () => {
+  const file = writeFixture();
+  const { status } = run(['set-block', file, 'issue-comment/111', 'reply-draft'], 'Line one.\n\nLine two.\n');
+  assert.equal(status, 0);
+  const { stdout } = run(['get', file, 'issue-comment/111', 'reply-draft']);
+  assert.equal(stdout, 'Line one.\n\nLine two.\n');
+});
+
+test('set-list replaces list content from stdin, skipping blank lines', () => {
+  const file = writeFixture();
+  const { status } = run(['set-list', file, 'issue-comment/111', 'possible-follow-ups'], 'item one\n\nitem two\n');
+  assert.equal(status, 0);
+  const { stdout } = run(['get', file, 'issue-comment/111', 'possible-follow-ups']);
+  assert.equal(stdout, 'item one\nitem two\n');
+});
+
+test('set-block replaces suggested-fix content, preserving multi-line code', () => {
+  const file = writeFixture();
+  const { status } = run(
+    ['set-block', file, 'review-comment/222', 'suggested-fix'],
+    'const value = 42;\nconst other = 1;\n',
+  );
+  assert.equal(status, 0);
+  const { stdout } = run(['get', file, 'review-comment/222', 'suggested-fix']);
+  assert.equal(stdout, 'const value = 42;\nconst other = 1;\n');
+});
+
+test('set updates the suggested-fix-assessment scalar field', () => {
+  const file = writeFixture();
+  const { status } = run(['set', file, 'review-comment/222', 'suggested-fix-assessment', 'evolve-with-changes']);
+  assert.equal(status, 0);
+  const { stdout } = run(['get', file, 'review-comment/222', 'suggested-fix-assessment']);
+  assert.equal(stdout.trim(), 'evolve-with-changes');
+});
+
+test('preserves absence of a trailing newline on the original file', () => {
+  const file = writeFixture(FIXTURE.replace(/\n$/, ''));
+  run(['set', file, 'issue-comment/111', 'action', 'reply']);
+  assert.equal(fs.readFileSync(file, 'utf8').endsWith('\n'), false);
+});
+
+test('get on an unknown id fails with a clear error', () => {
+  const file = writeFixture();
+  const { status, stderr } = run(['get', file, 'issue-comment/999', 'status']);
+  assert.notEqual(status, 0);
+  assert.match(stderr, /no section found with id: issue-comment\/999/);
+});
+
+test('get on an ambiguous id (duplicated in a malformed file) fails rather than guessing', () => {
+  const file = writeFixture(FIXTURE + FIXTURE.replace('### Contributor offers to help', '### Duplicate section'));
+  const { status, stderr } = run(['get', file, 'issue-comment/111', 'status']);
+  assert.notEqual(status, 0);
+  assert.match(stderr, /ambiguous: 2 sections found with id: issue-comment\/111/);
+});
+
+test('set on a block-only field fails and points to set-block', () => {
+  const file = writeFixture();
+  const { status, stderr } = run(['set', file, 'issue-comment/111', 'reply-draft', 'oops']);
+  assert.notEqual(status, 0);
+  assert.match(stderr, /use set-block/);
+});
+
+test('set-block on a scalar-only field fails and points to set', () => {
+  const file = writeFixture();
+  const { status, stderr } = run(['set-block', file, 'issue-comment/111', 'action'], 'oops\n');
+  assert.notEqual(status, 0);
+  assert.match(stderr, /use set \(scalar\)/);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentme",
-  "version": "0.35.1",
+  "version": "0.36.0",
   "description": "",
   "dependencies": {
     "filedist": "^0.39.0"