@elmiristic/agent-ready 0.1.0

package/README.md

@@ -0,0 +1,41 @@
+# agent-ready
+
+Wire an AI coding agent into any GitHub repo in 5 minutes.
+
+Tag a Trello card **agent-ready**, and Claude reads the task, edits the code, opens a PR, and pings you on Telegram — twice a day, automatically.
+
+## Quick start
+
+```bash
+npx agent-ready init
+```
+
+The wizard will:
+1. Connect your Trello board
+2. Add your Anthropic API key
+3. Give you a Telegram chat ID via @agent_ready_bot
+4. Set all GitHub secrets automatically
+5. Write the GitHub Actions workflows into your repo
+
+Then commit and push `.github/` and you're live.
+
+## How it works
+
+1. Add the `agent-ready` label to a Trello card in your **To Do** list
+2. The agent runs at **9am and 5pm** (or trigger manually in GitHub Actions)
+3. Claude reads the card title + description, identifies relevant files, writes the code
+4. A PR is opened — nothing touches `main` without your review
+5. You get a Telegram message with the PR link
+6. Merge the PR → card moves to **Done** automatically
+
+## Requirements
+
+- Node.js 18+
+- A GitHub repository
+- GitHub CLI (`gh`) for automatic secret setup (optional — can set manually)
+- A Trello account
+- An Anthropic API key
+
+## License
+
+MIT

package/bin/agent-ready.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { init } from '../src/init.js'
+
+const [, , command] = process.argv
+
+switch (command) {
+  case 'init':
+    await init()
+    break
+  default:
+    console.log(`
+  agent-ready — wire an AI coding agent into any repo in 5 minutes
+
+  Usage:
+    npx agent-ready init    Set up the agent in your current repo
+`)
+    process.exit(0)
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@elmiristic/agent-ready",
+  "version": "0.1.0",
+  "description": "Wire a Trello + Claude AI + GitHub Actions coding agent into any repo in 5 minutes.",
+  "type": "module",
+  "bin": {
+    "agent-ready": "./bin/agent-ready.js"
+  },
+  "scripts": {
+    "dev": "node bin/agent-ready.js init"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "trello",
+    "github-actions",
+    "claude",
+    "anthropic",
+    "automation",
+    "cli",
+    "telegram",
+    "coding-agent"
+  ],
+  "author": "Amazesofts",
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^7.5.0",
+    "chalk": "^5.4.1",
+    "execa": "^9.5.2",
+    "fs-extra": "^11.3.0",
+    "ora": "^8.1.1"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/init.js

@@ -0,0 +1,28 @@
+import chalk from 'chalk'
+import { welcome } from './steps/welcome.js'
+import { collectTrello } from './steps/collectTrello.js'
+import { collectAnthropic } from './steps/collectAnthropic.js'
+import { collectTelegram } from './steps/collectTelegram.js'
+import { setGithubSecrets } from './steps/setGithubSecrets.js'
+import { scaffold } from './steps/scaffold.js'
+import { done } from './steps/done.js'
+
+export async function init() {
+  try {
+    await welcome()
+    const trello = await collectTrello()
+    const anthropic = await collectAnthropic()
+    const telegram = await collectTelegram()
+    const secrets = { ...trello, ...anthropic, ...telegram }
+    await setGithubSecrets(secrets)
+    await scaffold()
+    await done()
+  } catch (err) {
+    if (err.name === 'ExitPromptError') {
+      console.log(chalk.dim('\n  Setup cancelled.'))
+      process.exit(0)
+    }
+    console.error(chalk.red('\n  Error: ' + err.message))
+    process.exit(1)
+  }
+}

package/src/steps/collectAnthropic.js

@@ -0,0 +1,23 @@
+import chalk from 'chalk'
+import { password } from '@inquirer/prompts'
+
+export async function collectAnthropic() {
+  console.log(chalk.bold('  Step 2 of 3 — Anthropic'))
+  console.log()
+  console.log(
+    chalk.dim('  1. Go to: ') + chalk.cyan('https://console.anthropic.com/settings/keys'),
+  )
+  console.log(chalk.dim('  2. Create a new API key and paste it below'))
+  console.log()
+
+  const apiKey = await password({
+    message: '  Anthropic API Key',
+    mask: '●',
+  })
+
+  console.log()
+
+  return {
+    ANTHROPIC_API_KEY: apiKey,
+  }
+}

package/src/steps/collectTelegram.js

@@ -0,0 +1,25 @@
+import chalk from 'chalk'
+import { input } from '@inquirer/prompts'
+
+export async function collectTelegram() {
+  console.log(chalk.bold('  Step 3 of 3 — Telegram'))
+  console.log()
+  console.log(chalk.dim('  Open Telegram and message: ') + chalk.cyan('@agentreadybot'))
+  console.log()
+  console.log(chalk.dim('  Send: ') + chalk.white('/start'))
+  console.log()
+  console.log(chalk.dim('  The bot will reply with your Chat ID. Paste it below.'))
+  console.log()
+
+  const chatId = await input({
+    message: '  Your Telegram Chat ID',
+  })
+
+  console.log()
+
+  return {
+    TELEGRAM_BOT_TOKEN: 'managed',
+    TELEGRAM_CHAT_ID: chatId,
+    AGENT_READY_SECRET: 'ar_shared_2026',
+  }
+}

package/src/steps/collectTrello.js

@@ -0,0 +1,76 @@
+import chalk from 'chalk'
+import { input, password, confirm } from '@inquirer/prompts'
+
+export async function collectTrello() {
+  console.log(chalk.bold('  Step 1 of 3 — Trello'))
+  console.log()
+  console.log(
+    chalk.dim('  1. Go to: ') +
+      chalk.cyan('https://trello.com/power-ups/admin'),
+  )
+  console.log(chalk.dim('  2. Create a Power-Up → go to API Key tab'))
+  console.log(chalk.dim('  3. Copy your Key, then click "Token" to generate your Token'))
+  console.log()
+
+  const apiKey = await password({
+    message: '  Trello API Key',
+    mask: '●',
+  })
+
+  const token = await password({
+    message: '  Trello Token',
+    mask: '●',
+  })
+
+  console.log()
+  console.log(chalk.dim('  To find your List IDs, open this URL in your browser:'))
+  console.log(
+    chalk.cyan(
+      `  https://api.trello.com/1/members/me/boards?key=${apiKey}&token=${token}`,
+    ),
+  )
+  console.log(chalk.dim('  Copy your board ID, then open:'))
+  console.log(
+    chalk.cyan(
+      `  https://api.trello.com/1/boards/BOARD_ID/lists?key=${apiKey}&token=${token}`,
+    ),
+  )
+  console.log()
+
+  const todoListId = await input({
+    message: '  To Do list ID',
+  })
+
+  const doingListId = await input({
+    message: '  Doing list ID',
+  })
+
+  const doneListId = await input({
+    message: '  Done list ID',
+  })
+
+  console.log()
+  console.log(chalk.dim('  Now create a label called "agent-ready" on your board.'))
+  console.log(chalk.dim('  Then open this URL to find its ID:'))
+  console.log(
+    chalk.cyan(
+      `  https://api.trello.com/1/boards/BOARD_ID/labels?key=${apiKey}&token=${token}`,
+    ),
+  )
+  console.log()
+
+  const labelId = await input({
+    message: '  agent-ready label ID',
+  })
+
+  console.log()
+
+  return {
+    TRELLO_API_KEY: apiKey,
+    TRELLO_TOKEN: token,
+    TRELLO_LIST_ID: todoListId,
+    TRELLO_DOING_LIST_ID: doingListId,
+    TRELLO_DONE_LIST_ID: doneListId,
+    TRELLO_AGENT_LABEL_ID: labelId,
+  }
+}

package/src/steps/done.js

@@ -0,0 +1,29 @@
+import chalk from 'chalk'
+
+export async function done() {
+  console.log(chalk.dim('  ─────────────────────────────────────────────────'))
+  console.log()
+  console.log('  ' + chalk.green('✓') + chalk.bold('  agent-ready is set up.'))
+  console.log()
+  console.log(chalk.dim('  How it works:'))
+  console.log(
+    chalk.dim('  1. Add the ') +
+      chalk.yellow('agent-ready') +
+      chalk.dim(' label to a Trello card in your To Do list'),
+  )
+  console.log(
+    chalk.dim('  2. The agent runs at 9am and 5pm (or trigger manually in GitHub Actions)'),
+  )
+  console.log(chalk.dim('  3. Claude reads the task, edits the code, opens a PR'))
+  console.log(chalk.dim('  4. You get a Telegram message with the PR link'))
+  console.log(chalk.dim('  5. Review and merge — nothing touches main without you'))
+  console.log()
+  console.log(chalk.dim('  Commit the generated files and push to get started:'))
+  console.log()
+  console.log('  ' + chalk.cyan('git add .github && git commit -m "feat: add agent-ready" && git push'))
+  console.log()
+  console.log(
+    chalk.dim('  Docs: ') + chalk.cyan('https://github.com/elmir-mammadli/agent-ready'),
+  )
+  console.log()
+}

package/src/steps/scaffold.js

@@ -0,0 +1,48 @@
+import chalk from 'chalk'
+import fs from 'fs-extra'
+import path from 'path'
+import ora from 'ora'
+import { workflowTemplate } from '../templates/workflow.js'
+import { agentScriptTemplate } from '../templates/agentScript.js'
+import { doneWorkflowTemplate } from '../templates/doneWorkflow.js'
+
+export async function scaffold() {
+  const spinner = ora({ text: '  Generating workflow files...', indent: 2 }).start()
+
+  const cwd = process.cwd()
+
+  const workflowsDir = path.join(cwd, '.github', 'workflows')
+  const scriptsDir = path.join(cwd, '.github', 'scripts')
+
+  await fs.ensureDir(workflowsDir)
+  await fs.ensureDir(scriptsDir)
+
+  await fs.writeFile(
+    path.join(workflowsDir, 'agent-ready.yml'),
+    workflowTemplate(),
+  )
+
+  await fs.writeFile(
+    path.join(workflowsDir, 'agent-ready-done.yml'),
+    doneWorkflowTemplate(),
+  )
+
+  await fs.writeFile(
+    path.join(scriptsDir, 'agent-ready.mjs'),
+    agentScriptTemplate(),
+  )
+
+  spinner.succeed('  Workflow files generated.')
+  console.log()
+  console.log(
+    chalk.dim('  Created: ') + chalk.white('.github/workflows/agent-ready.yml'),
+  )
+  console.log(
+    chalk.dim('  Created: ') +
+      chalk.white('.github/workflows/agent-ready-done.yml'),
+  )
+  console.log(
+    chalk.dim('  Created: ') + chalk.white('.github/scripts/agent-ready.mjs'),
+  )
+  console.log()
+}

package/src/steps/setGithubSecrets.js

@@ -0,0 +1,60 @@
+import chalk from 'chalk'
+import { confirm } from '@inquirer/prompts'
+import { execa } from 'execa'
+import ora from 'ora'
+
+export async function setGithubSecrets(secrets) {
+  console.log(chalk.bold('  GitHub Secrets'))
+  console.log()
+
+  const useGhCli = await confirm({
+    message:
+      '  Set GitHub secrets automatically? (requires GitHub CLI — gh.io/cli)',
+    default: true,
+  })
+
+  console.log()
+
+  const SKIP_DISPLAY = new Set(['TELEGRAM_BOT_TOKEN', 'AGENT_READY_SECRET'])
+
+  if (!useGhCli) {
+    console.log(chalk.dim('  Add these secrets manually in:'))
+    console.log(
+      chalk.dim('  GitHub repo → Settings → Secrets → Actions → New secret'),
+    )
+    console.log()
+    for (const [key] of Object.entries(secrets)) {
+      if (SKIP_DISPLAY.has(key)) continue
+      console.log(`  ${chalk.yellow(key)}`)
+    }
+    console.log()
+    console.log(
+      chalk.dim('  Note: TELEGRAM_BOT_TOKEN and AGENT_READY_SECRET are managed by agent-ready.'),
+    )
+    console.log()
+    return
+  }
+
+  const spinner = ora({ text: '  Setting GitHub secrets...', indent: 2 }).start()
+
+  let failed = []
+
+  for (const [key, value] of Object.entries(secrets)) {
+    if (key === 'TELEGRAM_BOT_TOKEN') continue
+    try {
+      await execa('gh', ['secret', 'set', key, '--body', value])
+    } catch {
+      failed.push(key)
+    }
+  }
+
+  if (failed.length > 0) {
+    spinner.warn(
+      `  Some secrets failed to set: ${failed.join(', ')}\n  Set them manually in GitHub repo → Settings → Secrets → Actions`,
+    )
+  } else {
+    spinner.succeed('  All secrets set.')
+  }
+
+  console.log()
+}

package/src/steps/welcome.js

@@ -0,0 +1,22 @@
+import chalk from 'chalk'
+
+export async function welcome() {
+  console.log()
+  console.log(
+    chalk.bold('  agent-ready') + chalk.dim(' — AI coding agent for your repo'),
+  )
+  console.log()
+  console.log(
+    chalk.dim('  Tag a Trello card ') +
+      chalk.yellow('agent-ready') +
+      chalk.dim(', Claude reads the task,'),
+  )
+  console.log(
+    chalk.dim('  writes the code, opens a PR, and pings you on Telegram.'),
+  )
+  console.log()
+  console.log(chalk.dim('  This wizard sets everything up in about 5 minutes.'))
+  console.log()
+  console.log(chalk.dim('  ─────────────────────────────────────────────────'))
+  console.log()
+}

package/src/templates/agentScript.js

@@ -0,0 +1,225 @@
+export function agentScriptTemplate() {
+  return `import { execSync } from 'child_process'
+import { readFileSync, writeFileSync, mkdirSync } from 'fs'
+import { dirname } from 'path'
+import Anthropic from '@anthropic-ai/sdk'
+
+const AGENT_READY_API = 'https://telegram-bot-ruby-tau.vercel.app'
+
+const {
+  TRELLO_API_KEY,
+  TRELLO_TOKEN,
+  TRELLO_LIST_ID,
+  TRELLO_DOING_LIST_ID,
+  TRELLO_AGENT_LABEL_ID,
+  ANTHROPIC_API_KEY,
+  TELEGRAM_CHAT_ID,
+  AGENT_READY_SECRET,
+  GITHUB_TOKEN,
+  GITHUB_REPOSITORY,
+} = process.env
+
+const required = {
+  TRELLO_API_KEY, TRELLO_TOKEN, TRELLO_LIST_ID,
+  TRELLO_DOING_LIST_ID, TRELLO_AGENT_LABEL_ID,
+  ANTHROPIC_API_KEY, TELEGRAM_CHAT_ID,
+  GITHUB_TOKEN, GITHUB_REPOSITORY,
+}
+const missing = Object.entries(required).filter(([, v]) => !v).map(([k]) => k)
+if (missing.length > 0) {
+  console.error('Missing secrets: ' + missing.join(', '))
+  process.exit(1)
+}
+
+const anthropic = new Anthropic({ apiKey: ANTHROPIC_API_KEY })
+
+async function trello(path, method = 'GET', body = null) {
+  const sep = path.includes('?') ? '&' : '?'
+  const url = \`https://api.trello.com/1\${path}\${sep}key=\${TRELLO_API_KEY}&token=\${TRELLO_TOKEN}\`
+  const opts = { method, headers: { 'Content-Type': 'application/json' } }
+  if (body) opts.body = JSON.stringify(body)
+  const res = await fetch(url, opts)
+  if (!res.ok) throw new Error(\`Trello \${method} \${path}: \${res.status} \${await res.text()}\`)
+  return res.json()
+}
+
+async function sendTelegram(text) {
+  const headers = { 'Content-Type': 'application/json' }
+  if (AGENT_READY_SECRET) headers['x-internal-secret'] = AGENT_READY_SECRET
+  await fetch(\`\${AGENT_READY_API}/api/send\`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify({ chat_id: TELEGRAM_CHAT_ID, text }),
+  })
+}
+
+function parseClaudeJson(msg) {
+  if (msg.stop_reason === 'max_tokens') {
+    throw new Error('Claude response was cut off. Narrow the task scope in the card description.')
+  }
+  const raw = msg.content[0].text.trim()
+  const json = raw.replace(/^\`\`\`(?:json)?\\s*/i, '').replace(/\\s*\`\`\`$/, '')
+  return JSON.parse(json)
+}
+
+function getFileTree() {
+  return execSync(
+    'find src -type f \\\\( -name "*.tsx" -o -name "*.ts" -o -name "*.css" -o -name "*.js" \\\\) | grep -v ".next" | grep -v "node_modules" | sort',
+    { encoding: 'utf8' },
+  ).trim()
+}
+
+async function getRelevantFiles(card, fileTree) {
+  const msg = await anthropic.messages.create({
+    model: 'claude-sonnet-4-6',
+    max_tokens: 512,
+    messages: [{
+      role: 'user',
+      content: \`You are a coding agent. Given a task and file tree, identify which files to read.
+
+Task: \${card.name}
+Description: \${card.desc || 'No description.'}
+
+File tree:
+\${fileTree}
+
+Return ONLY a JSON array of file paths, max 6 files.
+Example: ["src/app/page.tsx", "src/components/Hero.tsx"]\`,
+    }],
+  })
+  return parseClaudeJson(msg)
+}
+
+async function makeChanges(card, fileContents) {
+  const filesText = Object.entries(fileContents)
+    .map(([path, content]) => \`### \${path}\\n\\\`\\\`\\\`\\n\${content}\\n\\\`\\\`\\\`\`)
+    .join('\\n\\n')
+
+  const msg = await anthropic.messages.create({
+    model: 'claude-sonnet-4-6',
+    max_tokens: 16000,
+    messages: [{
+      role: 'user',
+      content: \`You are a coding agent.
+
+Task: \${card.name}
+Description: \${card.desc || 'No description.'}
+
+File contents:
+\${filesText}
+
+Return ONLY valid JSON — no markdown, no explanation:
+{
+  "changes": [{"path": "src/...", "content": "...complete file content..."}],
+  "summary": "One sentence describing the change",
+  "branchName": "lowercase-hyphen-slug-max-40-chars"
+}
+
+Rules:
+- Only include files you actually modified
+- Return complete file content, not a diff
+- branchName: lowercase, hyphens only, max 40 chars\`,
+    }],
+  })
+  return parseClaudeJson(msg)
+}
+
+async function createPR(branch, card, summary) {
+  const [owner, repo] = GITHUB_REPOSITORY.split('/')
+  const res = await fetch(\`https://api.github.com/repos/\${owner}/\${repo}/pulls\`, {
+    method: 'POST',
+    headers: {
+      Authorization: \`Bearer \${GITHUB_TOKEN}\`,
+      'Content-Type': 'application/json',
+      'X-GitHub-Api-Version': '2022-11-28',
+    },
+    body: JSON.stringify({
+      title: \`agent: \${card.name}\`,
+      body: \`## Summary\\n\${summary}\\n\\n## Trello Card\\n\${card.shortUrl}\\n\\n<!-- trello-card-id: \${card.id} -->\`,
+      head: branch,
+      base: 'main',
+    }),
+  })
+  if (!res.ok) throw new Error(\`GitHub PR: \${res.status} \${await res.text()}\`)
+  return (await res.json()).html_url
+}
+
+async function main() {
+  console.log('Fetching Trello cards...')
+  const allCards = await trello(\`/lists/\${TRELLO_LIST_ID}/cards\`)
+  const cards = allCards.filter(c => c.idLabels.includes(TRELLO_AGENT_LABEL_ID))
+
+  console.log(\`\${allCards.length} total, \${cards.length} agent-ready.\`)
+
+  if (cards.length === 0) {
+    await sendTelegram('agent-ready: No agent-ready tasks found. All clear.')
+    return
+  }
+
+  const card = cards[0]
+  console.log(\`Processing: "\${card.name}"\`)
+
+  await trello(\`/cards/\${card.id}?idList=\${TRELLO_DOING_LIST_ID}\`, 'PUT')
+  await sendTelegram(\`agent-ready: Starting task\\n\${card.name}\\n\\nWorking on it...\`)
+
+  execSync('git config user.name "agent-ready"')
+  execSync('git config user.email "agent@agent-ready.dev"')
+  execSync(\`git remote set-url origin https://x-access-token:\${GITHUB_TOKEN}@github.com/\${GITHUB_REPOSITORY}.git\`)
+
+  const fileTree = getFileTree()
+
+  console.log('Identifying relevant files...')
+  const filePaths = await getRelevantFiles(card, fileTree)
+  console.log('Files:', filePaths)
+
+  const fileContents = {}
+  for (const filePath of filePaths) {
+    try {
+      const content = readFileSync(filePath, 'utf8')
+      const lines = content.split('\\n')
+      fileContents[filePath] = lines.length > 300
+        ? lines.slice(0, 300).join('\\n') + '\\n// ... truncated ...'
+        : content
+    } catch {
+      console.warn(\`Could not read \${filePath}\`)
+    }
+  }
+
+  console.log('Generating changes...')
+  const { changes, summary, branchName } = await makeChanges(card, fileContents)
+  console.log('Summary:', summary)
+
+  const branch = \`agent/\${card.id}_\${branchName}\`
+  execSync(\`git checkout -b \${branch}\`)
+
+  for (const { path, content } of changes) {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, content, 'utf8')
+    console.log('Written:', path)
+  }
+
+  execSync('git add -A')
+  execSync(\`git commit -m "agent: \${summary}"\`)
+  execSync(\`git push origin \${branch}\`)
+
+  const prUrl = await createPR(branch, card, summary)
+  console.log('PR:', prUrl)
+
+  await sendTelegram(
+    \`agent-ready: Task complete\\n\\n\` +
+    \`Task: \${card.name}\\n\` +
+    \`Done: \${summary}\\n\` +
+    \`PR: \${prUrl}\\n\\n\` +
+    \`Review and merge when ready.\`
+  )
+
+  console.log('Done.')
+}
+
+main().catch(async err => {
+  console.error('Fatal:', err.message)
+  await sendTelegram(\`agent-ready: Error\\n\${err.message}\`).catch(() => {})
+  process.exit(1)
+})
+`
+}

package/src/templates/doneWorkflow.js

@@ -0,0 +1,38 @@
+export function doneWorkflowTemplate() {
+  return `name: agent-ready — mark done
+
+on:
+  pull_request:
+    types: [closed]
+
+jobs:
+  mark-done:
+    if: github.event.pull_request.merged == true && startsWith(github.event.pull_request.head.ref, 'agent/')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Move Trello card to Done and notify Telegram
+        run: |
+          CARD_ID=$(echo "$PR_BODY" | grep -o 'trello-card-id: [a-f0-9]*' | awk '{print $2}')
+
+          if [ -z "$CARD_ID" ]; then
+            echo "No card ID found. Skipping."
+            exit 0
+          fi
+
+          curl -s -X PUT \\
+            "https://api.trello.com/1/cards/\${CARD_ID}?idList=\${TRELLO_DONE_LIST_ID}&key=\${TRELLO_API_KEY}&token=\${TRELLO_TOKEN}"
+
+          MESSAGE="Merged: \${PR_TITLE}%0ACard moved to Done."
+          curl -s -X POST "https://telegram-bot-ruby-tau.vercel.app/api/send" \\
+            -H "Content-Type: application/json" \\
+            -d "{\\"chat_id\\":\\"\${TELEGRAM_CHAT_ID}\\",\\"text\\":\\"\${MESSAGE}\\"}"
+        env:
+          PR_BODY: \${{ github.event.pull_request.body }}
+          PR_TITLE: \${{ github.event.pull_request.title }}
+          TRELLO_API_KEY: \${{ secrets.TRELLO_API_KEY }}
+          TRELLO_TOKEN: \${{ secrets.TRELLO_TOKEN }}
+          TRELLO_DONE_LIST_ID: \${{ secrets.TRELLO_DONE_LIST_ID }}
+          TELEGRAM_CHAT_ID: \${{ secrets.TELEGRAM_CHAT_ID }}
+`
+}

package/src/templates/workflow.js

@@ -0,0 +1,42 @@
+export function workflowTemplate() {
+  return `name: agent-ready
+
+on:
+  schedule:
+    - cron: '0 9 * * *'
+    - cron: '0 17 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  run-agent:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install agent dependencies
+        run: npm install --prefix .github/scripts @anthropic-ai/sdk
+
+      - name: Run agent
+        run: node .github/scripts/agent-ready.mjs
+        env:
+          TRELLO_API_KEY: \${{ secrets.TRELLO_API_KEY }}
+          TRELLO_TOKEN: \${{ secrets.TRELLO_TOKEN }}
+          TRELLO_LIST_ID: \${{ secrets.TRELLO_LIST_ID }}
+          TRELLO_DOING_LIST_ID: \${{ secrets.TRELLO_DOING_LIST_ID }}
+          TRELLO_AGENT_LABEL_ID: \${{ secrets.TRELLO_AGENT_LABEL_ID }}
+          ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
+          TELEGRAM_CHAT_ID: \${{ secrets.TELEGRAM_CHAT_ID }}
+          AGENT_READY_SECRET: \${{ secrets.AGENT_READY_SECRET }}
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+`
+}

package/telegram-bot/api/send.js

@@ -0,0 +1,38 @@
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN
+const INTERNAL_SECRET = process.env.INTERNAL_SECRET
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' })
+  }
+
+  const authHeader = req.headers['x-internal-secret']
+  if (INTERNAL_SECRET && authHeader !== INTERNAL_SECRET) {
+    return res.status(401).json({ error: 'Unauthorized' })
+  }
+
+  let body
+  try {
+    body = typeof req.body === 'string' ? JSON.parse(req.body) : req.body
+  } catch {
+    return res.status(400).json({ error: 'Invalid JSON' })
+  }
+
+  const { chat_id, text } = body
+  if (!chat_id || !text) {
+    return res.status(400).json({ error: 'chat_id and text required' })
+  }
+
+  const tgRes = await fetch(`https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ chat_id, text, parse_mode: 'HTML' }),
+  })
+
+  const tgData = await tgRes.json()
+  if (!tgRes.ok) {
+    return res.status(502).json({ error: 'Telegram error', detail: tgData })
+  }
+
+  return res.status(200).json({ ok: true })
+}

package/telegram-bot/api/telegram.js

@@ -0,0 +1,43 @@
+const BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN
+
+function tg(method, body) {
+  return fetch(`https://api.telegram.org/bot${BOT_TOKEN}/${method}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  })
+}
+
+export default async function handler(req, res) {
+  if (req.method !== 'POST') {
+    return res.status(405).json({ error: 'Method not allowed' })
+  }
+
+  let body
+  try {
+    body = typeof req.body === 'string' ? JSON.parse(req.body) : req.body
+  } catch {
+    return res.status(400).json({ error: 'Invalid JSON' })
+  }
+
+  const message = body?.message
+  if (!message) return res.status(200).json({ ok: true })
+
+  const chatId = message.chat.id
+  const text = message.text?.trim()
+
+  if (text === '/start') {
+    await tg('sendMessage', {
+      chat_id: chatId,
+      parse_mode: 'HTML',
+      text:
+        `👋 <b>Welcome to agent-ready!</b>\n\n` +
+        `Your Telegram Chat ID is:\n\n` +
+        `<code>${chatId}</code>\n\n` +
+        `Copy this and paste it when running <code>npx agent-ready init</code>.\n\n` +
+        `You'll receive notifications here whenever your coding agent finishes a task or opens a PR.`,
+    })
+  }
+
+  return res.status(200).json({ ok: true })
+}

package/telegram-bot/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "agent-ready-telegram-bot",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vercel dev",
+    "deploy": "vercel --prod"
+  },
+  "dependencies": {
+    "itty-router": "^5.0.18"
+  }
+}

package/telegram-bot/vercel.json

@@ -0,0 +1,15 @@
+{
+  "functions": {
+    "api/*.js": {
+      "maxDuration": 10
+    }
+  },
+  "headers": [
+    {
+      "source": "/api/(.*)",
+      "headers": [
+        { "key": "Cache-Control", "value": "no-store" }
+      ]
+    }
+  ]
+}