@warpmetrics/coder 0.1.4 → 0.2.2

package/src/boards/index.js

@@ -0,0 +1,14 @@
+import { create as createGitHubProjects } from './github-projects.js';
+
+const providers = {
+  'github-projects': createGitHubProjects,
+};
+
+export function createBoard(config) {
+  const provider = config.board?.provider;
+  const factory = providers[provider];
+  if (!factory) {
+    throw new Error(`Unknown board provider: ${provider}. Available: ${Object.keys(providers).join(', ')}`);
+  }
+  return factory(config.board);
+}

package/src/claude.js

@@ -0,0 +1,40 @@
+import { spawn } from 'child_process';
+
+export function run({ prompt, workdir, allowedTools = 'Bash,Read,Edit,Write,Glob,Grep', maxTurns, verbose = true }) {
+  return new Promise((resolve, reject) => {
+    const args = ['-p', prompt, '--output-format', 'json', '--allowedTools', allowedTools];
+    if (maxTurns) args.push('--max-turns', String(maxTurns));
+
+    const proc = spawn('claude', args, {
+      cwd: workdir,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', d => { stdout += d; });
+    proc.stderr.on('data', d => {
+      stderr += d;
+      if (verbose) process.stderr.write(d);
+    });
+
+    proc.on('close', code => {
+      if (code !== 0) {
+        return reject(new Error(`claude exited with code ${code}: ${stderr}`));
+      }
+      try {
+        const result = JSON.parse(stdout);
+        resolve({
+          result: result.result || result,
+          sessionId: result.session_id || null,
+          costUsd: result.cost_usd || null,
+        });
+      } catch {
+        // Non-JSON output — still succeeded
+        resolve({ result: stdout, sessionId: null, costUsd: null });
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}

package/src/config.js

@@ -0,0 +1,13 @@
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const CONFIG_DIR = '.warp-coder';
+const CONFIG_FILE = 'config.json';
+
+export function loadConfig(cwd = process.cwd()) {
+  const configPath = join(cwd, CONFIG_DIR, CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    throw new Error(`Config not found: ${configPath}\nRun "warp-coder init" to create one.`);
+  }
+  return JSON.parse(readFileSync(configPath, 'utf-8'));
+}

package/src/git.js

@@ -0,0 +1,44 @@
+import { execSync } from 'child_process';
+
+function run(cmd, opts = {}) {
+  return execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'], ...opts }).trim();
+}
+
+export function cloneRepo(repoUrl, dest) {
+  run(`git clone --depth 1 ${repoUrl} ${dest}`);
+}
+
+export function checkoutBranch(dir, branch) {
+  run(`git checkout ${branch}`, { cwd: dir });
+}
+
+export function createBranch(dir, name) {
+  run(`git checkout -b ${name}`, { cwd: dir });
+}
+
+export function push(dir, branch) {
+  run(`git push -u origin ${branch}`, { cwd: dir });
+}
+
+export function createPR(dir, { title, body, base = 'main' }) {
+  const out = run(`gh pr create --title ${JSON.stringify(title)} --body ${JSON.stringify(body)} --base ${base}`, { cwd: dir });
+  // gh pr create prints the PR URL as the last line
+  const lines = out.split('\n');
+  const url = lines[lines.length - 1];
+  const match = url.match(/\/pull\/(\d+)/);
+  return { url, number: match ? parseInt(match[1], 10) : null };
+}
+
+export function mergePR(prNumber, { repo }) {
+  run(`gh pr merge ${prNumber} --squash --delete-branch --repo ${repo}`);
+}
+
+export function getReviews(prNumber, { repo }) {
+  const out = run(`gh api repos/${repo}/pulls/${prNumber}/reviews`);
+  return JSON.parse(out);
+}
+
+export function getPRBranch(prNumber, { repo }) {
+  const out = run(`gh pr view ${prNumber} --repo ${repo} --json headRefName --jq .headRefName`);
+  return out;
+}

package/src/hooks.js

@@ -0,0 +1,25 @@
+import { execSync } from 'child_process';
+
+export function runHook(name, config, context) {
+  const cmd = config.hooks?.[name];
+  if (!cmd) return { ran: false };
+
+  console.log(`  hook: ${name} → ${cmd}`);
+
+  const env = { ...process.env };
+  if (context.issueNumber) env.ISSUE_NUMBER = String(context.issueNumber);
+  if (context.prNumber) env.PR_NUMBER = String(context.prNumber);
+  if (context.branch) env.BRANCH = context.branch;
+  if (context.repo) env.REPO = context.repo;
+
+  try {
+    const stdout = execSync(cmd, { cwd: context.workdir, env, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
+    return { ran: true, hook: name, stdout, stderr: '', exitCode: 0 };
+  } catch (err) {
+    const result = { ran: true, hook: name, stdout: err.stdout || '', stderr: err.stderr || '', exitCode: err.status ?? 1 };
+    // Re-throw with the captured output attached so callers still get the error
+    const wrapped = new Error(`Hook "${name}" failed (exit ${result.exitCode}): ${(err.stderr || err.message).slice(0, 200)}`);
+    wrapped.hookResult = result;
+    throw wrapped;
+  }
+}

package/src/memory.js

@@ -0,0 +1,17 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+const MEMORY_FILE = 'memory.md';
+
+export function loadMemory(configDir) {
+  try {
+    return readFileSync(join(configDir, MEMORY_FILE), 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+export function saveMemory(configDir, content) {
+  mkdirSync(configDir, { recursive: true });
+  writeFileSync(join(configDir, MEMORY_FILE), content);
+}

package/src/reflect.js

@@ -0,0 +1,82 @@
+import * as claude from './claude.js';
+import { loadMemory, saveMemory } from './memory.js';
+
+export async function reflect({ configDir, step, issue, prNumber, success, error, hookOutputs, reviewComments, claudeOutput, maxLines = 100 }) {
+  const currentMemory = loadMemory(configDir);
+
+  const sections = [
+    '# Reflect on this task and update the memory file.',
+    '',
+    `Step: ${step}`,
+    `Outcome: ${success ? 'success' : 'failure'}`,
+  ];
+
+  if (issue) sections.push(`Issue: #${issue.number} — ${issue.title}`);
+  if (prNumber) sections.push(`PR: #${prNumber}`);
+
+  if (error) {
+    sections.push('', '## Error', '```', truncate(error, 500), '```');
+  }
+
+  if (hookOutputs?.length) {
+    sections.push('', '## Hook outputs');
+    for (const h of hookOutputs) {
+      sections.push(`### ${h.hook} (exit ${h.exitCode})`);
+      const output = (h.stdout + h.stderr).trim();
+      if (output) sections.push('```', truncate(output, 1000), '```');
+    }
+  }
+
+  if (reviewComments?.length) {
+    sections.push('', '## Review comments');
+    for (const c of reviewComments) {
+      sections.push(`- ${c.user?.login || 'reviewer'}: ${truncate(c.body || '', 200)}`);
+    }
+  }
+
+  if (claudeOutput) {
+    sections.push('', '## Claude output (truncated)', '```', truncate(String(claudeOutput), 1000), '```');
+  }
+
+  const prompt = [
+    'You are a memory manager for an automated coding agent.',
+    '',
+    `Here is the agent's current memory file (lessons learned from past tasks):`,
+    '',
+    currentMemory ? '```\n' + currentMemory + '\n```' : '(no memory yet)',
+    '',
+    'Here is what just happened:',
+    '',
+    sections.join('\n'),
+    '',
+    'Instructions:',
+    `- Output the COMPLETE updated memory file (markdown).`,
+    `- Keep it under ${maxLines} lines.`,
+    `- Preserve relevant existing lessons. Add new ones from this task.`,
+    `- Remove lessons that are contradicted by new evidence.`,
+    `- Be concise — each lesson should be 1-2 lines max.`,
+    `- Group lessons by topic (e.g. "## Testing", "## Code patterns").`,
+    `- Output ONLY the memory file content, no explanation.`,
+  ].join('\n');
+
+  try {
+    const result = await claude.run({
+      prompt,
+      workdir: process.cwd(),
+      allowedTools: '',
+      maxTurns: 1,
+      verbose: false,
+    });
+
+    const content = typeof result.result === 'string' ? result.result : JSON.stringify(result.result);
+    saveMemory(configDir, content.trim() + '\n');
+  } catch (err) {
+    // Reflection is best-effort — don't break the pipeline
+    console.log(`  warning: reflect failed: ${err.message}`);
+  }
+}
+
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen) + '\n... (truncated)';
+}

package/src/revise.js

@@ -0,0 +1,188 @@
+// Apply review feedback on an existing PR.
+
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { mkdirSync, rmSync } from 'fs';
+import * as git from './git.js';
+import * as claude from './claude.js';
+import * as warp from './warp.js';
+import { runHook } from './hooks.js';
+import { loadMemory } from './memory.js';
+import { reflect } from './reflect.js';
+
+const CONFIG_DIR = '.warp-coder';
+
+export async function revise(item, { board, config, log }) {
+  const prNumber = item.content?.number;
+  const repo = config.repo;
+  const repoName = repo.replace(/\.git$/, '').split('/').pop();
+  const maxRevisions = config.maxRevisions || 3;
+  const workdir = join(tmpdir(), 'warp-coder', `revise-${prNumber}`);
+  const configDir = join(process.cwd(), CONFIG_DIR);
+
+  log(`Revising PR #${prNumber}`);
+
+  // 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`);
+        try { await board.moveToBlocked(item); } catch {}
+        return false;
+      }
+      log(`  revision ${count + 1}/${maxRevisions}`);
+    } catch (err) {
+      log(`  warning: revision check failed: ${err.message}`);
+    }
+  }
+
+  // WarpMetrics: start pipeline
+  let groupId = null;
+  if (config.warpmetricsApiKey) {
+    try {
+      const pipeline = await warp.startPipeline(config.warpmetricsApiKey, {
+        step: 'revise',
+        repo: repoName,
+        prNumber,
+      });
+      groupId = pipeline.groupId;
+      log(`  pipeline: run=${pipeline.runId} group=${groupId}`);
+    } catch (err) {
+      log(`  warning: pipeline start failed: ${err.message}`);
+    }
+  }
+
+  let success = false;
+  let claudeResult = null;
+  let taskError = null;
+  let reviewComments = [];
+  const hookOutputs = [];
+
+  try {
+    // Clone + checkout PR branch
+    rmSync(workdir, { recursive: true, force: true });
+    mkdirSync(workdir, { recursive: true });
+    log(`  cloning into ${workdir}`);
+    git.cloneRepo(repo, workdir);
+
+    const branch = git.getPRBranch(prNumber, { repo: repoName });
+    git.checkoutBranch(workdir, branch);
+    log(`  branch: ${branch}`);
+
+    // Fetch review comments for context
+    try {
+      reviewComments = git.getReviews(prNumber, { repo: repoName });
+    } catch (err) {
+      log(`  warning: could not fetch reviews: ${err.message}`);
+    }
+
+    // Load memory for prompt enrichment
+    const memory = config.memory?.enabled !== false ? loadMemory(configDir) : '';
+
+    // Claude
+    const promptParts = [
+      `You are working on PR #${prNumber} in ${repoName}.`,
+      '',
+    ];
+
+    if (memory) {
+      promptParts.push(
+        'Lessons learned from previous tasks in this repository:',
+        '',
+        memory,
+        '',
+      );
+    }
+
+    promptParts.push(
+      'A code review has been submitted with comments. Your job:',
+      '',
+      '1. Read all review comments on this PR',
+      '2. Apply the suggested fixes',
+      '3. Run tests to make sure everything passes',
+      '4. Commit the fixes with a message like "Address review feedback"',
+      '',
+      'Do NOT open a new PR — just implement the fixes and commit.',
+    );
+
+    const prompt = promptParts.join('\n');
+
+    log('  running claude...');
+    claudeResult = await claude.run({
+      prompt,
+      workdir,
+      allowedTools: config.claude?.allowedTools,
+      maxTurns: config.claude?.maxTurns,
+    });
+    log(`  claude done (cost: $${claudeResult.costUsd ?? '?'})`);
+
+    // Hook: onBeforePush
+    try {
+      const h = runHook('onBeforePush', config, { workdir, prNumber, branch, repo: repoName });
+      if (h.ran) hookOutputs.push(h);
+    } catch (err) {
+      if (err.hookResult) hookOutputs.push(err.hookResult);
+      throw err;
+    }
+
+    // Push
+    log('  pushing...');
+    git.push(workdir, branch);
+
+    // Move back to In Review
+    try {
+      await board.moveToReview(item);
+    } catch (err) {
+      log(`  warning: could not move to In Review: ${err.message}`);
+    }
+
+    success = true;
+  } catch (err) {
+    taskError = err.message;
+    log(`  failed: ${err.message}`);
+  } finally {
+    // WarpMetrics: record outcome
+    if (config.warpmetricsApiKey && groupId) {
+      try {
+        const outcome = await warp.recordOutcome(config.warpmetricsApiKey, groupId, {
+          step: 'revise',
+          success,
+          costUsd: claudeResult?.costUsd,
+          error: taskError,
+          hooksFailed: hookOutputs.some(h => h.exitCode !== 0),
+          prNumber,
+          reviewCommentCount: reviewComments.length,
+        });
+        log(`  outcome: ${outcome.name}`);
+      } catch (err) {
+        log(`  warning: outcome recording failed: ${err.message}`);
+      }
+    }
+
+    // Reflect
+    if (config.memory?.enabled !== false) {
+      try {
+        await reflect({
+          configDir,
+          step: 'revise',
+          prNumber,
+          success,
+          error: taskError,
+          hookOutputs: hookOutputs.filter(h => h.ran),
+          reviewComments,
+          claudeOutput: claudeResult?.result,
+          maxLines: config.memory?.maxLines || 100,
+        });
+        log('  reflect: memory updated');
+      } catch (err) {
+        log(`  warning: reflect failed: ${err.message}`);
+      }
+    }
+
+    // Cleanup
+    rmSync(workdir, { recursive: true, force: true });
+  }
+
+  return success;
+}

package/{defaults/scripts/pipeline.js → src/warp.js}

@@ -1,11 +1,9 @@
-// Agent pipeline — shared helpers for WarpMetrics instrumentation.
+// WarpMetrics instrumentation client.
 // Zero external dependencies — uses Node built-ins + global fetch.
 
 import crypto from 'crypto';
-import { writeFileSync, readFileSync, existsSync } from 'fs';
 
 const API_URL = 'https://api.warpmetrics.com';
-const STATE_FILE = '.pipeline-state.json';
 
 // ---------------------------------------------------------------------------
 // ID generation
@@ -18,7 +16,7 @@ export function generateId(prefix) {
 }
 
 // ---------------------------------------------------------------------------
-// WarpMetrics Events API (same wire format as @warpmetrics/warp)
+// Events API (same wire format as @warpmetrics/warp)
 // ---------------------------------------------------------------------------
 
 export async function sendEvents(apiKey, batch) {
@@ -50,7 +48,7 @@ export async function sendEvents(apiKey, batch) {
 }
 
 // ---------------------------------------------------------------------------
-// WarpMetrics Query API
+// Query API
 // ---------------------------------------------------------------------------
 
 export async function findRuns(apiKey, label, { limit = 20 } = {}) {
@@ -97,14 +95,62 @@ export async function registerClassifications(apiKey) {
 }
 
 // ---------------------------------------------------------------------------
-// Cross-step state
+// Pipeline helpers — start run/group and record outcome
 // ---------------------------------------------------------------------------
 
-export function saveState(state) {
-  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+export async function startPipeline(apiKey, { step, repo, issueNumber, issueTitle, prNumber }) {
+  const runId = generateId('run');
+  const groupId = generateId('grp');
+  const now = new Date().toISOString();
+
+  const opts = { repo, step };
+  if (issueNumber) opts.issue = String(issueNumber);
+  if (issueTitle) opts.title = issueTitle;
+  if (prNumber) opts.pr_number = String(prNumber);
+
+  await sendEvents(apiKey, {
+    runs: [{ id: runId, label: 'agent-pipeline', opts, refId: null, timestamp: now }],
+    groups: [{ id: groupId, label: step, opts: { triggered_at: now }, timestamp: now }],
+    links: [{ parentId: runId, childId: groupId, type: 'group', timestamp: now }],
+  });
+
+  return { runId, groupId };
 }
 
-export function loadState() {
-  if (!existsSync(STATE_FILE)) return null;
-  return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+export async function recordOutcome(apiKey, groupId, { step, success, costUsd, error, hooksFailed, issueNumber, prNumber, reviewCommentCount }) {
+  const names = {
+    implement: { true: 'PR Created', false: 'Implementation Failed' },
+    revise: { true: 'Fixes Applied', false: 'Revision Failed' },
+  };
+
+  const name = names[step]?.[String(success)] || `${step}: ${success ? 'success' : 'failure'}`;
+  const id = generateId('oc');
+  const now = new Date().toISOString();
+
+  const opts = { status: success ? 'success' : 'failure', step };
+  if (costUsd != null) opts.cost_usd = String(costUsd);
+  if (error) opts.error = error.slice(0, 500);
+  if (hooksFailed) opts.hooks_failed = 'true';
+  if (issueNumber) opts.issue = String(issueNumber);
+  if (prNumber) opts.pr_number = String(prNumber);
+  if (reviewCommentCount) opts.review_comments = String(reviewCommentCount);
+
+  await sendEvents(apiKey, {
+    outcomes: [{ id, refId: groupId, name, opts, timestamp: now }],
+  });
+
+  return { id, name };
+}
+
+export async function countRevisions(apiKey, { prNumber, repo }) {
+  try {
+    const runs = await findRuns(apiKey, 'agent-pipeline');
+    return runs.filter(r =>
+      r.opts?.step === 'revise' &&
+      r.opts?.pr_number === String(prNumber) &&
+      r.opts?.repo === repo
+    ).length;
+  } catch {
+    return 0;
+  }
 }

package/src/watch.js

@@ -0,0 +1,76 @@
+// Main poll loop: watches the board and processes tasks sequentially.
+
+import { loadConfig } from './config.js';
+import { createBoard } from './boards/index.js';
+import { implement } from './agent.js';
+import { revise } from './revise.js';
+import * as git from './git.js';
+import { runHook } from './hooks.js';
+
+export async function watch() {
+  const config = loadConfig();
+  const board = createBoard(config);
+  const pollInterval = (config.pollInterval || 30) * 1000;
+
+  let running = true;
+  const shutdown = () => {
+    console.log('\nShutting down...');
+    running = false;
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  const log = msg => console.log(`[${new Date().toISOString()}] ${msg}`);
+
+  log('warp-coder watching...');
+  log(`  board: ${config.board.provider} (project ${config.board.project})`);
+  log(`  repo: ${config.repo}`);
+  log(`  poll interval: ${config.pollInterval || 30}s`);
+
+  while (running) {
+    try {
+      // 1. Pick up new tasks from Todo
+      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 });
+      }
+
+      // 2. Check for items needing revision
+      const reviewItems = await board.listInReview();
+      for (const item of reviewItems) {
+        if (!running) break;
+        log(`Found review feedback: PR #${item.content?.number}`);
+        await revise(item, { board, config, log });
+      }
+
+      // 3. Merge approved PRs
+      const approvedItems = await board.listApproved();
+      for (const item of approvedItems) {
+        if (!running) break;
+        const prNumber = item.content?.number;
+        const repoName = config.repo.replace(/\.git$/, '').split('/').pop();
+        log(`Merging approved PR #${prNumber}`);
+        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`);
+        } catch (err) {
+          log(`  merge failed: ${err.message}`);
+        }
+      }
+    } catch (err) {
+      log(`Poll error: ${err.message}`);
+    }
+
+    // Sleep
+    if (running) {
+      await new Promise(resolve => setTimeout(resolve, pollInterval));
+    }
+  }
+
+  log('Stopped.');
+}