@ateriss_/aiv-cli 0.1.0

package/src/cli/commands/prs.ts

@@ -0,0 +1,118 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { table } from 'table';
+import { resolveConfig, getGithubToken, isInitialized } from '../../config';
+import { GithubClient } from '../../git/github';
+import { detectRepoInfo } from '../../git/utils';
+import { selectPR, confirmReview } from '../selector';
+import { runReview } from './review';
+import { t } from '../../i18n';
+
+export function prsCommand(): Command {
+  return new Command('prs')
+    .alias('p')
+    .description('List open pull requests and optionally launch a review')
+    .option('--limit <n>', 'Max number of PRs to show', '20')
+    .option('--owner <owner>', 'GitHub owner (overrides auto-detect)')
+    .option('--repo <repo>', 'GitHub repo (overrides auto-detect)')
+    .option('--no-select', 'Skip interactive selector, just list PRs')
+    .action(async (opts) => {
+      if (!isInitialized()) {
+        console.log(chalk.red(t().notInitialized));
+        return;
+      }
+
+      const config = resolveConfig();
+      let token: string;
+      try {
+        token = getGithubToken(config);
+      } catch {
+        console.log(chalk.red(t().prsMissingToken(config.github.token_env)));
+        return;
+      }
+
+      const repoInfo = detectRepoInfo(process.cwd());
+      const owner = opts.owner ?? config.github.owner ?? repoInfo?.owner;
+      const repo  = opts.repo  ?? config.github.repo  ?? repoInfo?.repo;
+
+      if (!owner || !repo) {
+        console.log(chalk.red(t().repoNotDetected));
+        return;
+      }
+
+      const spinner = ora(t().prsFetching(chalk.cyan(`${owner}/${repo}`))).start();
+      let prs: Awaited<ReturnType<GithubClient['listPRs']>>;
+
+      try {
+        const client = new GithubClient(token);
+        prs = await client.listPRs(owner, repo, Number.parseInt(opts.limit));
+        spinner.stop();
+      } catch (e: any) {
+        spinner.fail(chalk.red(t().prsFailed(e.message)));
+        return;
+      }
+
+      if (prs.length === 0) {
+        console.log(chalk.yellow(t().prsNoneFound));
+        return;
+      }
+
+      // ── Table ──────────────────────────────────────────────────────────────
+      const rows = prs.map(pr => [
+        chalk.cyan(`#${pr.number}`),
+        truncate(pr.title, 50),
+        chalk.dim(pr.author),
+        chalk.dim(pr.branch),
+        chalk.green(`+${pr.additions}`) + chalk.dim('/') + chalk.red(`-${pr.deletions}`),
+        chalk.dim(formatDate(pr.createdAt)),
+      ]);
+
+      const header = [
+        chalk.bold(t().prsColPR),
+        chalk.bold(t().prsColTitle),
+        chalk.bold(t().prsColAuthor),
+        chalk.bold(t().prsColBranch),
+        chalk.bold(t().prsColChanges),
+        chalk.bold(t().prsColCreated),
+      ];
+
+      console.log('\n' + table([header, ...rows], {
+        border: {
+          topBody: '─', topJoin: '┬', topLeft: '╭', topRight: '╮',
+          bottomBody: '─', bottomJoin: '┴', bottomLeft: '╰', bottomRight: '╯',
+          bodyLeft: '│', bodyRight: '│', bodyJoin: '│',
+          joinBody: '─', joinLeft: '├', joinRight: '┤', joinJoin: '┼',
+        },
+        columnDefault: { paddingLeft: 1, paddingRight: 1 },
+      }));
+
+      console.log(chalk.dim(`  ${t().prsFooter(prs.length).trim()}`));
+      console.log(chalk.dim(`  ${t().reviewAccount(config.github.accountName, config.github.token_env)}\n`));
+
+      // ── Interactive selector ───────────────────────────────────────────────
+      if (opts.select === false || !process.stdout.isTTY) return;
+
+      const selected = await selectPR(prs, t().selectorSelectPR);
+      if (!selected) {
+        console.log(chalk.dim(t().selectorCancelled));
+        return;
+      }
+
+      const confirmed = await confirmReview(selected, t().selectorConfirmReview);
+      if (!confirmed) {
+        console.log(chalk.dim(t().selectorCancelled));
+        return;
+      }
+
+      await runReview({ prNumber: selected.number, owner, repo, config, token });
+    });
+}
+
+function truncate(str: string, max: number): string {
+  return str.length > max ? str.slice(0, max - 1) + '…' : str;
+}
+
+function formatDate(iso: string): string {
+  return new Date(iso).toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: '2-digit' });
+}

package/src/cli/commands/review.ts

@@ -0,0 +1,171 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { resolveConfig, loadRules, getGithubToken, isInitialized } from '../../config';
+import type { ResolvedConfig } from '../../types';
+import { GithubClient } from '../../git/github';
+import { detectRepoInfo } from '../../git/utils';
+import { Orchestrator } from '../../orchestrator';
+import { ContextManager, refreshContextFiles } from '../../context/manager';
+import { renderReview } from '../renderer';
+import { selectPR, selectPostReviewAction } from '../selector';
+import { t } from '../../i18n';
+
+// ─── Shared review runner (used by prs.ts and review command) ─────────────────
+
+export interface RunReviewOptions {
+  prNumber: number;
+  owner: string;
+  repo: string;
+  config: ResolvedConfig;
+  token: string;
+  agents?: string[];
+  json?: boolean;
+}
+
+export async function runReview(opts: RunReviewOptions): Promise<void> {
+  const { prNumber, owner, repo, config, token } = opts;
+  const rules = loadRules();
+  const activeAgents = opts.agents ?? ['business', 'architecture', 'security'];
+
+  console.log(chalk.bold(t().reviewTitle(prNumber)));
+  console.log(chalk.dim(`  ${t().reviewAccount(config.github.accountName, config.github.token_env)}\n`));
+
+  const fetchSpinner = ora(t().reviewFetching(prNumber, `${owner}/${repo}`)).start();
+  let prDiff: Awaited<ReturnType<GithubClient['getPRDiff']>>;
+
+  try {
+    const client = new GithubClient(token);
+    prDiff = await client.getPRDiff(owner, repo, prNumber);
+    fetchSpinner.succeed(t().reviewLoaded(chalk.cyan(prDiff.pr.title), prDiff.files.length));
+  } catch (e: any) {
+    fetchSpinner.fail(chalk.red(t().reviewFetchFailed(e.message)));
+    return;
+  }
+
+  const ctxSpinner = ora(t().reviewLoadingContext).start();
+  const context = new ContextManager(process.cwd()).buildReviewContext(prDiff);
+  ctxSpinner.succeed(t().reviewContextLoaded);
+
+  console.log(chalk.dim(t().reviewRunningAgents(activeAgents.join(', '))));
+
+  try {
+    const result = await new Orchestrator(config, rules).run(prDiff, context, activeAgents);
+    if (opts.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    renderReview(result);
+  } catch (e: any) {
+    console.log(chalk.red(t().reviewFailed(e.message)));
+    return;
+  }
+
+  if (!process.stdout.isTTY) return;
+
+  const action = await selectPostReviewAction(t().postReviewSelectAction);
+  if (action === 'skip') return;
+
+  const event = action === 'approve' ? 'APPROVE' : 'REQUEST_CHANGES';
+  const submitSpinner = ora(t().postReviewSubmitting).start();
+
+  try {
+    await new GithubClient(token).submitReview(owner, repo, prNumber, event);
+    if (action === 'approve') {
+      submitSpinner.succeed(chalk.green(t().postReviewApproved(prNumber)));
+    } else {
+      submitSpinner.succeed(chalk.yellow(t().postReviewChangesRequested(prNumber)));
+    }
+  } catch (e: any) {
+    submitSpinner.fail(chalk.red(t().postReviewFailed(e.message)));
+    return;
+  }
+
+  if (action === 'approve') {
+    const refreshSpinner = ora(t().postReviewRefreshing).start();
+    await refreshContextFiles(process.cwd());
+    refreshSpinner.succeed(chalk.green(t().postReviewRefreshed));
+  }
+}
+
+// ─── CLI command ──────────────────────────────────────────────────────────────
+
+export function reviewCommand(): Command {
+  return new Command('review')
+    .alias('r')
+    .description('Run AI review on a pull request')
+    .argument('[pr-number]', 'PR number (omit to pick interactively)')
+    .option('--owner <owner>', 'GitHub owner')
+    .option('--repo <repo>', 'GitHub repo')
+    .option('--agent <agents...>', 'Run specific agents only (business, architecture, security)')
+    .option('--json', 'Output raw JSON result')
+    .action(async (prArg: string | undefined, opts) => {
+      if (!isInitialized()) {
+        console.log(chalk.red(t().notInitialized));
+        return;
+      }
+
+      const config = resolveConfig();
+      let token: string;
+      try {
+        token = getGithubToken(config);
+      } catch {
+        console.log(chalk.red(t().prsMissingToken(config.github.token_env)));
+        return;
+      }
+
+      const repoInfo = detectRepoInfo(process.cwd());
+      const owner = opts.owner ?? config.github.owner ?? repoInfo?.owner;
+      const repo  = opts.repo  ?? config.github.repo  ?? repoInfo?.repo;
+
+      if (!owner || !repo) {
+        console.log(chalk.red(t().repoNotDetected));
+        return;
+      }
+
+      let prNumber: number;
+
+      if (prArg === undefined) {
+        // No number — fetch PRs and show interactive selector
+        const spinner = ora(t().prsFetching(chalk.cyan(`${owner}/${repo}`))).start();
+        let prs: Awaited<ReturnType<GithubClient['listPRs']>>;
+        try {
+          prs = await new GithubClient(token).listPRs(owner, repo, 30);
+          spinner.stop();
+        } catch (e: any) {
+          spinner.fail(chalk.red(t().prsFailed(e.message)));
+          return;
+        }
+
+        if (prs.length === 0) {
+          console.log(chalk.yellow(t().prsNoneFound));
+          return;
+        }
+
+        const selected = await selectPR(prs, t().selectorSelectPR);
+        if (!selected) {
+          console.log(chalk.dim(t().selectorCancelled));
+          return;
+        }
+        prNumber = selected.number;
+      } else {
+        // PR number provided directly
+        prNumber = Number.parseInt(prArg);
+        if (Number.isNaN(prNumber)) {
+          console.log(chalk.red(t().invalidPrNumber));
+          return;
+        }
+      }
+
+      await runReview({
+        prNumber,
+        owner,
+        repo,
+        config,
+        token,
+        agents: opts.agent,
+        json: opts.json,
+      });
+    });
+}
+

package/src/cli/renderer.ts

@@ -0,0 +1,102 @@
+import chalk from 'chalk';
+import { ReviewResult, AgentFinding } from '../types';
+import { t } from '../i18n';
+
+export function renderReview(result: ReviewResult): void {
+  const tr = t();
+  const riskColor = riskChalk(result.riskLabel);
+  const riskBadge = riskColor(`${result.riskScore}/100 [${result.riskLabel}]`);
+
+  console.log('\n' + chalk.bold('━'.repeat(60)));
+  console.log(chalk.bold(tr.renderReviewTitle(result.prNumber, result.prTitle)));
+  console.log(chalk.bold('━'.repeat(60)));
+
+  console.log(`\n  ${chalk.bold(tr.renderRiskScore)} ${riskBadge}`);
+  console.log(`  ${chalk.bold(tr.renderGenerated)} ${chalk.dim(result.generatedAt)}\n`);
+
+  console.log(chalk.bold(tr.renderExecutiveSummary));
+  console.log(chalk.dim('  ' + '─'.repeat(56)));
+  console.log(indent(result.executiveSummary, 2));
+
+  if (result.securityIssues.length > 0) {
+    console.log('\n' + chalk.bold.red(tr.renderSecurityIssues));
+    console.log(chalk.dim('  ' + '─'.repeat(56)));
+    renderFindings(result.securityIssues);
+  }
+
+  if (result.businessRisks.length > 0) {
+    console.log('\n' + chalk.bold.yellow(tr.renderBusinessRisks));
+    console.log(chalk.dim('  ' + '─'.repeat(56)));
+    renderFindings(result.businessRisks);
+  }
+
+  if (result.architectureIssues.length > 0) {
+    console.log('\n' + chalk.bold.blue(tr.renderArchitectureIssues));
+    console.log(chalk.dim('  ' + '─'.repeat(56)));
+    renderFindings(result.architectureIssues);
+  }
+
+  if (result.possibleRegressions.length > 0) {
+    console.log('\n' + chalk.bold.magenta(tr.renderRegressions));
+    console.log(chalk.dim('  ' + '─'.repeat(56)));
+    result.possibleRegressions.forEach(r => {
+      console.log(`  ${chalk.magenta('◆')} ${r}`);
+    });
+  }
+
+  console.log('\n' + chalk.bold(tr.renderAgentSummaries));
+  console.log(chalk.dim('  ' + '─'.repeat(56)));
+  result.agents.forEach(agent => {
+    const score = riskChalk(scoreLabel(agent.riskScore));
+    const scoreBadge = score(`[${agent.riskScore}/100]`);
+    console.log(`\n  ${chalk.bold(agent.agentName.toUpperCase())} ${scoreBadge}`);
+    console.log(indent(agent.summary, 2));
+  });
+
+  console.log('\n' + chalk.bold('━'.repeat(60)) + '\n');
+}
+
+function renderFindings(findings: AgentFinding[]): void {
+  const tr = t();
+  findings.forEach(f => {
+    const sev = severityBadge(f.severity);
+    const file = f.file ? chalk.dim(` → ${f.file}`) : '';
+    console.log(`\n  ${sev} ${chalk.bold(f.title)}${file}`);
+    console.log(indent(f.description, 2));
+    if (f.suggestion) {
+      console.log(`  ${chalk.dim(tr.renderSuggestion)} ${f.suggestion}`);
+    }
+  });
+}
+
+function severityBadge(sev: string): string {
+  const tr = t();
+  switch (sev) {
+    case 'critical': return chalk.bgRed.white(` ${tr.severityCritical} `);
+    case 'high':     return chalk.red(`[${tr.severityHigh}]`);
+    case 'medium':   return chalk.yellow(`[${tr.severityMedium}]`);
+    case 'low':      return chalk.blue(`[${tr.severityLow}]`);
+    default:         return chalk.dim(`[${tr.severityInfo}]`);
+  }
+}
+
+function riskChalk(label: string) {
+  switch (label) {
+    case 'CRITICAL': return chalk.bgRed.white;
+    case 'HIGH':     return chalk.red;
+    case 'MEDIUM':   return chalk.yellow;
+    default:         return chalk.green;
+  }
+}
+
+function scoreLabel(score: number): 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL' {
+  if (score >= 80) return 'CRITICAL';
+  if (score >= 60) return 'HIGH';
+  if (score >= 30) return 'MEDIUM';
+  return 'LOW';
+}
+
+function indent(text: string, spaces: number): string {
+  const pad = ' '.repeat(spaces);
+  return text.split('\n').map(l => pad + l).join('\n');
+}

package/src/cli/selector.ts

@@ -0,0 +1,78 @@
+import chalk from 'chalk';
+import { PullRequest } from '../types';
+
+// Inquirer v9 is ESM-only — must be loaded via dynamic import in CJS projects
+async function getInquirer() {
+  const mod = await import('inquirer');
+  return (mod as any).default as {
+    prompt: (questions: object[]) => Promise<Record<string, unknown>>;
+    Separator: new (line?: string) => object;
+  };
+}
+
+const CANCEL = -1;
+
+function prLabel(pr: PullRequest): string {
+  const num   = chalk.cyan(`#${pr.number}`);
+  const title = pr.title.length > 52 ? pr.title.slice(0, 51) + '…' : pr.title;
+  const meta  = chalk.dim(`${pr.author} · ${pr.branch}`);
+  const diff  = chalk.green(`+${pr.additions}`) + chalk.dim('/') + chalk.red(`-${pr.deletions}`);
+  return `${num}  ${title}  ${meta}  ${diff}`;
+}
+
+export async function selectPR(prs: PullRequest[], message: string): Promise<PullRequest | null> {
+  const inquirer = await getInquirer();
+
+  const choices = [
+    ...prs.map(pr => ({ name: prLabel(pr), value: pr.number, short: `#${pr.number}` })),
+    new inquirer.Separator('─'.repeat(62)),
+    { name: chalk.dim('↩  Cancel'), value: CANCEL, short: 'Cancel' },
+  ];
+
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'prNumber',
+    message,
+    choices,
+    pageSize: 14,
+    loop: false,
+  }]);
+
+  const selected = answers['prNumber'] as number;
+  return selected === CANCEL ? null : (prs.find(pr => pr.number === selected) ?? null);
+}
+
+export type PostReviewAction = 'approve' | 'request_changes' | 'skip';
+
+export async function selectPostReviewAction(message: string): Promise<PostReviewAction> {
+  const inquirer = await getInquirer();
+
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'action',
+    message,
+    choices: [
+      { name: chalk.green('✔  Approve PR'),        value: 'approve',          short: 'Approve' },
+      { name: chalk.yellow('⚑  Request Changes'),  value: 'request_changes',  short: 'Request Changes' },
+      new inquirer.Separator('─'.repeat(42)),
+      { name: chalk.dim('↩  Skip'),                value: 'skip',             short: 'Skip' },
+    ],
+    pageSize: 4,
+    loop: false,
+  }]);
+
+  return answers['action'] as PostReviewAction;
+}
+
+export async function confirmReview(pr: PullRequest, label: string): Promise<boolean> {
+  const inquirer = await getInquirer();
+
+  const answers = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'ok',
+    message: `${label} ${chalk.cyan(`#${pr.number}`)} — ${pr.title}?`,
+    default: true,
+  }]);
+
+  return Boolean(answers['ok']);
+}