codeant-cli 0.2.1 → 0.2.3

package/src/index.js

@@ -0,0 +1,398 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import { render } from 'ink';
+import React from 'react';
+import { createRequire } from 'module';
+import Secrets from './commands/secrets.js';
+import SetBaseUrl from './commands/setBaseUrl.js';
+import GetBaseUrl from './commands/getBaseUrl.js';
+import Login from './commands/login.js';
+import Logout from './commands/logout.js';
+import StaticAnalysis from './commands/staticAnalysis.js';
+import SecurityAnalysis from './commands/securityAnalysis.js';
+import Review from './commands/review.js';
+import Welcome from './components/Welcome.js';
+import * as scm from './scm/index.js';
+import { setConfigValue } from './utils/config.js';
+
+// Read version from package.json — createRequire works with ncc bundling
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+// Split comma-separated globs while preserving commas inside {} brace expansions (e.g. "*.{js,ts}")
+function splitGlobs(input) {
+  const parts = [];
+  let current = '';
+  let depth = 0;
+  for (const ch of String(input)) {
+    if (ch === '{') depth++;
+    else if (ch === '}') depth--;
+    if (ch === ',' && depth === 0) {
+      parts.push(current.trim());
+      current = '';
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current.trim());
+  return parts.filter(Boolean);
+}
+
+// Show welcome animation if no arguments provided
+if (process.argv.length === 2) {
+  render(React.createElement(Welcome, { version: pkg.version }));
+} else {
+  program
+    .name('codeant')
+    .description('Code review CLI tool')
+    .version(pkg.version);
+
+program
+  .command('secrets')
+  .description('Scan for secrets in your code')
+  .option('--staged', 'Scan only staged files (default)')
+  .option('--all', 'Scan all changed files')
+  .option('--uncommitted', 'Scan uncommitted changes')
+  .option('--last-commit', 'Scan last commit')
+  .option('--last-n-commits <n>', 'Scan last n commits (max 5)', parseInt)
+  .option('--fail-on <level>', 'Fail only on HIGH, MEDIUM, or all (default: HIGH)', 'HIGH')
+  .option('--include <paths>', 'Comma-separated list of file paths regex to include')
+  .option('--exclude <paths>', 'Comma-separated list of file paths regex to exclude')
+  .action((options) => {
+    let scanType = 'staged-only';
+    let lastNCommits = 1;
+
+    // Check !== undefined, not truthy — passing 0 is valid and shouldn't fall through
+    if (options.lastNCommits !== undefined) {
+      scanType = 'last-n-commits';
+      lastNCommits = Math.min(Math.max(1, options.lastNCommits), 5);
+    } else if (options.all) {
+      scanType = 'branch-diff';
+    } else if (options.uncommitted) {
+      scanType = 'uncommitted';
+    } else if (options.lastCommit) {
+      scanType = 'last-commit';
+    }
+
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : splitGlobs(options.include))
+      : [];
+
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : splitGlobs(options.exclude))
+      : [];
+
+    const failOn = options.failOn?.toUpperCase() || 'HIGH';
+
+    render(React.createElement(Secrets, { scanType, failOn, include, exclude, lastNCommits }));
+  });
+
+program
+  .command('static-analysis')
+  .description('Run static analysis on your code')
+  .option('--staged', 'Scan only staged files (default)')
+  .option('--all', 'Scan all changed files')
+  .option('--uncommitted', 'Scan uncommitted changes')
+  .option('--last-commit', 'Scan last commit')
+  .option('--last-n-commits <n>', 'Scan last n commits (max 5)', parseInt)
+  .option('--fail-on <level>', 'Fail on issues at or above this level: BLOCKER, CRITICAL, MAJOR, MINOR, INFO (default: CRITICAL)', 'CRITICAL')
+  .option('--auto-fix', 'Automatically apply fixes when available')
+  .option('--include <paths>', 'Comma-separated list of file paths regex to include')
+  .option('--exclude <paths>', 'Comma-separated list of file paths regex to exclude')
+  .action((options) => {
+    let scanType = 'staged-only';
+    let lastNCommits = 1;
+
+    // Check !== undefined, not truthy — passing 0 is valid and shouldn't fall through
+    if (options.lastNCommits !== undefined) {
+      scanType = 'last-n-commits';
+      lastNCommits = Math.min(Math.max(1, options.lastNCommits), 5);
+    } else if (options.all) {
+      scanType = 'branch-diff';
+    } else if (options.uncommitted) {
+      scanType = 'uncommitted';
+    } else if (options.lastCommit) {
+      scanType = 'last-commit';
+    }
+
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : splitGlobs(options.include))
+      : [];
+
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : splitGlobs(options.exclude))
+      : [];
+
+    const failOn = options.failOn?.toUpperCase() || 'CRITICAL';
+    const autoFix = options.autoFix || false;
+    render(React.createElement(StaticAnalysis, {scanType, failOn, include, exclude, autoFix, lastNCommits}));
+  });
+
+program
+  .command('security-analysis')
+  .description('Run security analysis on your code')
+  .option('--staged', 'Scan only staged files (default)')
+  .option('--all', 'Scan all changed files')
+  .option('--uncommitted', 'Scan uncommitted changes')
+  .option('--last-commit', 'Scan last commit')
+  .option('--last-n-commits <n>', 'Scan last n commits (max 5)', parseInt)
+  .option('--fail-on <level>', 'Fail on issues at or above this level: BLOCKER, CRITICAL, MAJOR, MINOR, INFO (default: CRITICAL)', 'CRITICAL')
+  .option('--include <paths>', 'Comma-separated list of file paths regex to include')
+  .option('--exclude <paths>', 'Comma-separated list of file paths regex to exclude')
+  .action((options) => {
+    let scanType = 'staged-only';
+    let lastNCommits = 1;
+
+    // Check !== undefined, not truthy — passing 0 is valid and shouldn't fall through
+    if (options.lastNCommits !== undefined) {
+      scanType = 'last-n-commits';
+      lastNCommits = Math.min(Math.max(1, options.lastNCommits), 5);
+    } else if (options.all) {
+      scanType = 'branch-diff';
+    } else if (options.uncommitted) {
+      scanType = 'uncommitted';
+    } else if (options.lastCommit) {
+      scanType = 'last-commit';
+    }
+
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : splitGlobs(options.include))
+      : [];
+
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : splitGlobs(options.exclude))
+      : [];
+
+    const failOn = options.failOn?.toUpperCase() || 'HIGH';
+
+    render(React.createElement(SecurityAnalysis, { scanType, failOn, include, exclude, lastNCommits }));
+  });
+
+program
+  .command('review')
+  .description('Run AI-powered code review')
+  .option('--all', 'Review committed + uncommitted changes (default)')
+  .option('--committed', 'Review only unpushed commits')
+  .option('--uncommitted', 'Review only uncommitted changes (staged + unstaged + untracked)')
+  .option('--staged', 'Review only staged files')
+  .option('--last-commit', 'Review last commit')
+  .option('--last-n-commits <n>', 'Review last n commits (max 5)', parseInt)
+  .option('--base <branch>', 'Compare against a specific base branch (e.g. --base develop)')
+  .option('--base-commit <commit>', 'Compare against a specific commit (e.g. --base-commit HEAD~3)')
+  .option('--fail-on <level>', 'Fail on issues at or above this level: BLOCKER, CRITICAL, MAJOR, MINOR, INFO (default: CRITICAL)', 'CRITICAL')
+  .option('--include <paths>', 'Comma-separated list of file paths glob patterns to include')
+  .option('--exclude <paths>', 'Comma-separated list of file paths glob patterns to exclude')
+  .action((options) => {
+    let scanType = 'all';
+    let lastNCommits = 1;
+    let baseBranch = null;
+    let baseCommit = null;
+
+    if (options.base) {
+      scanType = 'base-branch';
+      baseBranch = options.base;
+    } else if (options.baseCommit) {
+      scanType = 'base-commit';
+      baseCommit = options.baseCommit;
+    // Check !== undefined, not truthy — passing 0 is valid and shouldn't fall through
+    } else if (options.lastNCommits !== undefined) {
+      scanType = 'last-n-commits';
+      lastNCommits = Math.min(Math.max(1, options.lastNCommits), 5);
+    } else if (options.committed) {
+      scanType = 'committed';
+    } else if (options.uncommitted) {
+      scanType = 'uncommitted';
+    } else if (options.staged) {
+      scanType = 'staged-only';
+    } else if (options.lastCommit) {
+      scanType = 'last-commit';
+    }
+
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : splitGlobs(options.include))
+      : [];
+
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : splitGlobs(options.exclude))
+      : [];
+
+    const failOn = options.failOn?.toUpperCase() || 'CRITICAL';
+
+    render(React.createElement(Review, { scanType, lastNCommits, failOn, include, exclude, baseBranch, baseCommit }));
+  });
+
+program
+  .command('set-base-url <url>')
+  .description('Set the API base URL')
+  .action((url) => {
+    render(React.createElement(SetBaseUrl, { url }));
+  });
+
+  program
+    .command('get-base-url')
+    .description('Show the current API base URL')
+    .action(() => {
+      render(React.createElement(GetBaseUrl));
+    });
+
+  program
+    .command('login')
+    .description('Login to CodeAnt')
+    .action(() => {
+      render(React.createElement(Login));
+    });
+
+  program
+    .command('logout')
+    .description('Logout from CodeAnt')
+    .action(() => {
+      render(React.createElement(Logout));
+    });
+
+  // ─── Helper: resolve repo params with auto-detection fallback ───
+  function resolveRepoOpts(options) {
+    const remote = options.remote || scm.detectRemote();
+    const name = options.name || scm.detectRepoName();
+    const defaultBranch = options.defaultBranch || scm.detectDefaultBranch();
+    if (!remote) { console.error('Error: Could not detect remote. Use --remote (github|gitlab|bitbucket|azure)'); process.exit(1); }
+    if (!name) { console.error('Error: Could not detect repo name. Use --name owner/repo'); process.exit(1); }
+    return { ...options, remote, name, defaultBranch };
+  }
+
+  // Helper: run async command and output JSON
+  async function runCmd(fn) {
+    try {
+      const result = await fn();
+      console.log(JSON.stringify(result, null, 2));
+    } catch (err) {
+      console.error(JSON.stringify({ error: err.message }, null, 2));
+      process.exit(1);
+    }
+  }
+
+  // ─── Token management ───
+  program
+    .command('set-token <remote> <token>')
+    .description('Store auth token for a platform (github|gitlab|bitbucket|azure)')
+    .action((remote, token) => {
+      const keyMap = { github: 'githubToken', gitlab: 'gitlabToken', bitbucket: 'bitbucketToken', azure: 'azureDevOpsToken' };
+      const key = keyMap[remote];
+      if (!key) { console.error(`Unknown remote "${remote}". Use: github, gitlab, bitbucket, azure`); process.exit(1); }
+      setConfigValue(key, token);
+      console.log(`${remote} token saved.`);
+    });
+
+  // ─── PR commands ───
+  const pr = program.command('pr').description('Pull request tools (GitHub, GitLab, Bitbucket, Azure DevOps)');
+
+  pr.command('list')
+    .description('List pull requests / merge requests')
+    .option('--name <repo>', 'Repository (owner/repo)')
+    .option('--remote <provider>', 'github, gitlab, bitbucket, azure')
+    .option('--default-branch <branch>', 'Default branch name')
+    .option('--source-branch <branch>', 'Filter by source branch (partial match)')
+    .option('--author <login>', 'Filter by author (fuzzy match)')
+    .option('--state <state>', 'open or closed (default: open)', 'open')
+    .option('--limit <n>', 'Max results (default: 20, max: 100)', parseInt, 20)
+    .option('--offset <n>', 'Pagination offset', parseInt, 0)
+    .action((options) => {
+      const opts = resolveRepoOpts(options);
+      runCmd(() => scm.listPullRequests({
+        name: opts.name, remote: opts.remote, defaultBranch: opts.defaultBranch,
+        sourceBranch: opts.sourceBranch, authorLogin: opts.author,
+        state: opts.state, limit: opts.limit, offset: opts.offset,
+      }));
+    });
+
+  pr.command('get')
+    .description('Get detailed PR information including review analysis')
+    .option('--name <repo>', 'Repository (owner/repo)')
+    .option('--remote <provider>', 'github, gitlab, bitbucket, azure')
+    .option('--default-branch <branch>', 'Default branch name')
+    .requiredOption('--pr-number <n>', 'PR number', parseInt)
+    .action((options) => {
+      const opts = resolveRepoOpts(options);
+      runCmd(() => scm.getPullRequest({
+        name: opts.name, remote: opts.remote, defaultBranch: opts.defaultBranch,
+        prNumber: opts.prNumber,
+      }));
+    });
+
+  pr.command('comments')
+    .description('List all comments for a PR')
+    .option('--name <repo>', 'Repository (owner/repo)')
+    .option('--remote <provider>', 'github, gitlab, bitbucket, azure')
+    .option('--default-branch <branch>', 'Default branch name')
+    .requiredOption('--pr-number <n>', 'PR number', parseInt)
+    .option('--codeant-generated <bool>', 'Filter by CodeAnt authorship (true/false)', (v) => v === 'true')
+    .option('--addressed', 'Filter by addressed/resolved status')
+    .option('--created-after <date>', 'ISO 8601 date filter')
+    .option('--created-before <date>', 'ISO 8601 date filter')
+    .action((options) => {
+      const opts = resolveRepoOpts(options);
+      runCmd(() => scm.listPullRequestComments({
+        name: opts.name, remote: opts.remote, defaultBranch: opts.defaultBranch,
+        prNumber: opts.prNumber, codeantGenerated: opts.codeantGenerated,
+        addressed: opts.addressed, createdAfter: opts.createdAfter, createdBefore: opts.createdBefore,
+      }));
+    });
+
+  // ─── Code review commands ───
+  const codeReview = program.command('code-review').description('Code review tools');
+
+  codeReview.command('list')
+    .description('List code reviews with optional filtering')
+    .option('--name <repo>', 'Repository (owner/repo)')
+    .option('--remote <provider>', 'github, gitlab, bitbucket, azure')
+    .option('--default-branch <branch>', 'Default branch name')
+    .option('--pr-number <n>', 'Filter by PR number', parseInt)
+    .option('--status <status>', 'Filter by status (PENDING, COMPLETED, FAILED, etc.)')
+    .option('--limit <n>', 'Max results (default: 20)', parseInt, 20)
+    .option('--offset <n>', 'Pagination offset', parseInt, 0)
+    .action((options) => {
+      const opts = resolveRepoOpts(options);
+      runCmd(() => scm.listCodeReviews({
+        name: opts.name, remote: opts.remote, defaultBranch: opts.defaultBranch,
+        prNumber: opts.prNumber, status: opts.status,
+        limit: opts.limit, offset: opts.offset,
+      }));
+    });
+
+  codeReview.command('get')
+    .description('Get detailed information for a specific code review')
+    .option('--name <repo>', 'Repository (owner/repo)')
+    .option('--remote <provider>', 'github, gitlab, bitbucket, azure')
+    .requiredOption('--pr-number <n>', 'PR number', parseInt)
+    .requiredOption('--review-id <id>', 'Code review ID')
+    .action((options) => {
+      const opts = resolveRepoOpts(options);
+      runCmd(() => scm.getCodeReview({
+        name: opts.name, remote: opts.remote,
+        prNumber: opts.prNumber, reviewId: opts.reviewId,
+      }));
+    });
+
+  // ─── Comment search ───
+  const comments = program.command('comments').description('Comment search tools');
+
+  comments.command('search')
+    .description('Search across all CodeAnt comments')
+    .option('--name <repo>', 'Repository (owner/repo)')
+    .option('--remote <provider>', 'github, gitlab, bitbucket, azure')
+    .requiredOption('--query <term>', 'Search term')
+    .option('--limit <n>', 'Max results (default: 10, max: 50)', parseInt, 10)
+    .option('--include-addressed', 'Include resolved comments (default: false)')
+    .option('--created-after <date>', 'ISO 8601 date filter')
+    .action((options) => {
+      const opts = resolveRepoOpts(options);
+      runCmd(() => scm.searchComments({
+        name: opts.name, remote: opts.remote,
+        query: opts.query, limit: opts.limit,
+        includeAddressed: opts.includeAddressed || false,
+        createdAfter: opts.createdAfter,
+      }));
+    });
+
+  program.parse();
+}

package/src/reviewHeadless.js

@@ -0,0 +1,170 @@
+import ReviewApiHelper from './utils/reviewApiHelper.js';
+import { fetchApi } from './utils/fetchApi.js';
+import { executeTool } from './tools/executeTool.js';
+
+const MAX_TURNS = 5;
+
+/**
+ * Run a single agent turn loop (per-file or reflector).
+ */
+async function runTurnLoop(initialPayload, gitRoot, isReflectorLoop) {
+  let nextPayload = initialPayload;
+  let finalMessage = null;
+  let finalOutput = null;
+
+  for (let turn = 0; turn < MAX_TURNS; turn += 1) {
+    const resp = await fetchApi('/extension/pr-review/agent/turn', 'POST', nextPayload);
+
+    if (!resp || typeof resp !== 'object') {
+      throw new Error('Invalid response from agent API');
+    }
+
+    const sessionId = resp.session_id;
+    const assistantMsg = resp.response;
+    const done = resp.done;
+
+    if (!sessionId) {
+      throw new Error('Missing session_id in agent response');
+    }
+
+    finalMessage = assistantMsg;
+    if (resp.output) finalOutput = resp.output;
+
+    if (done) {
+      if (isReflectorLoop && resp.parsing_error) {
+        console.error('Warning: parsing error in reflector response');
+      }
+      break;
+    }
+
+    const toolCalls = assistantMsg?.tool_calls || [];
+    if (toolCalls.length === 0) break;
+
+    const toolResults = await Promise.all(
+      toolCalls.map(async (tc) => ({
+        tool_call_id: tc.id,
+        content: await executeTool(tc, gitRoot),
+      }))
+    );
+
+    nextPayload = { session_id: sessionId, tool_results: toolResults };
+  }
+
+  return { finalMessage, finalOutput };
+}
+
+/**
+ * Headless review runner — no React/Ink, returns plain JSON.
+ *
+ * @param {Object} options
+ * @param {string}  options.workspacePath  - Absolute path to the repo/workspace
+ * @param {string}  [options.apiKey]       - API key (overrides env/config)
+ * @param {string}  [options.baseUrl]      - API base URL (overrides env/config)
+ * @param {string}  [options.scanType='all'] - all|committed|uncommitted|staged-only|last-commit|last-n-commits|base-branch|base-commit
+ * @param {string[]} [options.include=[]]  - Glob patterns to include
+ * @param {string[]} [options.exclude=[]]  - Glob patterns to exclude
+ * @param {number}  [options.lastNCommits=1]
+ * @param {string}  [options.baseBranch]
+ * @param {string}  [options.baseCommit]
+ * @param {function} [options.onProgress]  - Optional callback(message) for progress updates
+ * @returns {Promise<{issues: Array, meta: Object|null, error: string|null}>}
+ */
+export async function runReviewHeadless(options = {}) {
+  const {
+    workspacePath,
+    apiKey,
+    baseUrl,
+    scanType = 'all',
+    include = [],
+    exclude = [],
+    lastNCommits = 1,
+    baseBranch = null,
+    baseCommit = null,
+    onProgress = () => {},
+    onFilesReady = () => {},
+  } = options;
+
+  // Temporarily set env vars so fetchApi picks them up
+  const prevToken = process.env.CODEANT_API_TOKEN;
+  const prevUrl = process.env.CODEANT_API_URL;
+
+  if (apiKey) process.env.CODEANT_API_TOKEN = apiKey;
+  if (baseUrl) process.env.CODEANT_API_URL = baseUrl;
+
+  try {
+    // ── Fetch diff ──────────────────────────────────────────────────────
+    onProgress('Fetching diff...');
+
+    const helper = new ReviewApiHelper(workspacePath);
+    await helper.init();
+    const gitRoot = helper.getGitRoot() || workspacePath;
+    const requestBody = await helper.buildReviewApiRequest(scanType, include, exclude, { lastNCommits, baseBranch, baseCommit });
+
+    const meta = requestBody?._meta || null;
+    delete requestBody._meta;
+
+    // Notify caller about files being reviewed as soon as we know
+    onFilesReady(meta?.reviewed_files || [], meta);
+
+    if (!requestBody?.diff_content?.length) {
+      return { issues: [], meta, error: null, noFiles: true };
+    }
+
+    // ── Split into per-file requests ────────────────────────────────────
+    const perFileRequests = ReviewApiHelper.splitIntoPerFileRequests(requestBody);
+
+    onProgress(`Analyzing ${perFileRequests.length} file${perFileRequests.length !== 1 ? 's' : ''} in parallel...`);
+
+    // ── Per-file agent turn loops (parallel) ────────────────────────────
+    const perFileResults = await Promise.all(
+      perFileRequests.map((fileReq) => {
+        const filename = fileReq._filename;
+        delete fileReq._filename;
+
+        if (fileReq.file_contents?.[filename]) {
+          fileReq.file_content = fileReq.file_contents[filename];
+          fileReq.file_path = filename;
+        }
+        delete fileReq.file_contents;
+
+        return runTurnLoop(fileReq, gitRoot, false);
+      })
+    );
+
+    const allSuggestions = perFileResults
+      .map((r) => r.finalMessage?.content)
+      .filter(Boolean);
+
+    // ── Reflector loop ──────────────────────────────────────────────────
+    const combinedSuggestions = allSuggestions.join('\n\n');
+    onProgress('Running reflector...');
+
+    const reflectorPayload = {
+      diff_content: requestBody.diff_content,
+      prompt_template_name: 'reflector',
+      extra_variables: {
+        suggestion_str: combinedSuggestions,
+      },
+    };
+
+    const { finalOutput: reflectorOutput } = await runTurnLoop(reflectorPayload, gitRoot, true);
+
+    // ── Parse results ───────────────────────────────────────────────────
+    const issues = (reflectorOutput?.code_suggestions || []).map((issue) => ({
+      issue_content: issue.issue_content || '',
+      relevant_file: issue.relevant_file || 'Unknown',
+      start_line: issue.start_line || 0,
+      label: issue.label || 'Code Quality',
+    }));
+
+    return { issues, meta, error: null, noFiles: false };
+  } catch (err) {
+    return { issues: [], meta: null, error: err.message, noFiles: false };
+  } finally {
+    // Restore env vars
+    if (prevToken !== undefined) process.env.CODEANT_API_TOKEN = prevToken;
+    else delete process.env.CODEANT_API_TOKEN;
+    if (prevUrl !== undefined) process.env.CODEANT_API_URL = prevUrl;
+    else delete process.env.CODEANT_API_URL;
+  }
+}

package/src/scm/azure/client.js

@@ -0,0 +1,21 @@
+import * as azdev from 'azure-devops-node-api';
+import { getAzureDevOpsToken } from '../../utils/scmAuth.js';
+import { getConfigValue } from '../../utils/config.js';
+
+export function getConnection() {
+  const token = getAzureDevOpsToken();
+  if (!token) throw new Error('Azure DevOps token not found. Set AZURE_DEVOPS_TOKEN env var or run `codeant set-token azure <token>`.');
+
+  const orgUrl = process.env.AZURE_DEVOPS_ORG_URL || getConfigValue('azureDevOpsOrgUrl');
+  if (!orgUrl) throw new Error('Azure DevOps org URL not found. Set AZURE_DEVOPS_ORG_URL env var or run `codeant set-azure-org <url>`.');
+
+  const authHandler = azdev.getPersonalAccessTokenHandler(token);
+  return new azdev.WebApi(orgUrl, authHandler);
+}
+
+// Azure repos use "project/repo" format
+export function splitRepo(name) {
+  const [project, repo] = name.split('/');
+  if (!project || !repo) throw new Error(`Invalid repo name "${name}". Use project/repo format.`);
+  return { project, repo };
+}

package/src/scm/azure/getCodeReview.js

@@ -0,0 +1,20 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function getCodeReview({ name, prNumber, reviewId }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const pr = await gitApi.getPullRequest(repo, prNumber, project);
+  const reviewer = (pr.reviewers || []).find(r => String(r.id) === String(reviewId));
+
+  if (!reviewer) throw new Error(`Reviewer ${reviewId} not found on PR #${prNumber}`);
+
+  return {
+    id: reviewer.id,
+    user: reviewer.displayName || reviewer.uniqueName,
+    state: reviewer.vote > 0 ? 'APPROVED' : reviewer.vote < 0 ? 'REJECTED' : 'PENDING',
+    body: null,
+    comments: [],
+  };
+}

package/src/scm/azure/getPullRequest.js

@@ -0,0 +1,30 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function getPullRequest({ name, prNumber }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const pr = await gitApi.getPullRequest(repo, prNumber, project);
+  const threads = await gitApi.getThreads(repo, prNumber, project);
+
+  const reviewers = (pr.reviewers || []).map(r => ({
+    user: r.displayName || r.uniqueName,
+    state: r.vote > 0 ? 'APPROVED' : r.vote < 0 ? 'REJECTED' : 'PENDING',
+  }));
+
+  return {
+    number: pr.pullRequestId,
+    title: pr.title,
+    state: pr.status === 1 ? 'open' : 'closed',
+    merged: pr.status === 3,
+    author: pr.createdBy?.displayName || pr.createdBy?.uniqueName,
+    sourceBranch: pr.sourceRefName?.replace('refs/heads/', ''),
+    targetBranch: pr.targetRefName?.replace('refs/heads/', ''),
+    body: pr.description,
+    createdAt: pr.creationDate,
+    url: pr.url,
+    reviewSummary: reviewers,
+    threadCount: threads?.length || 0,
+  };
+}

package/src/scm/azure/index.js

@@ -0,0 +1,6 @@
+export { listPullRequests } from './listPullRequests.js';
+export { getPullRequest } from './getPullRequest.js';
+export { listPullRequestComments } from './listPullRequestComments.js';
+export { listCodeReviews } from './listCodeReviews.js';
+export { getCodeReview } from './getCodeReview.js';
+export { searchComments } from './searchComments.js';

package/src/scm/azure/listCodeReviews.js

@@ -0,0 +1,17 @@
+import { getConnection, splitRepo } from './client.js';
+
+export async function listCodeReviews({ name, prNumber, limit = 20 }) {
+  const connection = getConnection();
+  const gitApi = await connection.getGitApi();
+  const { project, repo } = splitRepo(name);
+
+  const pr = await gitApi.getPullRequest(repo, prNumber, project);
+
+  return (pr.reviewers || []).slice(0, limit).map(r => ({
+    id: r.id,
+    user: r.displayName || r.uniqueName,
+    state: r.vote > 0 ? 'APPROVED' : r.vote < 0 ? 'REJECTED' : 'PENDING',
+    body: null,
+    submittedAt: null,
+  }));
+}