chorus-cli 0.4.0

package/index.js

@@ -0,0 +1,1184 @@
+#!/usr/bin/env node
+const _path = require('path');
+const _os = require('os');
+const _configDir = _path.join(_os.homedir(), '.config', 'chorus');
+const _configEnv = _path.join(_configDir, '.env');
+const _localEnv = _path.join(__dirname, '.env');
+// Prefer user config dir (works when installed globally), fall back to local .env for dev
+require('dotenv').config({ path: require('fs').existsSync(_configEnv) ? _configEnv : _localEnv });
+const { Octokit } = require('@octokit/rest');
+const Anthropic = require('@anthropic-ai/sdk');
+const { createProvider } = require('./providers');
+const { exec, execFile, spawn } = require('child_process');
+const util = require('util');
+const path = require('path');
+const os = require('os');
+const execPromise = util.promisify(exec);
+const execFilePromise = util.promisify(execFile);
+const fs = require('fs').promises;
+
+// Run coder.py with real-time stderr streaming so progress is visible
+function runCoder(prompt) {
+  return new Promise((resolve, reject) => {
+    const env = { ...process.env };
+    if (CONFIG.ai.proxyUrl) {
+      env.CODER_PROXY_URL = CONFIG.ai.proxyUrl;
+      env.ANTHROPIC_API_KEY = CONFIG.ai.anthropicApiKey;
+    }
+    const proc = spawn(CONFIG.ai.venvPython, [CONFIG.ai.coderPath, '--prompt', prompt], {
+      cwd: process.cwd(),
+      env,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 600000,
+    });
+
+    let stdout = '';
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    // Stream stderr to terminal in real-time
+    proc.stderr.on('data', (data) => {
+      process.stderr.write(data);
+    });
+
+    proc.on('close', (code) => {
+      try {
+        resolve(JSON.parse(stdout));
+      } catch (e) {
+        reject(new Error(`Failed to parse coder output (exit ${code}): ${stdout.slice(0, 500)}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+// Run qa.py with issue context on stdin, capture JSON from stdout
+function runQAChat(issue, enrichedDetails, qaName, useSuper = false) {
+  return new Promise((resolve, reject) => {
+    const input = JSON.stringify({
+      issue_number: issue.number,
+      issue_title: issue.title,
+      issue_body: issue.body || '',
+      enriched_questions: enrichedDetails,
+    });
+
+    const args = ['--messenger', CONFIG.messenger, '--qa', qaName];
+    if (CONFIG.messenger === 'teams') {
+      args.push('--auth', CONFIG.teams.authPath);
+    }
+    if (useSuper) args.push('--super');
+
+    const env = { ...process.env };
+    if (CONFIG.ai.proxyUrl) {
+      env.CODER_PROXY_URL = CONFIG.ai.proxyUrl;
+      env.ANTHROPIC_API_KEY = CONFIG.ai.anthropicApiKey;
+    }
+    if (CONFIG.messenger === 'slack' && CONFIG.slack.botToken) {
+      env.SLACK_BOT_TOKEN = CONFIG.slack.botToken;
+    }
+    const proc = spawn(CONFIG.ai.venvPython, [CONFIG.ai.qaPath, ...args], {
+      cwd: process.cwd(),
+      env,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 1800000, // 30 min
+    });
+
+    let stdout = '';
+
+    proc.stdin.write(input);
+    proc.stdin.end();
+
+    proc.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    // Stream stderr to terminal in real-time
+    proc.stderr.on('data', (data) => {
+      process.stderr.write(data);
+    });
+
+    proc.on('close', (code) => {
+      try {
+        resolve(JSON.parse(stdout));
+      } catch (e) {
+        reject(new Error(`Failed to parse qa.py output (exit ${code}): ${stdout.slice(0, 500)}`));
+      }
+    });
+
+    proc.on('error', reject);
+  });
+}
+
+// ===== CONFIGURATION =====
+const CONFIG = {
+  github: {
+    owner: process.env.GITHUB_OWNER,
+    repo: process.env.GITHUB_REPO,
+    token: process.env.GITHUB_TOKEN,
+  },
+  azuredevops: {
+    org: process.env.AZDO_ORG,
+    project: process.env.AZDO_PROJECT,
+    repo: process.env.AZDO_REPO,
+    pat: process.env.AZDO_PAT,
+  },
+  messenger: process.env.MESSENGER || 'teams',
+  teams: {
+    authPath: path.join(os.homedir(), '.config', 'chorus', 'teams-auth.json'),
+    pollInterval: 60000 // Check for response every 60 seconds
+  },
+  slack: {
+    botToken: process.env.SLACK_BOT_TOKEN || '',
+  },
+  ai: {
+    enrichmentTool: 'claude',  // 'claude' or 'kimi'
+    codingTool: 'coder',       // 'coder', 'claude', or 'kimi'
+    coderPath: path.join(__dirname, 'tools', 'coder.py'),
+    qaPath: path.join(__dirname, 'tools', 'qa.py'),
+    mapperPath: path.join(__dirname, 'tools', 'mapper.py'),
+    venvPython: process.platform === 'win32'
+      ? path.join(os.homedir(), '.config', 'chorus', '.venv', 'Scripts', 'python.exe')
+      : path.join(os.homedir(), '.config', 'chorus', '.venv', 'bin', 'python'),
+    anthropicApiKey: process.env.PROXY_API_KEY || process.env.ANTHROPIC_API_KEY,
+    proxyUrl: process.env.PROXY_URL,
+  }
+};
+
+// ===== GITHUB / AZURE DEVOPS =====
+// Provider-specific logic lives in ./providers/
+// Use createProvider(CONFIG, issueArg) to get the right provider.
+
+// ===== AI ENRICHMENT =====
+async function enrichWithAI(issue) {
+  const prompt = `Analyze this GitHub issue and write questions for QA clarification.
+
+ISSUE DETAILS:
+Title: ${issue.title}
+Body: ${issue.body || 'No description provided'}
+Labels: ${issue.labels.map(l => l.name).join(', ') || 'None'}
+
+INSTRUCTIONS:
+- Write clear, specific questions that will help a developer fix this issue
+- Use simple language that a QA analyst can easily understand
+- Format for a Teams message (clean, readable, no code blocks or technical formatting)
+- Focus on missing details, edge cases, and expected vs actual behavior
+- Ask questions that avoid back-and-forth (get all needed info upfront)
+- Use pure text formatting, so it's not a big unstructured paragraph, like how this text is structured with newlines and spaces
+- Maximum 3 questions
+OUTPUT FORMAT:
+Hi! I need clarification on issue #${issue.number}:
+
+${issue.title}
+
+To fix this properly, I need to know:
+
+1. [First question]
+2. [Second question]
+3. [Third question]
+...
+
+Thanks!
+
+IMPORTANT: Output ONLY the message above. Do not include any preamble, thinking process, or explanations. Start directly with "Hi! I need clarification..."`;
+
+  console.log('🤖 Enriching issue with AI...');
+  
+  const tool = CONFIG.ai.enrichmentTool;
+  
+  if (tool === 'claude') {
+    // Use Anthropic API
+    if (!CONFIG.ai.anthropicApiKey) {
+      throw new Error('PROXY_API_KEY or ANTHROPIC_API_KEY environment variable is required');
+    }
+    const clientOpts = { apiKey: CONFIG.ai.anthropicApiKey };
+    if (CONFIG.ai.proxyUrl) {
+      clientOpts.baseURL = CONFIG.ai.proxyUrl.replace(/\/+$/, '');
+    }
+    const anthropic = new Anthropic(clientOpts);
+    
+    const message = await anthropic.messages.create({
+
+      //when --super flag is added use claude-opus-4-6, else default to claude-sonnet-4-20250514
+      model: 'claude-opus-4-6',
+      max_tokens: 2000,
+      messages: [
+        {
+          role: 'user',
+          content: prompt
+        }
+      ]
+    });
+
+    if (message.usage) {
+      console.log(`   Enrichment tokens: ${message.usage.input_tokens} in / ${message.usage.output_tokens} out`);
+    }
+
+    return message.content[0].text.trim();
+  } else {
+    // Use Kimi CLI
+    const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
+    const { stdout } = await execPromise(`kimi --prompt "${escapedPrompt}"`);
+    return stdout.trim();
+  }
+}
+
+// ===== CODE GENERATION =====
+async function generateCode(issue, enrichedDetails, qaResponse) {
+  const tool = CONFIG.ai.codingTool;
+
+  if (tool === 'coder') {
+    const prompt = `Implement a solution for this GitHub issue in the current repository:
+
+**Issue #${issue.number}: ${issue.title}**
+
+Original Description:
+${issue.body || 'No description provided'}
+
+Technical Analysis:
+${enrichedDetails}
+
+QA Clarification:
+${qaResponse}
+
+Instructions:
+1. Explore the codebase to understand the structure and relevant files
+2. Implement all necessary code changes by writing to the actual files
+3. Do not write unit tests unless the project already has substantive test coverage
+4. Do not attempt to build or compile the project`;
+
+    console.log('🔨 Generating code with Coder agent...');
+
+    return await runCoder(prompt);
+  }
+
+  // Fallback: kimi
+  const prompt = `Generate a solution for this GitHub issue:
+
+**Issue #${issue.number}: ${issue.title}**
+
+Original Description:
+${issue.body || 'No description provided'}
+
+Technical Analysis:
+${enrichedDetails}
+
+QA Clarification:
+${qaResponse}
+
+Please implement a complete solution with:
+1. All necessary code changes
+2. Tests if applicable
+3. Documentation updates
+
+Output the code with file paths clearly marked using code blocks like:
+\`\`\`path/to/file.js
+code here
+\`\`\``;
+
+  console.log('🔨 Generating code with Kimi...');
+  const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
+  const { stdout } = await execPromise(`kimi --prompt "${escapedPrompt}"`);
+  return { _raw: stdout, completed: true, summary: stdout.trim(), files_modified: [], files_created: [] };
+}
+
+// ===== CODE REVIEW =====
+
+async function getCodeRabbitReview(solution, issue, provider) {
+  console.log('🐰 Preparing code for CodeRabbit review...');
+
+  const isCoder = CONFIG.ai.codingTool === 'coder';
+  let filesWritten;
+
+  if (isCoder) {
+    const coderFiles = provider.getSolutionFiles(solution).length;
+    filesWritten = coderFiles;
+    console.log(`  Coder wrote ${coderFiles} file(s) directly`);
+  } else {
+    filesWritten = 0; // Legacy path — files already written by provider
+  }
+
+  if (filesWritten === 0) {
+    console.log('Skipping CodeRabbit review (no files to review)');
+    return { needsChanges: false, feedback: 'No files to review' };
+  }
+
+  // 2. Create a temporary branch for review
+  const branchName = `review/issue-${issue.number}`;
+
+  try {
+    // Clean up stale review branch from previous runs
+    await execPromise(`git branch -D ${branchName}`).catch(() => {});
+
+    await execPromise(`git checkout -b ${branchName}`);
+    await provider.gitAddSolutionFiles(solution);
+
+    // Verify there are staged changes before committing
+    const { stdout: diffStat } = await execPromise(`git diff --cached --stat`);
+    if (!diffStat.trim()) {
+      console.warn('⚠️  No staged changes to commit — skipping CodeRabbit review');
+      await execPromise(`git checkout main`);
+      await execPromise(`git branch -D ${branchName}`).catch(() => {});
+      return { needsChanges: false, feedback: 'No file changes to review' };
+    }
+
+    await execPromise(`git commit -m "Draft: ${issue.title}"`);
+
+    // 3. Run CodeRabbit CLI (plain text output, compare against main)
+    console.log('🐰 Running CodeRabbit review...');
+    const { stdout, stderr } = await execPromise(`coderabbit review --plain --base main`);
+    const reviewOutput = (stdout + '\n' + stderr).trim();
+
+    console.log('CodeRabbit output:', reviewOutput || '(empty)');
+
+    // 4. Parse CodeRabbit output to determine if changes needed
+    const needsChanges = reviewOutput.length > 0 && (
+      reviewOutput.toLowerCase().includes('issue') ||
+      reviewOutput.toLowerCase().includes('refactor') ||
+      reviewOutput.toLowerCase().includes('warning') ||
+      reviewOutput.toLowerCase().includes('suggestion') ||
+      reviewOutput.toLowerCase().includes('improve') ||
+      reviewOutput.toLowerCase().includes('consider')
+    );
+
+    // 5. Clean up — undo the commit so changes stay in working tree, then go back to main
+    await execPromise(`git reset --mixed HEAD~1`);  // undo commit, keep changes in working tree
+    await execPromise(`git stash`);                  // stash working tree changes
+    await execPromise(`git checkout main`);
+    await execPromise(`git stash pop`);              // restore coder's changes on main
+    await execPromise(`git branch -D ${branchName}`).catch(() => {});
+
+    return {
+      needsChanges,
+      feedback: reviewOutput
+    };
+  } catch (error) {
+    console.error('Error running CodeRabbit:', error.message);
+    // Clean up on error — try to preserve working tree changes
+    await execPromise(`git reset --mixed HEAD~1`).catch(() => {});
+    await execPromise(`git stash`).catch(() => {});
+    await execPromise(`git checkout main`).catch(() => {});
+    await execPromise(`git stash pop`).catch(() => {});
+    await execPromise(`git branch -D ${branchName}`).catch(() => {});
+
+    return {
+      needsChanges: false,
+      feedback: `CodeRabbit error: ${error.message}`
+    };
+  }
+}
+
+async function refineCode(solution, review) {
+  const tool = CONFIG.ai.codingTool;
+
+  if (tool === 'coder') {
+    const filesContext = [
+      ...(solution.files_modified || []),
+      ...(solution.files_created || [])
+    ].join(', ');
+
+    const prompt = `Refine the code based on this code review feedback.
+
+Files that were changed: ${filesContext}
+
+Review Feedback:
+${review.feedback}
+
+Instructions:
+1. Read the files listed above
+2. Address every concern raised in the review
+3. Edit the files to fix the issues
+4. Do not write unit tests unless the project already has substantive test coverage
+5. Do not attempt to build or compile the project`;
+
+    console.log('🔄 Refining code with Coder agent...');
+
+    return await runCoder(prompt);
+  }
+
+  // Fallback: kimi
+  const prompt = `Please refine this code based on the review feedback:
+
+Current Solution:
+${solution._raw || solution}
+
+Review Feedback:
+${review.feedback}
+
+Please update the code to address all concerns. Output with the same file format:
+\`\`\`path/to/file.js
+updated code
+\`\`\``;
+
+  console.log('🔄 Refining code with Kimi...');
+  const escapedPrompt = prompt.replace(/"/g, '\\"').replace(/\$/g, '\\$');
+  const { stdout } = await execPromise(`kimi --prompt "${escapedPrompt}"`);
+  return { _raw: stdout, completed: true, summary: stdout.trim(), files_modified: [], files_created: [] };
+}
+
+// PR creation is handled by the provider (see ./providers/)
+
+// ===== LINT =====
+async function lintAndFix(solution, provider) {
+  const files = provider.getSolutionFiles(solution).filter(f => /\.(js|jsx|ts|tsx)$/.test(f));
+  if (files.length === 0) {
+    console.log('🔍 No JS/TS files to lint\n');
+    return;
+  }
+
+  console.log(`🔍 Linting ${files.length} file(s)...`);
+
+  // First pass: auto-fix what ESLint can
+  const quoted = files.map(f => `"${f}"`).join(' ');
+  try {
+    await execPromise(`npx eslint --fix --quiet ${quoted}`, { cwd: process.cwd() });
+    console.log('   Auto-fix applied');
+  } catch (e) {
+    // eslint exits non-zero when there are unfixable errors — that's expected
+    if (e.stdout) console.log(e.stdout);
+  }
+
+  // Second pass: check for remaining errors
+  try {
+    const { stdout } = await execPromise(`npx eslint --quiet ${quoted}`, { cwd: process.cwd() });
+    if (stdout.trim()) {
+      console.log('   Remaining lint issues:\n', stdout);
+    } else {
+      console.log('   All lint issues resolved ✓\n');
+      return;
+    }
+  } catch (e) {
+    const lintOutput = (e.stdout || '') + (e.stderr || '');
+    if (!lintOutput.trim()) {
+      console.log('   All lint issues resolved ✓\n');
+      return;
+    }
+
+    // Unfixable errors remain — send back to coder
+    console.log('🔄 Lint errors remain, sending to Coder for manual fix...');
+    const prompt = `Fix these ESLint errors. Do NOT disable rules or add eslint-disable comments — fix the actual code.
+
+Files: ${files.join(', ')}
+
+ESLint output:
+${lintOutput.slice(0, 5000)}`;
+
+    const fixResult = await runCoder(prompt);
+
+    if (fixResult.completed === false) {
+      console.warn('⚠️  Coder lint fix had errors:', fixResult.errors);
+    }
+
+    // Update solution with any new files coder touched
+    for (const f of (fixResult.files_modified || [])) {
+      if (!solution.files_modified.includes(f)) solution.files_modified.push(f);
+    }
+
+    console.log('   Lint fix pass complete\n');
+  }
+}
+
+// ===== TOKEN LIMIT =====
+
+function isTokenLimitError(err) {
+  const msg = typeof err === 'string' ? err : (err?.message || err?.error || '');
+  return msg.includes('token limit exceeded') || msg.includes('rate_limit_error');
+}
+
+async function fetchAccountEmail() {
+  if (!CONFIG.ai.proxyUrl || !CONFIG.ai.anthropicApiKey) return null;
+  try {
+    const res = await fetch(`${CONFIG.ai.proxyUrl.replace(/\/+$/, '')}/auth/me`, {
+      headers: { 'Authorization': `Bearer ${CONFIG.ai.anthropicApiKey}` },
+    });
+    if (res.ok) {
+      const data = await res.json();
+      return data.email || null;
+    }
+  } catch {}
+  return null;
+}
+
+async function printTokenLimitMessage() {
+  const email = await fetchAccountEmail();
+  const base = 'https://getchorusai.com/pricing';
+  const url = email ? `${base}?email=${encodeURIComponent(email)}` : base;
+
+  console.error('\n⚠️  You\'ve run out of Chorus tokens for this month.\n');
+  console.error('   To keep going, purchase more tokens at:');
+  console.error(`   ${url}\n`);
+  console.error('   Or wait for your monthly allowance to reset.\n');
+}
+
+// ===== MAIN WORKFLOW =====
+async function processTicket(issueArg, { useSuper = false, skipQA = false, qaName: qaNameOverride } = {}) {
+  try {
+    console.log('🚀 Starting ticket processing...\n');
+
+    // 0. Ensure Python venv exists and has required dependencies
+    const reqFile = path.join(__dirname, 'tools', 'requirements.txt');
+    const { execFileSync: efs } = require('child_process');
+    const venvDir = path.join(os.homedir(), '.config', 'chorus', '.venv');
+
+    if (!require('fs').existsSync(CONFIG.ai.venvPython)) {
+      console.log('🐍 Creating Python virtual environment...');
+      efs('python3', ['-m', 'venv', venvDir], { stdio: 'inherit' });
+    }
+
+    try {
+      efs(CONFIG.ai.venvPython, ['-c', 'import anthropic'], { stdio: 'ignore' });
+    } catch {
+      console.log('📦 Installing Python dependencies (first run)...');
+      efs(CONFIG.ai.venvPython, ['-m', 'pip', 'install', '-r', reqFile], { stdio: 'inherit' });
+    }
+
+    // 0a. Verify no modified tracked files (untracked files like .coder/ are fine)
+    const { stdout: gitStatus } = await execPromise('git status --porcelain --untracked-files=no');
+    if (gitStatus.trim()) {
+      console.error('⚠️ Working directory has uncommitted changes. Commit or stash first:');
+      console.error(gitStatus);
+      //throw new Error('Dirty working directory');
+    }
+    const { stdout: currentBranch } = await execPromise('git rev-parse --abbrev-ref HEAD');
+    if (currentBranch.trim() !== 'main') {
+      console.warn(`⚠️ Not on main branch (currently on ${currentBranch.trim()}). Switch to main first.`);
+      //throw new Error('Not on main branch');
+    }
+
+    // 0b. Map the codebase so coder starts with full context
+    if (CONFIG.ai.codingTool === 'coder') {
+      console.log('🗺️  Mapping codebase...');
+      try {
+        await execFilePromise(CONFIG.ai.venvPython, [CONFIG.ai.mapperPath, process.cwd()]);
+        console.log('   Map generated\n');
+      } catch (e) {
+        console.warn('   Mapper failed, coder will explore manually:', e.message);
+      }
+    }
+
+    // 1. Fetch issue via provider
+    const provider = createProvider(CONFIG, issueArg);
+    console.log(`   Provider: ${provider.name}`);
+
+    const parsed = provider.parseIssueArg(issueArg);
+    let issue;
+    if (parsed) {
+      console.log(`📥 Fetching issue #${parsed.number}...`);
+      issue = await provider.fetchIssueByNumber(parsed.number, parsed.owner, parsed.repo);
+    } else {
+      console.log('📥 Fetching latest assigned issue...');
+      issue = await provider.fetchLatestIssue();
+    }
+    console.log(`Found issue #${issue.number}: ${issue.title}\n`);
+
+    // 2. Enrich with AI
+    const enrichedDetails = await enrichWithAI(issue);
+    console.log('Enrichment complete\n', enrichedDetails);
+
+    // 3. Multi-turn QA conversation via qa.py
+    let qaResponse = '';
+    if (skipQA) {
+      console.log('⏭️  Skipping QA conversation (--skip-qa)\n');
+    } else {
+      const qaName = qaNameOverride || await provider.getUserDisplayName(issue.user.login);
+      console.log(`💬 Starting QA conversation with ${qaName?.login}...`);
+      const qaResult = await runQAChat(issue, enrichedDetails, qaName, useSuper);
+      qaResponse = qaResult.requirements;
+
+      if (!qaResult.completed) {
+        if (isTokenLimitError(qaResult.error)) {
+          await printTokenLimitMessage();
+          process.exit(1);
+        }
+        console.warn('⚠️  QA chat did not complete successfully:', qaResult.error || 'unknown');
+      }
+      console.log(`QA complete (${qaResult.conversation_rounds} rounds)\n`);
+    }
+    
+    // 4. Generate code (with retry if coder doesn't actually write files)
+    const maxCodeAttempts = 3;
+    let solution;
+
+    for (let attempt = 1; attempt <= maxCodeAttempts; attempt++) {
+      if (attempt === 1) {
+        solution = await generateCode(issue, enrichedDetails, qaResponse);
+      } else {
+        // Reprompt with explicit instruction that files must be written
+        const retryPrompt = `You previously attempted to implement this issue but DID NOT write any files. Your task is NOT complete until you have actually created or modified files using write_file or edit_file.
+
+Implement a solution for this GitHub issue in the current repository:
+
+Issue #${issue.number}: ${issue.title}
+
+Original Description:
+${issue.body || 'No description provided'}
+
+Technical Analysis:
+${enrichedDetails}
+
+QA Clarification:
+${qaResponse}
+
+CRITICAL: You MUST write code to actual files. Do not just describe changes — use write_file or edit_file to make them. If you are unsure where to make changes, explore the codebase first, then write the code.`;
+
+        console.log(`🔁 Reprompting coder (attempt ${attempt}/${maxCodeAttempts})...`);
+        solution = await runCoder(retryPrompt);
+      }
+
+      if (solution.completed === false) {
+        const errs = solution.errors || [solution.summary || ''];
+        if (errs.some(e => isTokenLimitError(e))) {
+          printTokenLimitMessage();
+          process.exit(1);
+        }
+        console.error('❌ Code generation failed:', errs);
+        throw new Error('Code generation failed');
+      }
+
+      const filesChanged = (solution.files_modified || []).length + (solution.files_created || []).length;
+
+      if (filesChanged > 0) {
+        break; // Success — coder actually wrote files
+      }
+
+      if (attempt < maxCodeAttempts) {
+        console.warn(`⚠️  Coder reported success but wrote 0 files (attempt ${attempt}/${maxCodeAttempts})`);
+      } else {
+        console.error('❌ Coder failed to write any files after', maxCodeAttempts, 'attempts');
+        throw new Error('Code generation produced no file changes');
+      }
+    }
+
+    console.log('Code generation complete\n');
+    if (solution.summary) console.log(`Summary: ${solution.summary}\n`);
+
+    // 5. Lint files the coder touched
+    await lintAndFix(solution, provider);
+
+    // 6. CodeRabbit review
+    let review = await getCodeRabbitReview(solution, issue, provider);
+
+    // 7. Iterate if needed
+    let iterations = 0;
+    const maxIterations = 3;
+
+    if (review.needsChanges) {
+      console.log('🔄 CodeRabbit found issues, refining...\n');
+
+      while (review.needsChanges && iterations < maxIterations) {
+        console.log(`Iteration ${iterations + 1}/${maxIterations}...`);
+
+        const refined = await refineCode(solution, review);
+
+        if (refined.completed === false) {
+          console.warn('⚠️  Refinement had errors:', refined.errors);
+        }
+
+        const refinedFiles = (refined.files_modified || []).length + (refined.files_created || []).length;
+        if (refinedFiles > 0) {
+          solution = refined; // Update solution only if refinement actually touched files
+        } else {
+          console.warn('⚠️  Refinement produced no file changes, keeping previous solution');
+        }
+
+        const newReview = await getCodeRabbitReview(solution, issue, provider);
+
+        if (!newReview.needsChanges) {
+          review = newReview;
+          break;
+        }
+
+        review = newReview;
+        iterations++;
+      }
+
+      if (iterations >= maxIterations && review.needsChanges) {
+        console.warn('⚠️  Max iterations reached. Creating PR with current state.');
+      }
+    }
+
+    // 8. User review loop — confirm before creating PR
+    const readline = require('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const maxUserIterations = 5;
+    let userIteration = 0;
+
+    while (userIteration < maxUserIterations) {
+      const allFiles = [...new Set([
+        ...(solution.files_modified || []),
+        ...(solution.files_created || []),
+      ])];
+      console.log('FILES CHANGED:');
+      allFiles.forEach(f => console.log(`  ${f}`));
+      if (solution.summary) console.log(`\nSUMMARY: ${solution.summary}`);
+      console.log();
+
+      const answer = await prompt(rl, '✅ Happy with the changes? (y/n): ');
+      if (answer.trim().toLowerCase() === 'y' || answer.trim().toLowerCase() === 'yes') {
+        break;
+      }
+
+      const feedback = await prompt(rl, '📝 What needs to change? ');
+      if (!feedback.trim()) {
+        console.log('No feedback provided, continuing to PR.\n');
+        break;
+      }
+
+      userIteration++;
+      console.log(`\n🔁 Revising (attempt ${userIteration}/${maxUserIterations})...\n`);
+
+      const filesContext = allFiles.join(', ');
+      const revisionPrompt = `Revise the code based on user feedback.
+
+Files that were changed: ${filesContext}
+
+User feedback:
+${feedback.trim()}
+
+Instructions:
+1. Read the files listed above
+2. Address the user's feedback
+3. Edit the files to make the requested changes
+4. Do not write unit tests unless the project already has substantive test coverage
+5. Do not attempt to build or compile the project`;
+
+      const revised = await runCoder(revisionPrompt);
+
+      if (revised.completed === false) {
+        const errs = revised.errors || [revised.summary || ''];
+        if (errs.some(e => isTokenLimitError(e))) {
+          printTokenLimitMessage();
+          rl.close();
+          process.exit(1);
+        }
+        console.warn('⚠️  Revision had errors:', errs);
+      }
+
+      const revisedFiles = (revised.files_modified || []).length + (revised.files_created || []).length;
+      if (revisedFiles > 0) {
+        solution = revised;
+      } else {
+        console.warn('⚠️  Revision produced no file changes, keeping previous solution');
+      }
+
+      await lintAndFix(solution, provider);
+      console.log();
+    }
+
+    if (userIteration >= maxUserIterations) {
+      console.warn('⚠️  Max revision rounds reached. Creating PR with current state.');
+    }
+
+    rl.close();
+
+    // 9. Create PR
+    await provider.createPR(issue, solution);
+
+    console.log('\n✨ Ticket processing complete!');
+
+  } catch (error) {
+    if (isTokenLimitError(error)) {
+      await printTokenLimitMessage();
+      process.exit(1);
+    }
+    console.error('❌ Error processing ticket:', error);
+    throw error;
+  }
+}
+
+// ===== SETUP =====
+
+function prompt(rl, question, hidden = false) {
+  return new Promise((resolve) => {
+    if (hidden) {
+      process.stdout.write(question);
+      const stdin = process.stdin;
+      const wasRaw = stdin.isRaw;
+      stdin.setRawMode(true);
+      stdin.resume();
+      stdin.setEncoding('utf8');
+      let input = '';
+      const onData = (ch) => {
+        if (ch === '\n' || ch === '\r') {
+          stdin.setRawMode(wasRaw);
+          stdin.removeListener('data', onData);
+          stdin.pause();
+          process.stdout.write('\n');
+          resolve(input);
+        } else if (ch === '\u0003') {
+          process.exit();
+        } else if (ch === '\u007F' || ch === '\b') {
+          if (input.length > 0) input = input.slice(0, -1);
+        } else {
+          input += ch;
+        }
+      };
+      stdin.on('data', onData);
+    } else {
+      rl.question(question, resolve);
+    }
+  });
+}
+
+async function setupGitHub() {
+  console.log('Setting up GitHub configuration...\n');
+
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const owner = await prompt(rl, `GitHub owner/org: `) || CONFIG.github.owner;
+  const repo = await prompt(rl, `GitHub repo: `) || CONFIG.github.repo;
+  const token = await prompt(rl, 'GitHub token (optional, for private repos): ', true);
+  rl.close();
+
+  const configDir = path.join(os.homedir(), '.config', 'chorus');
+  await fs.mkdir(configDir, { recursive: true });
+  const envPath = path.join(configDir, '.env');
+  let envContent = '';
+  try {
+    envContent = await fs.readFile(envPath, 'utf8');
+  } catch { /* no .env yet */ }
+
+  const updates = { GITHUB_OWNER: owner, GITHUB_REPO: repo };
+  if (token) updates.GITHUB_TOKEN = token;
+
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    if (regex.test(envContent)) {
+      envContent = envContent.replace(regex, `${key}=${value}`);
+    } else {
+      envContent = envContent.trimEnd() + `\n${key}=${value}`;
+    }
+  }
+
+  await fs.writeFile(envPath, envContent.trimEnd() + '\n');
+
+  // Update in-memory config
+  CONFIG.github.owner = owner;
+  CONFIG.github.repo = repo;
+  if (token) CONFIG.github.token = token;
+
+  console.log(`\n✅ GitHub config saved to ${envPath} (${owner}/${repo})\n`);
+}
+
+async function setupProxyAuth() {
+  const DEFAULT_PROXY_URL = 'https://chorus-bad0f.web.app';
+
+  if (!CONFIG.ai.proxyUrl) {
+    CONFIG.ai.proxyUrl = DEFAULT_PROXY_URL;
+
+    // Persist PROXY_URL to .env
+    const configDir = path.join(os.homedir(), '.config', 'chorus');
+    await fs.mkdir(configDir, { recursive: true });
+    const envPath = path.join(configDir, '.env');
+    let envContent = '';
+    try { envContent = await fs.readFile(envPath, 'utf8'); } catch { /* no .env yet */ }
+    if (envContent.includes('PROXY_URL=')) {
+      envContent = envContent.replace(/PROXY_URL=.*/, `PROXY_URL=${CONFIG.ai.proxyUrl}`);
+    } else {
+      envContent = envContent.trimEnd() + `\nPROXY_URL=${CONFIG.ai.proxyUrl}`;
+    }
+    await fs.writeFile(envPath, envContent.trimEnd() + '\n');
+    process.env.PROXY_URL = CONFIG.ai.proxyUrl;
+  }
+
+  console.log('Setting up Chorus authentication...\n');
+
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const email = await prompt(rl, 'Email: ');
+  const password = await prompt(rl, 'Password: ', true);
+  rl.close();
+
+  // Try register first, fall back to login
+  let apiKey;
+  for (const endpoint of ['/auth/register', '/auth/login']) {
+    const res = await fetch(`${CONFIG.ai.proxyUrl}${endpoint}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, password }),
+    });
+
+    const data = await res.json();
+
+    if (res.ok && data.apiKey) {
+      apiKey = data.apiKey;
+      console.log(`\n✅ ${endpoint === '/auth/register' ? 'Registered' : 'Logged in'} successfully`);
+      break;
+    }
+
+    // If register fails with 409 (already exists), try login next
+    if (res.status === 409) continue;
+
+    // Any other error on login means bad credentials
+    if (endpoint === '/auth/login' && !res.ok) {
+      console.error(`\n❌ Login failed: ${data.error?.message || 'Unknown error'}`);
+      return;
+    }
+  }
+
+  if (!apiKey) {
+    console.error('\n❌ Failed to authenticate');
+    return;
+  }
+
+  // Save to ~/.config/chorus/.env
+  const configDir = path.join(os.homedir(), '.config', 'chorus');
+  await fs.mkdir(configDir, { recursive: true });
+  const envPath = path.join(configDir, '.env');
+  let envContent = '';
+  try {
+    envContent = await fs.readFile(envPath, 'utf8');
+  } catch { /* no .env yet */ }
+
+  if (envContent.includes('PROXY_API_KEY=')) {
+    envContent = envContent.replace(/PROXY_API_KEY=.*/, `PROXY_API_KEY=${apiKey}`);
+  } else {
+    envContent = envContent.trimEnd() + `\nPROXY_API_KEY=${apiKey}\n`;
+  }
+  await fs.writeFile(envPath, envContent);
+
+  // Update in-memory config
+  CONFIG.ai.anthropicApiKey = apiKey;
+  process.env.PROXY_API_KEY = apiKey;
+
+  console.log(`   API key saved to .env\n`);
+}
+
+async function setupTeamsAuth() {
+  console.log('Setting up Teams authentication...\n');
+
+  const { firefox } = require('playwright');
+  const browser = await firefox.launch({ headless: false });
+  const context = await browser.newContext();
+  const page = await context.newPage();
+
+  await page.goto('https://teams.microsoft.com');
+
+  console.log('Please log in to Teams manually in the browser window...');
+  console.log('Once logged in and you can see your chats, press Enter here...\n');
+
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  await new Promise(resolve => rl.question('Press Enter when ready... ', resolve));
+  rl.close();
+
+  await fs.mkdir(path.dirname(CONFIG.teams.authPath), { recursive: true });
+  await context.storageState({ path: CONFIG.teams.authPath });
+  await browser.close();
+
+  console.log(`\n✅ Authentication state saved to ${CONFIG.teams.authPath}`);
+}
+
+async function setupSlack() {
+  console.log('Setting up Slack integration...\n');
+  console.log('1. Create or configure your Slack app at:');
+  console.log('   https://api.slack.com/apps\n');
+  console.log('2. Under OAuth & Permissions, add these bot token scopes:');
+  console.log('   - chat:write    (send messages)');
+  console.log('   - users:read    (find users by name)');
+  console.log('   - im:history    (read DM replies)');
+  console.log('   - im:write      (open DM channels)\n');
+  console.log('3. Install the app to your workspace and copy the Bot User OAuth Token.\n');
+
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const token = await prompt(rl, 'Slack bot token (xoxb-...): ', true);
+  rl.close();
+
+  if (!token.startsWith('xoxb-')) {
+    console.error('\n❌ Invalid token — Slack bot tokens start with "xoxb-"');
+    return;
+  }
+
+  const configDir = path.join(os.homedir(), '.config', 'chorus');
+  await fs.mkdir(configDir, { recursive: true });
+  const envPath = path.join(configDir, '.env');
+  let envContent = '';
+  try {
+    envContent = await fs.readFile(envPath, 'utf8');
+  } catch { /* no .env yet */ }
+
+  const updates = { SLACK_BOT_TOKEN: token, MESSENGER: 'slack' };
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    if (regex.test(envContent)) {
+      envContent = envContent.replace(regex, `${key}=${value}`);
+    } else {
+      envContent = envContent.trimEnd() + `\n${key}=${value}`;
+    }
+  }
+
+  await fs.writeFile(envPath, envContent.trimEnd() + '\n');
+
+  CONFIG.messenger = 'slack';
+  CONFIG.slack.botToken = token;
+
+  console.log(`\n✅ Slack config saved to ${envPath}\n`);
+}
+
+async function setupAzureDevOps() {
+  console.log('Setting up Azure DevOps configuration...\n');
+
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const adoOrg = await prompt(rl, 'Azure DevOps organization: ');
+  const adoProject = await prompt(rl, 'Azure DevOps project: ');
+  const adoRepo = await prompt(rl, 'Azure DevOps repository name: ');
+  const adoPat = await prompt(rl, 'Azure DevOps PAT (personal access token): ', true);
+  rl.close();
+
+  const configDir = path.join(os.homedir(), '.config', 'chorus');
+  await fs.mkdir(configDir, { recursive: true });
+  const envPath = path.join(configDir, '.env');
+  let envContent = '';
+  try {
+    envContent = await fs.readFile(envPath, 'utf8');
+  } catch { /* no .env yet */ }
+
+  const updates = { AZDO_ORG: adoOrg, AZDO_PROJECT: adoProject, AZDO_REPO: adoRepo, PROVIDER: 'azuredevops' };
+  if (adoPat) updates.AZDO_PAT = adoPat;
+
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    if (regex.test(envContent)) {
+      envContent = envContent.replace(regex, `${key}=${value}`);
+    } else {
+      envContent = envContent.trimEnd() + `\n${key}=${value}`;
+    }
+  }
+
+  await fs.writeFile(envPath, envContent.trimEnd() + '\n');
+
+  CONFIG.azuredevops.org = adoOrg;
+  CONFIG.azuredevops.project = adoProject;
+  CONFIG.azuredevops.repo = adoRepo;
+  if (adoPat) CONFIG.azuredevops.pat = adoPat;
+
+  console.log(`\n✅ Azure DevOps config saved to ${envPath} (${adoOrg}/${adoProject}/${adoRepo})\n`);
+}
+
+async function setup() {
+  console.log('Chorus Setup\n============\n');
+
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const providerChoice = await prompt(rl, 'Which provider? (github / azuredevops) [github]: ');
+  rl.close();
+
+  const chosenProvider = (providerChoice || 'github').toLowerCase();
+
+  if (chosenProvider === 'azuredevops' || chosenProvider === 'ado' || chosenProvider === 'azure') {
+    await setupAzureDevOps();
+  } else {
+    await setupGitHub();
+  }
+
+  await setupProxyAuth();
+
+  const readline2 = require('readline');
+  const rl2 = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  const messengerChoice = await prompt(rl2, 'Which messenger for QA chat? (teams / slack) [teams]: ');
+  rl2.close();
+
+  const chosenMessenger = (messengerChoice || 'teams').toLowerCase();
+
+  if (chosenMessenger === 'slack') {
+    await setupSlack();
+  } else {
+    await setupTeamsAuth();
+  }
+
+  console.log('\n✅ Setup complete. You can now run: chorus run\n');
+}
+
+// ===== CLI =====
+const command = process.argv[2];
+const _envExists = require('fs').existsSync(path.join(os.homedir(), '.config', 'chorus', '.env'));
+
+function parseRunArgs() {
+  const args = process.argv.slice(3);
+  const opts = { useSuper: false, skipQA: false, qaName: null, issueArg: null };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--super') {
+      opts.useSuper = true;
+    } else if (args[i] === '--skip-qa') {
+      opts.skipQA = true;
+    } else if (args[i] === '--qa' && i + 1 < args.length) {
+      opts.qaName = args[++i];
+    } else if (!args[i].startsWith('--')) {
+      opts.issueArg = args[i];
+    }
+  }
+  return opts;
+}
+
+if (command === 'setup') {
+  setup().catch(console.error);
+} else if (command === 'run') {
+  if (!_envExists) {
+    console.log('It looks like this is your first time running Chorus.');
+    console.log('Running setup first...\n');
+    setup().then(() => {
+      const { issueArg, ...opts } = parseRunArgs();
+      return processTicket(issueArg, opts);
+    }).catch(console.error);
+  } else {
+    const { issueArg, ...opts } = parseRunArgs();
+    processTicket(issueArg, opts).catch(console.error);
+  }
+} else {
+  if (!_envExists) {
+    console.log(`
+Chorus — AI-powered GitHub ticket automation
+=============================================
+
+It looks like Chorus hasn't been set up yet.
+Run "chorus setup" to get started.
+    `);
+  } else {
+    console.log(`
+Chorus — AI-powered ticket automation (GitHub & Azure DevOps)
+=============================================================
+
+Usage:
+  chorus setup                       - Set up provider, Chorus auth + messenger
+  chorus run                         - Process latest assigned issue
+  chorus run 4464                    - Process specific issue by number
+  chorus run <url>                   - Process issue from full URL (auto-detects provider)
+  chorus run 4464 --super            - Use Opus 4.6 for QA evaluation
+  chorus run 4464 --qa 'John Doe'   - Specify QA contact name for chat
+  chorus run 4464 --skip-qa          - Skip QA conversation, go straight to coding
+
+GitHub examples:
+  chorus run 4464
+  chorus run https://github.com/shesha-io/shesha-framework/issues/4464
+
+Azure DevOps examples:
+  chorus run 456
+  chorus run https://dev.azure.com/myorg/myproject/_workitems/edit/456
+  PROVIDER=azuredevops chorus run 456
+
+Slack example:
+  MESSENGER=slack chorus run 4464 --qa 'John Doe'
+
+Environment variables:
+  PROVIDER          - Force provider: github (default) or azuredevops
+  MESSENGER         - Messenger for QA chat: teams (default) or slack
+  SLACK_BOT_TOKEN   - Slack bot token (required when MESSENGER=slack)
+  AZDO_ORG          - Azure DevOps organization
+  AZDO_PROJECT      - Azure DevOps project
+  AZDO_REPO         - Azure DevOps repository name
+  AZDO_PAT          - Azure DevOps personal access token
+
+Configuration is stored in ~/.config/chorus/.env
+Run "chorus setup" to configure credentials and messenger auth.
+    `);
+  }
+}