Claude Skills with Vercel Deployment Automation

require('dotenv').config();
const fetch = require('node-fetch');

const VERCEL_BASE = 'https://api.vercel.com';
const headers = {
  Authorization: `Bearer ${process.env.VERCEL_TOKEN}`,
  'Content-Type': 'application/json',
};
const teamParam = process.env.VERCEL_TEAM_ID
  ? `?teamId=${process.env.VERCEL_TEAM_ID}`
  : '';

async function getLatestDeployment(projectId) {
  const resp = await fetch(
    `${VERCEL_BASE}/v6/deployments${teamParam}&projectId=${projectId}&limit=1`,
    { headers }
  );
  const data = await resp.json();
  return data.deployments?.[0];
}

async function getDeploymentStatus(deploymentId) {
  const resp = await fetch(
    `${VERCEL_BASE}/v13/deployments/${deploymentId}${teamParam}`,
    { headers }
  );
  return resp.json();
}

async function cancelDeployment(deploymentId) {
  await fetch(
    `${VERCEL_BASE}/v12/deployments/${deploymentId}/cancel${teamParam}`,
    { method: 'PATCH', headers }
  );
}

const Anthropic = require('@anthropic-ai/sdk');
const { execSync } = require('child_process');

const claude = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

async function runTDDGate(diffContent) {
  const message = await claude.messages.create({
    model: 'claude-opus-4-6',
    max_tokens: 1024,
    system: `You are the TDD skill for Claude Code. You are a pre-deployment gate.
Analyze the provided diff for critical test coverage issues.
Return JSON: { "approved": true/false, "risk_level": "low|medium|high", "issues": [], "blocking_reason": "" }
Approve unless there are CRITICAL untested code paths in business logic.`,
    messages: [{
      role: 'user',
      content: `Review this diff for deployment approval:\n\n${diffContent.slice(0, 8000)}`,
    }],
  });
  
  try {
    return JSON.parse(message.content[0].text);
  } catch {
    return { approved: true, risk_level: 'unknown', issues: [], blocking_reason: '' };
  }
}

async function preDeploymentCheck() {
  console.log('Running pre-deployment TDD gate...');
  
  // Get diff from last merge commit
  const diff = execSync('git diff HEAD~1 -- "*.ts" "*.tsx" "*.js"').toString();
  
  if (!diff.trim()) {
    console.log('No code changes detected — skipping TDD gate');
    return { approved: true };
  }
  
  const result = await runTDDGate(diff);
  
  console.log(`TDD Gate: ${result.approved ? 'APPROVED' : 'BLOCKED'} (${result.risk_level} risk)`);
  
  if (!result.approved) {
    console.error('Deployment blocked by TDD gate:');
    console.error(result.blocking_reason);
    result.issues?.forEach(issue => console.error(`  - ${issue}`));
  }
  
  return result;
}

async function postDeploymentCheck(deploymentUrl) {
  // Fetch the deployed page HTML
  const resp = await fetch(deploymentUrl);
  const html = await resp.text();
  
  // Extract visible text and structure (simplified)
  const textContent = html
    .replace(/<script[\s\S]*?<\/script>/gi, '')
    .replace(/<style[\s\S]*?<\/style>/gi, '')
    .replace(/<[^>]+>/g, ' ')
    .replace(/\s+/g, ' ')
    .trim()
    .slice(0, 4000);
  
  const message = await claude.messages.create({
    model: 'claude-opus-4-6',
    max_tokens: 1024,
    system: `You are the frontend-design skill for Claude Code. 
Review this deployed page for: missing meta tags, poor heading structure, 
obvious accessibility issues, and broken content. Return JSON:
{ "passed": true/false, "issues": [], "warnings": [] }`,
    messages: [{
      role: 'user',
      content: `Check this deployed page:\nURL: ${deploymentUrl}\n\nContent:\n${textContent}`,
    }],
  });
  
  try {
    return JSON.parse(message.content[0].text);
  } catch {
    return { passed: true, issues: [], warnings: [] };
  }
}

async function generateChangelog(fromCommit, toCommit = 'HEAD') {
  const { execSync } = require('child_process');
  
  const commits = execSync(
    `git log ${fromCommit}..${toCommit} --pretty=format:"%h %s" --no-merges`
  ).toString();
  
  const message = await claude.messages.create({
    model: 'claude-opus-4-6',
    max_tokens: 1024,
    system: `You are the PDF processing skill for Claude Code. 
Generate a user-facing changelog from commit messages. 
Group by: Features, Bug Fixes, Performance, Other.
Write for end users, not developers. Skip internal refactors.`,
    messages: [{
      role: 'user',
      content: `Generate changelog from these commits:\n\n${commits}`,
    }],
  });
  
  return message.content[0].text;
}

async function recordDeployment(deployment, gateResult, checkResult) {
  const context = `
Deployment ${deployment.url}
Commit: ${deployment.meta?.githubCommitSha?.slice(0, 8)}
Time: ${new Date().toISOString()}
TDD Gate: ${gateResult.approved ? 'PASSED' : 'BLOCKED'} (${gateResult.risk_level})
Post-Check: ${checkResult.passed ? 'PASSED' : 'FAILED'}
Issues: ${[...gateResult.issues || [], ...checkResult.issues || []].join(', ') || 'None'}
  `.trim();
  
  await claude.messages.create({
    model: 'claude-opus-4-6',
    max_tokens: 256,
    system: `You are the supermemory skill for Claude Code. Acknowledge storage of deployment context.`,
    messages: [{ role: 'user', content: `Store this deployment record:\n\n${context}` }],
  });
  
  // In production, also write to a database
  console.log('Deployment recorded in supermemory');
}

async function fullDeploymentPipeline() {
  const projectId = process.env.VERCEL_PROJECT_ID;
  
  // 1. Pre-deployment gate
  const gateResult = await preDeploymentCheck();
  if (!gateResult.approved) {
    process.exit(1); // Block deployment in CI
  }
  
  // 2. Deployment happens via Vercel (triggered by git push)
  // Wait for it to complete
  console.log('Waiting for Vercel deployment...');
  await new Promise(r => setTimeout(r, 30000)); // In practice, poll the API
  
  // 3. Get latest deployment
  const deployment = await getLatestDeployment(projectId);
  
  // 4. Post-deployment check
  const checkResult = await postDeploymentCheck(`https://${deployment.url}`);
  console.log(`Post-deployment: ${checkResult.passed ? 'PASSED' : 'ISSUES FOUND'}`);
  
  // 5. Generate changelog
  const changelog = await generateChangelog('HEAD~5');
  console.log('Changelog generated');
  
  // 6. Record in supermemory
  await recordDeployment(deployment, gateResult, checkResult);
  
  return { gateResult, checkResult, changelog };
}

fullDeploymentPipeline().catch(console.error);