@warpmetrics/coder 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 WarpMetrics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,64 @@
+# @warpmetrics/coder
+
+Agent pipeline for implementing GitHub issues with Claude Code. Label an issue with `agent` and it gets implemented, reviewed, and revised automatically.
+
+## Quick Start
+
+```bash
+npx @warpmetrics/coder init
+```
+
+This will:
+1. Set up `ANTHROPIC_API_KEY` and `WARPMETRICS_API_KEY` as GitHub secrets
+2. Add two workflow files to `.github/workflows/`
+3. Add pipeline scripts to `.github/scripts/`
+4. Register outcome classifications with WarpMetrics
+
+## How It Works
+
+```
+Issue labeled "agent"
+  → agent-implement.yml runs Claude Code Action
+    → Claude reads the issue, creates a branch, implements, opens PR
+      → warp-review reviews the PR (if installed)
+        → agent-revise.yml applies feedback and pushes fixes
+          → Loop until approved or revision limit (3) reached
+```
+
+Every step is instrumented with [WarpMetrics](https://warpmetrics.com) — you get runs, groups, and outcomes tracking the full pipeline.
+
+## Workflows
+
+### agent-implement.yml
+
+Triggered when an issue is labeled `agent`. Creates a branch `agent/issue-{number}`, implements the issue, and opens a PR.
+
+### agent-revise.yml
+
+Triggered when `github-actions[bot]` submits a review with comments (i.e., warp-review feedback). Applies the review feedback and pushes to the same branch. Stops after 3 revision attempts.
+
+## Outcome Classifications
+
+| Name | Classification |
+|------|---------------|
+| PR Created | success |
+| Fixes Applied | success |
+| Issue Understood | success |
+| Needs Clarification | neutral |
+| Needs Human | neutral |
+| Implementation Failed | failure |
+| Tests Failed | failure |
+| Revision Failed | failure |
+| Max Retries | failure |
+
+## Pairing with warp-review
+
+For the full implement → review → revise loop, install [warp-review](https://github.com/warpmetrics/warp-review):
+
+```bash
+npx @warpmetrics/review init
+```
+
+## License
+
+MIT

package/bin/init.js

@@ -0,0 +1,178 @@
+#!/usr/bin/env node
+
+import { createInterface } from 'readline';
+import { existsSync, mkdirSync, copyFileSync, readdirSync } from 'fs';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const defaultsDir = join(__dirname, '..', 'defaults');
+
+const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+function ask(question) {
+  return new Promise(resolve => rl.question(question, resolve));
+}
+
+function log(msg) {
+  console.log(msg);
+}
+
+async function main() {
+  log('');
+  log('  warp-coder \u2014 Agent pipeline for implementing GitHub issues');
+  log('');
+
+  // 1. Anthropic API key
+  const anthropicKey = await ask('  ? Anthropic API key: ');
+  if (!anthropicKey.startsWith('sk-ant-')) {
+    log('  \u26a0 Warning: key doesn\'t start with sk-ant- \u2014 make sure this is a valid Anthropic API key');
+  }
+
+  // 2. WarpMetrics API key
+  const wmKey = await ask('  ? WarpMetrics API key (get one at warpmetrics.com/app/api-keys): ');
+  if (!wmKey.startsWith('wm_')) {
+    log('  \u26a0 Warning: key doesn\'t start with wm_ \u2014 make sure this is a valid WarpMetrics API key');
+  }
+
+  log('');
+
+  // 3. Set GitHub secrets
+  let ghAvailable = false;
+  try {
+    execSync('gh --version', { stdio: 'ignore' });
+    ghAvailable = true;
+  } catch {
+    ghAvailable = false;
+  }
+
+  if (ghAvailable) {
+    log('  Setting GitHub secrets...');
+    try {
+      execSync('gh secret set ANTHROPIC_API_KEY', { input: anthropicKey, stdio: ['pipe', 'ignore', 'ignore'] });
+      log('  \u2713 ANTHROPIC_API_KEY set');
+    } catch (e) {
+      log(`  \u2717 Failed to set ANTHROPIC_API_KEY: ${e.message}`);
+    }
+    try {
+      execSync('gh secret set WARPMETRICS_API_KEY', { input: wmKey, stdio: ['pipe', 'ignore', 'ignore'] });
+      log('  \u2713 WARPMETRICS_API_KEY set');
+    } catch (e) {
+      log(`  \u2717 Failed to set WARPMETRICS_API_KEY: ${e.message}`);
+    }
+  } else {
+    log('  gh (GitHub CLI) not found. Set these secrets manually:');
+    log('');
+    log('  gh secret set ANTHROPIC_API_KEY');
+    log('  gh secret set WARPMETRICS_API_KEY');
+    log('  (gh will prompt for the value interactively)');
+  }
+  log('');
+
+  // 4. Copy workflows
+  await copyWorkflow('agent-implement.yml');
+  await copyWorkflow('agent-revise.yml');
+
+  // 5. Copy scripts
+  await copyScripts();
+
+  log('');
+
+  // 6. Register outcome classifications
+  log('  Registering outcome classifications with WarpMetrics...');
+  const classifications = [
+    { name: 'PR Created', classification: 'success' },
+    { name: 'Fixes Applied', classification: 'success' },
+    { name: 'Issue Understood', classification: 'success' },
+    { name: 'Needs Clarification', classification: 'neutral' },
+    { name: 'Needs Human', classification: 'neutral' },
+    { name: 'Implementation Failed', classification: 'failure' },
+    { name: 'Tests Failed', classification: 'failure' },
+    { name: 'Revision Failed', classification: 'failure' },
+    { name: 'Max Retries', classification: 'failure' },
+  ];
+
+  let classOk = true;
+  for (const { name, classification } of classifications) {
+    try {
+      const res = await fetch(`https://api.warpmetrics.com/v1/outcomes/classifications/${encodeURIComponent(name)}`, {
+        method: 'PUT',
+        headers: {
+          Authorization: `Bearer ${wmKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ classification }),
+      });
+      if (!res.ok) {
+        classOk = false;
+        console.warn(`  \u26a0 Failed to set classification ${name}: ${res.status}`);
+      }
+    } catch (e) {
+      classOk = false;
+      console.warn(`  \u26a0 Failed to set classification ${name}: ${e.message}`);
+    }
+  }
+  if (classOk) {
+    log('  \u2713 Outcomes configured');
+  } else {
+    log('  \u26a0 Some classifications failed \u2014 you can set them manually in the WarpMetrics dashboard');
+  }
+
+  // 7. Check for warp-review
+  log('');
+  if (!existsSync('.github/workflows/warp-review.yml')) {
+    log('  \u26a0 warp-review not found. Install it for automated code reviews on agent PRs:');
+    log('  npx @warpmetrics/review init');
+  } else {
+    log('  \u2713 warp-review detected \u2014 agent PRs will be reviewed automatically');
+  }
+
+  // 8. Print next steps
+  log('');
+  log('  Done! Next steps:');
+  log('  1. git add .github/workflows .github/scripts');
+  log('  2. git commit -m "Add warp-coder agent pipeline"');
+  log('  3. Label a GitHub issue with "agent" to trigger implementation');
+  log('  4. View pipeline analytics at https://app.warpmetrics.com');
+  log('');
+
+  rl.close();
+}
+
+async function copyWorkflow(filename) {
+  const dest = `.github/workflows/${filename}`;
+  if (existsSync(dest)) {
+    const overwrite = await ask(`  ${filename} already exists. Overwrite? (y/N): `);
+    if (overwrite.toLowerCase() !== 'y') {
+      log(`  Skipping ${filename}`);
+      return;
+    }
+  }
+  mkdirSync('.github/workflows', { recursive: true });
+  copyFileSync(join(defaultsDir, filename), dest);
+  log(`  \u2713 ${dest} created`);
+}
+
+async function copyScripts() {
+  const scriptsDir = '.github/scripts';
+  if (existsSync(scriptsDir)) {
+    const overwrite = await ask('  .github/scripts/ already exists. Overwrite? (y/N): ');
+    if (overwrite.toLowerCase() !== 'y') {
+      log('  Skipping scripts');
+      return;
+    }
+  }
+  mkdirSync(scriptsDir, { recursive: true });
+  const srcDir = join(defaultsDir, 'scripts');
+  for (const file of readdirSync(srcDir)) {
+    copyFileSync(join(srcDir, file), join(scriptsDir, file));
+  }
+  log(`  \u2713 .github/scripts/ created (${readdirSync(srcDir).length} files)`);
+}
+
+main().catch(err => {
+  console.error('init failed:', err.message);
+  process.exitCode = 1;
+  rl.close();
+});

package/defaults/agent-implement.yml

@@ -0,0 +1,74 @@
+name: Agent — Implement Issue
+
+on:
+  issues:
+    types: [labeled]
+
+permissions:
+  contents: write
+  pull-requests: write
+  issues: write
+
+jobs:
+  implement:
+    if: github.event.label.name == 'agent'
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Start pipeline
+        run: node .github/scripts/pipeline-start.js
+        env:
+          WARPMETRICS_API_KEY: ${{ secrets.WARPMETRICS_API_KEY }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          STEP: implement
+          ISSUE_NUMBER: ${{ github.event.issue.number }}
+          ISSUE_TITLE: ${{ github.event.issue.title }}
+
+      - name: Implement issue
+        id: agent
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          direct_prompt: |
+            You are working on the repository ${{ github.repository }}.
+
+            Implement the following GitHub issue:
+
+            **#${{ github.event.issue.number }}: ${{ github.event.issue.title }}**
+
+            ${{ github.event.issue.body }}
+
+            Steps:
+            1. Read the codebase to understand relevant context
+            2. Create a new branch: agent/issue-${{ github.event.issue.number }}
+            3. Implement the changes
+            4. Run tests to verify nothing is broken
+            5. Commit with a clear message
+            6. Push the branch and open a pull request
+            7. Include "Closes #${{ github.event.issue.number }}" in the PR body
+
+            If the issue is unclear or you cannot implement it, explain what is missing.
+
+      - name: Record outcome
+        if: always()
+        run: node .github/scripts/pipeline-outcome.js
+        env:
+          WARPMETRICS_API_KEY: ${{ secrets.WARPMETRICS_API_KEY }}
+          STEP: implement
+          STATUS: ${{ steps.agent.outcome }}
+
+      - name: Comment on failure
+        if: failure()
+        run: |
+          gh issue comment ${{ github.event.issue.number }} \
+            --body "Agent failed to implement this issue. See the [workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})."
+          gh issue edit ${{ github.event.issue.number }} --add-label "agent-failed" --remove-label "agent"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/defaults/agent-revise.yml

@@ -0,0 +1,81 @@
+name: Agent — Revise PR
+
+on:
+  pull_request_review:
+    types: [submitted]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  revise:
+    # Only trigger when warp-review (bot) submits a review with comments
+    # and the PR was created by the agent (has "agent" label on the linked issue)
+    if: >
+      github.event.review.user.login == 'github-actions[bot]' &&
+      github.event.review.state == 'COMMENTED'
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.ref }}
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+
+      - name: Check revision limit
+        id: check
+        run: node .github/scripts/check-revision-limit.js
+        env:
+          WARPMETRICS_API_KEY: ${{ secrets.WARPMETRICS_API_KEY }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+
+      - name: Start pipeline
+        if: steps.check.outputs.should_revise == 'true'
+        run: node .github/scripts/pipeline-start.js
+        env:
+          WARPMETRICS_API_KEY: ${{ secrets.WARPMETRICS_API_KEY }}
+          GITHUB_REPOSITORY: ${{ github.repository }}
+          STEP: revise
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+
+      - name: Apply review feedback
+        id: agent
+        if: steps.check.outputs.should_revise == 'true'
+        uses: anthropics/claude-code-action@v1
+        with:
+          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
+          direct_prompt: |
+            You are working on PR #${{ github.event.pull_request.number }} in ${{ github.repository }}.
+
+            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"
+            5. Push to the same branch
+
+            Do NOT open a new PR — just push to the existing branch.
+
+      - name: Record outcome
+        if: always() && steps.check.outputs.should_revise == 'true'
+        run: node .github/scripts/pipeline-outcome.js
+        env:
+          WARPMETRICS_API_KEY: ${{ secrets.WARPMETRICS_API_KEY }}
+          STEP: revise
+          STATUS: ${{ steps.agent.outcome }}
+
+      - name: Request human review
+        if: steps.check.outputs.should_revise == 'false'
+        run: |
+          gh pr comment ${{ github.event.pull_request.number }} \
+            --body "Agent has reached the revision limit (${{ steps.check.outputs.revision_count }} attempts). Requesting human review."
+          gh pr edit ${{ github.event.pull_request.number }} --add-label "needs-human"
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/defaults/scripts/check-revision-limit.js

@@ -0,0 +1,47 @@
+// Agent pipeline — check if we should attempt another revision.
+// Queries WarpMetrics for previous "revise" runs on this PR.
+// Sets GitHub Actions outputs: should_revise, revision_count.
+
+import { appendFileSync } from 'fs';
+import { findRuns } from './pipeline.js';
+
+const apiKey = process.env.WARPMETRICS_API_KEY;
+const prNumber = process.env.PR_NUMBER;
+const repo = process.env.GITHUB_REPOSITORY;
+const MAX_REVISIONS = 3;
+
+function setOutput(key, value) {
+  if (process.env.GITHUB_OUTPUT) {
+    appendFileSync(process.env.GITHUB_OUTPUT, `${key}=${value}\n`);
+  }
+  console.log(`${key}=${value}`);
+}
+
+if (!apiKey) {
+  setOutput('should_revise', 'true');
+  setOutput('revision_count', '0');
+  process.exit(0);
+}
+
+try {
+  const runs = await findRuns(apiKey, 'agent-pipeline');
+  const revisions = runs.filter(r =>
+    r.opts?.step === 'revise' &&
+    r.opts?.pr_number === String(prNumber) &&
+    r.opts?.repo === repo
+  );
+
+  const count = revisions.length;
+  const shouldRevise = count < MAX_REVISIONS;
+
+  setOutput('should_revise', String(shouldRevise));
+  setOutput('revision_count', String(count));
+
+  console.log(shouldRevise
+    ? `Revision ${count + 1}/${MAX_REVISIONS}`
+    : `Revision limit reached (${count}/${MAX_REVISIONS})`);
+} catch (err) {
+  console.warn(`Revision check failed: ${err.message} — allowing revision`);
+  setOutput('should_revise', 'true');
+  setOutput('revision_count', '0');
+}

package/defaults/scripts/pipeline-outcome.js

@@ -0,0 +1,33 @@
+// Agent pipeline — record an outcome after the agent step.
+
+import { generateId, sendEvents, loadState } from './pipeline.js';
+
+const apiKey = process.env.WARPMETRICS_API_KEY;
+const status = process.env.STATUS; // "success" or "failure"
+const step = process.env.STEP;
+
+if (!apiKey) process.exit(0);
+
+const state = loadState();
+if (!state) {
+  console.warn('No pipeline state — skipping outcome');
+  process.exit(0);
+}
+
+const names = {
+  implement: { success: 'PR Created', failure: 'Implementation Failed' },
+  revise: { success: 'Fixes Applied', failure: 'Revision Failed' },
+};
+
+const name = names[step]?.[status] || `${step}: ${status}`;
+const id = generateId('oc');
+const now = new Date().toISOString();
+
+try {
+  await sendEvents(apiKey, {
+    outcomes: [{ id, refId: state.groupId, name, opts: { status, step }, timestamp: now }],
+  });
+  console.log(`Outcome: ${name} (${id})`);
+} catch (err) {
+  console.warn(`Failed to record outcome: ${err.message}`);
+}

package/defaults/scripts/pipeline-start.js

@@ -0,0 +1,40 @@
+// Agent pipeline — create a WarpMetrics run + group before the agent step.
+
+import { generateId, sendEvents, registerClassifications, saveState } from './pipeline.js';
+
+const apiKey = process.env.WARPMETRICS_API_KEY;
+const repo = process.env.GITHUB_REPOSITORY;
+const step = process.env.STEP; // "implement" or "revise"
+const issueNumber = process.env.ISSUE_NUMBER || null;
+const issueTitle = process.env.ISSUE_TITLE || null;
+const prNumber = process.env.PR_NUMBER || null;
+
+if (!apiKey) {
+  console.log('WARPMETRICS_API_KEY not set — skipping');
+  process.exit(0);
+}
+
+const runId = generateId('run');
+const groupId = generateId('grp');
+const now = new Date().toISOString();
+
+const opts = { repo, step };
+if (issueNumber) opts.issue = issueNumber;
+if (issueTitle) opts.title = issueTitle;
+if (prNumber) opts.pr_number = prNumber;
+
+try {
+  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 }],
+  });
+  console.log(`Pipeline run=${runId} group=${groupId} step=${step}`);
+} catch (err) {
+  console.warn(`Failed to start pipeline: ${err.message}`);
+}
+
+saveState({ runId, groupId, step });
+
+// Register outcome classifications on first run (idempotent)
+await registerClassifications(apiKey).catch(() => {});

package/defaults/scripts/pipeline.js

@@ -0,0 +1,110 @@
+// Agent pipeline — shared helpers for WarpMetrics instrumentation.
+// 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
+// ---------------------------------------------------------------------------
+
+export function generateId(prefix) {
+  const t = Date.now().toString(36).padStart(10, '0');
+  const r = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+  return `wm_${prefix}_${t}${r}`;
+}
+
+// ---------------------------------------------------------------------------
+// WarpMetrics Events API (same wire format as @warpmetrics/warp)
+// ---------------------------------------------------------------------------
+
+export async function sendEvents(apiKey, batch) {
+  const full = {
+    runs: batch.runs || [],
+    groups: batch.groups || [],
+    calls: batch.calls || [],
+    links: batch.links || [],
+    outcomes: batch.outcomes || [],
+    acts: batch.acts || [],
+  };
+
+  const raw = JSON.stringify(full);
+  const body = JSON.stringify({ d: Buffer.from(raw, 'utf-8').toString('base64') });
+
+  const res = await fetch(`${API_URL}/v1/events`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body,
+  });
+
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`Events API ${res.status}: ${text}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// WarpMetrics Query API
+// ---------------------------------------------------------------------------
+
+export async function findRuns(apiKey, label, { limit = 20 } = {}) {
+  const params = new URLSearchParams({ label, limit: String(limit) });
+  const res = await fetch(`${API_URL}/v1/runs?${params}`, {
+    headers: { Authorization: `Bearer ${apiKey}` },
+  });
+  if (!res.ok) return [];
+  const data = await res.json();
+  return data.data || [];
+}
+
+// ---------------------------------------------------------------------------
+// Outcome classifications (idempotent PUT)
+// ---------------------------------------------------------------------------
+
+export async function registerClassifications(apiKey) {
+  const items = [
+    { name: 'PR Created', classification: 'success' },
+    { name: 'Fixes Applied', classification: 'success' },
+    { name: 'Issue Understood', classification: 'success' },
+    { name: 'Needs Clarification', classification: 'neutral' },
+    { name: 'Needs Human', classification: 'neutral' },
+    { name: 'Implementation Failed', classification: 'failure' },
+    { name: 'Tests Failed', classification: 'failure' },
+    { name: 'Revision Failed', classification: 'failure' },
+    { name: 'Max Retries', classification: 'failure' },
+  ];
+
+  for (const { name, classification } of items) {
+    try {
+      await fetch(`${API_URL}/v1/outcomes/classifications/${encodeURIComponent(name)}`, {
+        method: 'PUT',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ classification }),
+      });
+    } catch {
+      // Best-effort
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Cross-step state
+// ---------------------------------------------------------------------------
+
+export function saveState(state) {
+  writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+}
+
+export function loadState() {
+  if (!existsSync(STATE_FILE)) return null;
+  return JSON.parse(readFileSync(STATE_FILE, 'utf-8'));
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@warpmetrics/coder",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Agent pipeline for implementing GitHub issues with Claude Code. Powered by WarpMetrics.",
+  "bin": {
+    "warp-coder": "./bin/init.js"
+  },
+  "scripts": {
+    "release:patch": "npm version patch && git push origin main --tags",
+    "release:minor": "npm version minor && git push origin main --tags"
+  },
+  "files": [
+    "bin/",
+    "defaults/",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/warpmetrics/warp-coder"
+  },
+  "keywords": [
+    "agent",
+    "claude-code",
+    "github-action",
+    "warpmetrics",
+    "llm",
+    "code-generation"
+  ]
+}