@warpmetrics/coder 0.2.5 → 0.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@warpmetrics/coder",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "type": "module",
   "description": "Local agent loop for implementing GitHub issues with Claude Code. Powered by WarpMetrics.",
   "bin": {

package/src/agent.js

@@ -12,7 +12,7 @@ import { reflect } from './reflect.js';
 
 const CONFIG_DIR = '.warp-coder';
 
-export async function implement(item, { board, config, log }) {
+export async function implement(item, { board, config, log, refActId }) {
   const issueNumber = item.content?.number;
   const issueTitle = item.content?.title || `Issue #${issueNumber}`;
   const issueBody = item.content?.body || '';
@@ -45,6 +45,7 @@ export async function implement(item, { board, config, log }) {
         repo: repoName,
         issueNumber,
         issueTitle,
+        refActId,
       });
       runId = pipeline.runId;
       groupId = pipeline.groupId;
@@ -203,9 +204,9 @@ export async function implement(item, { board, config, log }) {
         log(`  outcome: ${outcome.name}`);
 
         // Emit act so warp-review can link its run as a follow-up
-        if (success && actId) {
+        if (success && actId && outcome.runOutcomeId) {
           await warp.emitAct(config.warpmetricsApiKey, {
-            outcomeId: outcome.id,
+            outcomeId: outcome.runOutcomeId,
             actId,
             name: 'review',
           });

package/src/boards/github-projects.js

@@ -111,6 +111,14 @@ export function create({ project, owner, statusField = 'Status', columns = {} })
         const repo = item.content.repository || `${owner}/${item.content.repository}`;
         const reviews = ghJson(`api repos/${repo}/pulls/${prNumber}/reviews`);
         item._prNumber = prNumber;
+
+        // Parse act ID from the most recent warp-review review body
+        const actMatch = reviews
+          ?.slice().reverse()
+          .map(r => (r.body || '').match(/<!-- wm:act:(wm_act_\w+) -->/))
+          .find(m => m);
+        if (actMatch) item._reviewActId = actMatch[1];
+
         if (reviews?.some(r => r.state === 'APPROVED')) {
           approved.push(item);
         } else if (reviews?.some(r => r.state === 'COMMENTED' || r.state === 'CHANGES_REQUESTED')) {

package/src/git.js

@@ -59,6 +59,14 @@ export function getReviewComments(prNumber, { repo }) {
   return JSON.parse(out);
 }
 
+export function updatePRBody(prNumber, { repo, body }) {
+  run(`gh pr edit ${prNumber} --repo ${repo} --body ${JSON.stringify(body)}`);
+}
+
+export function getPRBody(prNumber, { repo }) {
+  return run(`gh pr view ${prNumber} --repo ${repo} --json body --jq .body`);
+}
+
 export function getPRBranch(prNumber, { repo }) {
   const out = run(`gh pr view ${prNumber} --repo ${repo} --json headRefName --jq .headRefName`);
   return out;

package/src/revise.js

@@ -12,7 +12,7 @@ import { reflect } from './reflect.js';
 
 const CONFIG_DIR = '.warp-coder';
 
-export async function revise(item, { board, config, log }) {
+export async function revise(item, { board, config, log, refActId }) {
   const prNumber = item._prNumber || item.content?.number;
   const repo = config.repo;
   const repoName = repo.replace(/\.git$/, '').replace(/^.*github\.com[:\/]/, '');
@@ -20,6 +20,9 @@ export async function revise(item, { board, config, log }) {
   const workdir = join(tmpdir(), 'warp-coder', `revise-${prNumber}`);
   const configDir = join(process.cwd(), CONFIG_DIR);
 
+  // Pre-generate act ID for chaining (update PR body so warp-review can link next review)
+  const actId = config.warpmetricsApiKey ? warp.generateId('act') : null;
+
   log(`Revising PR #${prNumber}`);
 
   // Move to In Progress
@@ -33,13 +36,13 @@ export async function revise(item, { board, config, log }) {
   // Check revision limit
   if (config.warpmetricsApiKey) {
     try {
-      const count = await warp.countRevisions(config.warpmetricsApiKey, { prNumber, repo: repoName });
-      if (count >= maxRevisions) {
-        log(`  revision limit reached (${count}/${maxRevisions}) — moving to Blocked`);
+      const revisionCount = await warp.countRevisions(config.warpmetricsApiKey, { prNumber, repo: repoName });
+      if (revisionCount >= maxRevisions) {
+        log(`  revision limit reached (${revisionCount}/${maxRevisions}) — moving to Blocked`);
         try { await board.moveToBlocked(item); } catch {}
-        return false;
+        return { success: false, reason: 'max_retries', count: revisionCount };
       }
-      log(`  revision ${count + 1}/${maxRevisions}`);
+      log(`  revision ${revisionCount + 1}/${maxRevisions}`);
     } catch (err) {
       log(`  warning: revision check failed: ${err.message}`);
     }
@@ -54,6 +57,7 @@ export async function revise(item, { board, config, log }) {
         step: 'revise',
         repo: repoName,
         prNumber,
+        refActId,
       });
       runId = pipeline.runId;
       groupId = pipeline.groupId;
@@ -182,6 +186,20 @@ export async function revise(item, { board, config, log }) {
     log('  pushing...');
     git.push(workdir, branch);
 
+    // Update PR body with new act ID for next review cycle
+    if (actId) {
+      try {
+        let body = git.getPRBody(prNumber, { repo: repoName });
+        body = body.replace(/<!-- wm:act:wm_act_\w+ -->/, `<!-- wm:act:${actId} -->`);
+        if (!body.includes(`<!-- wm:act:${actId} -->`)) {
+          body += `\n\n<!-- wm:act:${actId} -->`;
+        }
+        git.updatePRBody(prNumber, { repo: repoName, body });
+      } catch (err) {
+        log(`  warning: could not update PR body with act ID: ${err.message}`);
+      }
+    }
+
     // Move back to In Review
     try {
       await board.moveToReview(item);
@@ -212,6 +230,15 @@ export async function revise(item, { board, config, log }) {
           reviewCommentCount: reviewComments.length,
         });
         log(`  outcome: ${outcome.name}`);
+
+        // Emit act so warp-review can link its next review as a follow-up
+        if (success && actId && outcome.runOutcomeId) {
+          await warp.emitAct(config.warpmetricsApiKey, {
+            outcomeId: outcome.runOutcomeId,
+            actId,
+            name: 'review',
+          });
+        }
       } catch (err) {
         log(`  warning: outcome recording failed: ${err.message}`);
       }
@@ -241,5 +268,5 @@ export async function revise(item, { board, config, log }) {
     rmSync(workdir, { recursive: true, force: true });
   }
 
-  return success;
+  return { success, reason: success ? 'ok' : 'error' };
 }

package/src/warp.js

@@ -69,6 +69,8 @@ export async function registerClassifications(apiKey) {
   const items = [
     { name: 'PR Created', classification: 'success' },
     { name: 'Fixes Applied', classification: 'success' },
+    { name: 'Merged', classification: 'success' },
+    { name: 'Shipped', classification: 'success' },
     { name: 'Issue Understood', classification: 'success' },
     { name: 'Needs Clarification', classification: 'neutral' },
     { name: 'Needs Human', classification: 'neutral' },
@@ -94,11 +96,37 @@ export async function registerClassifications(apiKey) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Issue run — the root of the lifecycle chain
+// ---------------------------------------------------------------------------
+
+export async function createIssueRun(apiKey, { repo, issueNumber, issueTitle }) {
+  const runId = generateId('run');
+  const outcomeId = generateId('oc');
+  const actId = generateId('act');
+  const now = new Date().toISOString();
+
+  await sendEvents(apiKey, {
+    runs: [{ id: runId, label: 'issue', opts: { repo, issue: String(issueNumber), title: issueTitle }, refId: null, timestamp: now }],
+    outcomes: [{ id: outcomeId, refId: runId, name: 'Started', opts: null, timestamp: now }],
+    acts: [{ id: actId, refId: outcomeId, name: 'implement', opts: null, timestamp: now }],
+  });
+
+  return { runId, actId };
+}
+
+export async function closeIssueRun(apiKey, { runId, name, opts }) {
+  const now = new Date().toISOString();
+  await sendEvents(apiKey, {
+    outcomes: [{ id: generateId('oc'), refId: runId, name, opts: opts || null, timestamp: now }],
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Pipeline helpers — start run/group and record outcome
 // ---------------------------------------------------------------------------
 
-export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitle, prNumber }) {
+export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitle, prNumber, refActId }) {
   const runId = generateId('run');
   const groupId = generateId('grp');
   const now = new Date().toISOString();
@@ -109,7 +137,7 @@ export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitl
   if (prNumber) opts.pr_number = String(prNumber);
 
   await sendEvents(apiKey, {
-    runs: [{ id: runId, label: 'agent-pipeline', opts, refId: null, timestamp: now }],
+    runs: [{ id: runId, label: 'agent-pipeline', opts, refId: refActId || null, timestamp: now }],
     groups: [{ id: groupId, label: step, opts: { triggered_at: now }, timestamp: now }],
     links: [{ parentId: runId, childId: groupId, type: 'group', timestamp: now }],
   });
@@ -121,6 +149,7 @@ export async function recordOutcome(apiKey, { runId, groupId }, { step, success,
   const names = {
     implement: { true: 'PR Created', false: 'Implementation Failed' },
     revise: { true: 'Fixes Applied', false: 'Revision Failed' },
+    merge: { true: 'Merged', false: 'Merge Failed' },
   };
 
   const name = names[step]?.[String(success)] || `${step}: ${success ? 'success' : 'failure'}`;
@@ -134,16 +163,20 @@ export async function recordOutcome(apiKey, { runId, groupId }, { step, success,
   if (prNumber) opts.pr_number = String(prNumber);
   if (reviewCommentCount) opts.review_comments = String(reviewCommentCount);
 
+  const groupOutcomeId = generateId('oc');
   const outcomes = [
-    { id: generateId('oc'), refId: groupId, name, opts, timestamp: now },
+    { id: groupOutcomeId, refId: groupId, name, opts, timestamp: now },
   ];
+
+  let runOutcomeId = null;
   if (runId) {
-    outcomes.push({ id: generateId('oc'), refId: runId, name, opts, timestamp: now });
+    runOutcomeId = generateId('oc');
+    outcomes.push({ id: runOutcomeId, refId: runId, name, opts, timestamp: now });
   }
 
   await sendEvents(apiKey, { outcomes });
 
-  return { id: outcomes[0].id, name };
+  return { id: groupOutcomeId, runOutcomeId, name };
 }
 
 export async function emitAct(apiKey, { outcomeId, actId, name, opts }) {

package/src/watch.js

@@ -5,12 +5,17 @@ import { createBoard } from './boards/index.js';
 import { implement } from './agent.js';
 import { revise } from './revise.js';
 import * as git from './git.js';
+import * as warp from './warp.js';
 import { runHook } from './hooks.js';
 
 export async function watch() {
   const config = loadConfig();
   const board = createBoard(config);
   const pollInterval = (config.pollInterval || 30) * 1000;
+  const repoName = config.repo.replace(/\.git$/, '').replace(/^.*github\.com[:\/]/, '');
+
+  // Track issue runs across poll cycles (issueNumber → { runId })
+  const issueRuns = new Map();
 
   let running = true;
   let sleepResolve = null;
@@ -42,8 +47,26 @@ export async function watch() {
       const todoItems = await board.listTodo();
       if (todoItems.length > 0) {
         const item = todoItems[0];
-        log(`Found todo: #${item.content?.number} — ${item.content?.title}`);
-        await implement(item, { board, config, log });
+        const issueNumber = item.content?.number;
+        const issueTitle = item.content?.title;
+        log(`Found todo: #${issueNumber} — ${issueTitle}`);
+
+        // Create issue run (root of the lifecycle chain)
+        let implementActId = null;
+        if (config.warpmetricsApiKey && !issueRuns.has(issueNumber)) {
+          try {
+            const issue = await warp.createIssueRun(config.warpmetricsApiKey, {
+              repo: repoName, issueNumber, issueTitle,
+            });
+            issueRuns.set(issueNumber, { runId: issue.runId });
+            implementActId = issue.actId;
+            log(`  issue run: ${issue.runId}`);
+          } catch (err) {
+            log(`  warning: issue run creation failed: ${err.message}`);
+          }
+        }
+
+        await implement(item, { board, config, log, refActId: implementActId });
       }
 
       // 2. Check for items needing revision
@@ -51,7 +74,24 @@ export async function watch() {
       for (const item of reviewItems) {
         if (!running) break;
         log(`Found review feedback: PR #${item._prNumber || item.content?.number}`);
-        await revise(item, { board, config, log });
+        const result = await revise(item, { board, config, log, refActId: item._reviewActId });
+
+        // Record outcome on the issue run if revision failed terminally
+        const issueNumber = item.content?.number;
+        const issueCtx = issueNumber ? issueRuns.get(issueNumber) : null;
+        if (!result.success && issueCtx && config.warpmetricsApiKey) {
+          const name = result.reason === 'max_retries' ? 'Max Retries' : 'Revision Failed';
+          try {
+            await warp.closeIssueRun(config.warpmetricsApiKey, {
+              runId: issueCtx.runId,
+              name,
+              opts: { pr_number: String(item._prNumber || ''), revisions: String(result.count || '') },
+            });
+            log(`  issue run: ${name}`);
+          } catch (err) {
+            log(`  warning: issue run outcome failed: ${err.message}`);
+          }
+        }
       }
 
       // 3. Merge approved PRs
@@ -59,16 +99,60 @@ export async function watch() {
       for (const item of approvedItems) {
         if (!running) break;
         const prNumber = item._prNumber || item.content?.number;
-        const repoName = config.repo.replace(/\.git$/, '').replace(/^.*github\.com[:\/]/, '');
+        const refActId = item._reviewActId;
         log(`Merging approved PR #${prNumber}`);
+
+        // Create merge run (follow-up of review's "merge" act)
+        let mergeRunId = null;
+        let mergeGroupId = null;
+        if (config.warpmetricsApiKey) {
+          try {
+            const pipeline = await warp.startPipeline(config.warpmetricsApiKey, {
+              step: 'merge', repo: repoName, prNumber, refActId,
+            });
+            mergeRunId = pipeline.runId;
+            mergeGroupId = pipeline.groupId;
+          } catch (err) {
+            log(`  warning: merge pipeline failed: ${err.message}`);
+          }
+        }
+
         try {
           runHook('onBeforeMerge', config, { prNumber, repo: repoName });
           git.mergePR(prNumber, { repo: repoName });
           runHook('onMerged', config, { prNumber, repo: repoName });
           await board.moveToDone(item);
           log(`  merged and moved to Done`);
+
+          // Record merge outcome
+          if (config.warpmetricsApiKey && mergeGroupId) {
+            try {
+              await warp.recordOutcome(config.warpmetricsApiKey, { runId: mergeRunId, groupId: mergeGroupId }, {
+                step: 'merge', success: true, prNumber,
+              });
+            } catch {}
+          }
+
+          // Close the issue run with "Shipped"
+          const issueNumber = item.content?.number;
+          const issueCtx = issueRuns.get(issueNumber);
+          if (config.warpmetricsApiKey && issueCtx) {
+            try {
+              await warp.closeIssueRun(config.warpmetricsApiKey, {
+                runId: issueCtx.runId, name: 'Shipped',
+              });
+              issueRuns.delete(issueNumber);
+            } catch {}
+          }
         } catch (err) {
           log(`  merge failed: ${err.message}`);
+          if (config.warpmetricsApiKey && mergeGroupId) {
+            try {
+              await warp.recordOutcome(config.warpmetricsApiKey, { runId: mergeRunId, groupId: mergeGroupId }, {
+                step: 'merge', success: false, error: err.message, prNumber,
+              });
+            } catch {}
+          }
         }
       }
     } catch (err) {