@ateriss_/aiv-cli 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
-  "name":  "@ateriss_/aiv-cli",
-  "version": "1.0.0",
+  "name": "@ateriss_/aiv-cli",
+  "version": "1.0.2",
   "description": "AI-powered PR reviewer CLI — local-first, multi-agent semantic analysis",
   "main": "dist/index.js",
   "bin": {
@@ -13,7 +13,14 @@
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["ai", "pr-review", "cli", "github", "claude", "openai"],
+  "keywords": [
+    "ai",
+    "pr-review",
+    "cli",
+    "github",
+    "claude",
+    "openai"
+  ],
   "author": "",
   "license": "MIT",
   "dependencies": {

package/src/agents/base.ts

@@ -1,5 +1,6 @@
 import { AgentResult, AgentFinding, PRDiff, AivRules } from '../types';
 import { LLMProvider } from '../providers/base';
+import { getLang } from '../i18n';
 
 export interface AgentContext {
   projectContext: string;
@@ -36,6 +37,10 @@ export abstract class BaseAgent {
       .map(f => `### ${f.filename}\n\`\`\`diff\n${f.patch}\n\`\`\``)
       .join('\n\n');
 
+    const langInstruction = getLang() === 'es'
+      ? '\n\nIMPORTANT: Respond in Spanish. All string values in the JSON (summary, title, description, suggestion, possibleRegressions) must be written in Spanish.'
+      : '';
+
     return `## PR: #${ctx.diff.pr.number} — ${ctx.diff.pr.title}
 
 **Author:** ${ctx.diff.pr.author}
@@ -83,7 +88,7 @@ Analyze the above and return a JSON response matching this schema:
   "possibleRegressions": ["string"]
 }
 
-Return ONLY valid JSON. No markdown fences, no explanation outside the JSON.`;
+Return ONLY valid JSON. No markdown fences, no explanation outside the JSON.${langInstruction}`;
   }
 
   protected parseResponse(raw: string): AgentResult {

package/src/cli/commands/review.ts

@@ -2,13 +2,13 @@ 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 type { ResolvedConfig, ReviewResult } 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 { renderReview, buildAivComment } from '../renderer';
+import { selectPR, selectPostReviewAction, confirmMerge, selectMergeStrategy } from '../selector';
 import { t } from '../../i18n';
 
 // ─── Shared review runner (used by prs.ts and review command) ─────────────────
@@ -27,15 +27,14 @@ 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'];
+  const client = new GithubClient(token);
 
   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) {
@@ -43,49 +42,110 @@ export async function runReview(opts: RunReviewOptions): Promise<void> {
     return;
   }
 
+  const result = await resolveResult(client, { owner, repo, prNumber }, config, rules, prDiff, activeAgents, opts.json);
+  if (!result) return;
+
+  if (opts.json) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  renderReview(result);
+  if (!process.stdout.isTTY) return;
+
+  const action = await selectPostReviewAction(t().postReviewSelectAction);
+  if (action === 'skip') return;
+
+  if (action === 'post_comment') {
+    await doPostComment(client, owner, repo, prNumber, result);
+    return;
+  }
+
+  const submitted = await doSubmitReview(client, owner, repo, prNumber, action);
+  if (!submitted) return;
+
+  if (action === 'approve') {
+    await doApproveFlow(client, owner, repo, prNumber, result);
+  }
+}
+
+interface RepoRef { owner: string; repo: string; prNumber: number; }
+
+async function resolveResult(
+  client: GithubClient,
+  ref: RepoRef,
+  config: ResolvedConfig, rules: ReturnType<typeof loadRules>,
+  prDiff: Awaited<ReturnType<GithubClient['getPRDiff']>>,
+  activeAgents: string[], json?: boolean,
+): Promise<ReviewResult | null> {
+  const { owner, repo, prNumber } = ref;
+  if (!json && process.stdout.isTTY) {
+    const cached = await client.findAivReview(owner, repo, prNumber);
+    if (cached) {
+      console.log(chalk.cyan(`\n  ${t().reviewCachedFound}`));
+      const useCached = await confirmMerge(t().reviewCachedUse);
+      if (useCached) {
+        console.log(chalk.dim(`  ${t().reviewCachedUsing}`));
+        return cached;
+      }
+      console.log(chalk.dim(`  ${t().reviewCachedSkipping}`));
+    }
+  }
+
   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);
+    return await new Orchestrator(config, rules).run(prDiff, context, activeAgents);
   } catch (e: any) {
     console.log(chalk.red(t().reviewFailed(e.message)));
-    return;
+    return null;
   }
+}
 
-  if (!process.stdout.isTTY) return;
-
-  const action = await selectPostReviewAction(t().postReviewSelectAction);
-  if (action === 'skip') return;
+async function doPostComment(client: GithubClient, owner: string, repo: string, prNumber: number, result: ReviewResult): Promise<void> {
+  const spinner = ora(t().postReviewPostingComment).start();
+  try {
+    await client.postComment(owner, repo, prNumber, buildAivComment(result));
+    spinner.succeed(chalk.green(t().postReviewCommentPosted(prNumber)));
+  } catch (e: any) {
+    spinner.fail(chalk.red(t().postReviewCommentFailed(e.message)));
+  }
+}
 
+async function doSubmitReview(client: GithubClient, owner: string, repo: string, prNumber: number, action: 'approve' | 'request_changes'): Promise<boolean> {
   const event = action === 'approve' ? 'APPROVE' : 'REQUEST_CHANGES';
-  const submitSpinner = ora(t().postReviewSubmitting).start();
-
+  const spinner = 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)));
-    }
+    await client.submitReview(owner, repo, prNumber, event);
+    const msg = action === 'approve' ? t().postReviewApproved(prNumber) : t().postReviewChangesRequested(prNumber);
+    const color = action === 'approve' ? chalk.green : chalk.yellow;
+    spinner.succeed(color(msg));
+    return true;
   } catch (e: any) {
-    submitSpinner.fail(chalk.red(t().postReviewFailed(e.message)));
-    return;
+    spinner.fail(chalk.red(t().postReviewFailed(e.message)));
+    return false;
   }
+}
 
-  if (action === 'approve') {
-    const refreshSpinner = ora(t().postReviewRefreshing).start();
-    await refreshContextFiles(process.cwd());
-    refreshSpinner.succeed(chalk.green(t().postReviewRefreshed));
+async function doApproveFlow(client: GithubClient, owner: string, repo: string, prNumber: number, result: ReviewResult): Promise<void> {
+  const wantsMerge = await confirmMerge(t().postReviewMergeConfirm);
+  if (wantsMerge) {
+    await doPostComment(client, owner, repo, prNumber, result);
+    const strategy = await selectMergeStrategy(t().postReviewSelectMerge);
+    const mergeSpinner = ora(t().postReviewMerging(prNumber)).start();
+    try {
+      await client.mergePR(owner, repo, prNumber, strategy);
+      mergeSpinner.succeed(chalk.green(t().postReviewMerged(prNumber)));
+    } catch (e: any) {
+      mergeSpinner.fail(chalk.red(t().postReviewMergeFailed(e.message)));
+    }
   }
+  const refreshSpinner = ora(t().postReviewRefreshing).start();
+  await refreshContextFiles(process.cwd());
+  refreshSpinner.succeed(chalk.green(t().postReviewRefreshed));
 }
 
 // ─── CLI command ──────────────────────────────────────────────────────────────

package/src/cli/renderer.ts

@@ -2,6 +2,67 @@ import chalk from 'chalk';
 import { ReviewResult, AgentFinding } from '../types';
 import { t } from '../i18n';
 
+const SEVERITY_EMOJI: Record<string, string> = {
+  critical: '🔴', high: '🟠', medium: '🟡', low: '🔵', info: '⚪',
+};
+
+const RISK_EMOJI: Record<string, string> = {
+  CRITICAL: '🔴', HIGH: '🟠', MEDIUM: '🟡', LOW: '🟢',
+};
+
+export function buildAivComment(result: ReviewResult): string {
+  const encoded = Buffer.from(JSON.stringify(result)).toString('base64');
+  const header = `<!-- aiv-review:${encoded} -->`;
+
+  const riskEmoji = RISK_EMOJI[result.riskLabel] ?? '⚪';
+  const lines: string[] = [
+    header,
+    '',
+    `## 🤖 aiv Review — PR #${result.prNumber} · ${result.prTitle}`,
+    '',
+    `**Risk Score:** ${riskEmoji} \`${result.riskScore}/100 ${result.riskLabel}\` · Generated: ${result.generatedAt}`,
+    '',
+    '---',
+    '',
+    '### Executive Summary',
+    result.executiveSummary,
+  ];
+
+  if (result.securityIssues.length > 0) {
+    lines.push('', '---', '', '### 🔴 Security Issues');
+    for (const f of result.securityIssues) lines.push(...findingMd(f));
+  }
+  if (result.businessRisks.length > 0) {
+    lines.push('', '---', '', '### 🟡 Business Risks');
+    for (const f of result.businessRisks) lines.push(...findingMd(f));
+  }
+  if (result.architectureIssues.length > 0) {
+    lines.push('', '---', '', '### 🔵 Architecture Issues');
+    for (const f of result.architectureIssues) lines.push(...findingMd(f));
+  }
+  if (result.possibleRegressions.length > 0) {
+    lines.push('', '---', '', '### ⚠️ Possible Regressions');
+    for (const r of result.possibleRegressions) lines.push(`- ${r}`);
+  }
+
+  lines.push('', '---', '', '<details>', '<summary>Agent Summaries</summary>', '');
+  for (const a of result.agents) {
+    lines.push(`**${a.agentName.toUpperCase()}** \`[${a.riskScore}/100]\``, a.summary, '');
+  }
+  lines.push('</details>', '', '---', '*Generated by [aiv](https://www.npmjs.com/package/@ateriss_/aiv-cli)*');
+
+  return lines.join('\n');
+}
+
+function findingMd(f: AgentFinding): string[] {
+  const emoji = SEVERITY_EMOJI[f.severity] ?? '⚪';
+  const out = [`\n**${emoji} [${f.severity.toUpperCase()}] ${f.title}**`];
+  if (f.file) out.push(`\`${f.file}\``);
+  out.push(f.description);
+  if (f.suggestion) out.push(`> 💡 ${f.suggestion}`);
+  return out;
+}
+
 export function renderReview(result: ReviewResult): void {
   const tr = t();
   const riskColor = riskChalk(result.riskLabel);

package/src/cli/selector.ts

@@ -42,7 +42,8 @@ export async function selectPR(prs: PullRequest[], message: string): Promise<Pul
   return selected === CANCEL ? null : (prs.find(pr => pr.number === selected) ?? null);
 }
 
-export type PostReviewAction = 'approve' | 'request_changes' | 'skip';
+export type PostReviewAction = 'approve' | 'request_changes' | 'post_comment' | 'skip';
+export type MergeStrategy = 'merge' | 'squash' | 'rebase';
 
 export async function selectPostReviewAction(message: string): Promise<PostReviewAction> {
   const inquirer = await getInquirer();
@@ -52,18 +53,47 @@ export async function selectPostReviewAction(message: string): Promise<PostRevie
     name: 'action',
     message,
     choices: [
-      { name: chalk.green('✔  Approve PR'),        value: 'approve',          short: 'Approve' },
-      { name: chalk.yellow('⚑  Request Changes'),  value: 'request_changes',  short: 'Request Changes' },
+      { name: chalk.green('✔  Approve PR'),             value: 'approve',          short: 'Approve' },
+      { name: chalk.yellow('⚑  Request Changes'),       value: 'request_changes',  short: 'Request Changes' },
+      { name: chalk.cyan('💬  Post as PR comment'),     value: 'post_comment',     short: 'Post Comment' },
       new inquirer.Separator('─'.repeat(42)),
-      { name: chalk.dim('↩  Skip'),                value: 'skip',             short: 'Skip' },
+      { name: chalk.dim('↩  Skip'),                     value: 'skip',             short: 'Skip' },
     ],
-    pageSize: 4,
+    pageSize: 5,
     loop: false,
   }]);
 
   return answers['action'] as PostReviewAction;
 }
 
+export async function confirmMerge(message: string): Promise<boolean> {
+  const inquirer = await getInquirer();
+  const answers = await inquirer.prompt([{
+    type: 'confirm',
+    name: 'ok',
+    message,
+    default: false,
+  }]);
+  return Boolean(answers['ok']);
+}
+
+export async function selectMergeStrategy(message: string): Promise<MergeStrategy> {
+  const inquirer = await getInquirer();
+  const answers = await inquirer.prompt([{
+    type: 'list',
+    name: 'strategy',
+    message,
+    choices: [
+      { name: chalk.cyan('Squash and merge'),  value: 'squash', short: 'Squash' },
+      { name: 'Merge commit',                  value: 'merge',  short: 'Merge' },
+      { name: chalk.dim('Rebase and merge'),   value: 'rebase', short: 'Rebase' },
+    ],
+    pageSize: 3,
+    loop: false,
+  }]);
+  return answers['strategy'] as MergeStrategy;
+}
+
 export async function confirmReview(pr: PullRequest, label: string): Promise<boolean> {
   const inquirer = await getInquirer();
 

package/src/git/github.ts

@@ -1,4 +1,6 @@
-import { PullRequest, PRDiff, PRFile } from '../types';
+import { PullRequest, PRDiff, PRFile, ReviewResult } from '../types';
+
+const AIV_COMMENT_TAG = '<!-- aiv-review:';
 
 const GITHUB_API = 'https://api.github.com';
 
@@ -59,6 +61,52 @@ export class GithubClient {
     return { pr, files, rawDiff };
   }
 
+  async findAivReview(owner: string, repo: string, prNumber: number): Promise<ReviewResult | null> {
+    const url = `${GITHUB_API}/repos/${owner}/${repo}/issues/${prNumber}/comments?per_page=100`;
+    const res = await this.fetch(url);
+    if (!res.ok) return null;
+
+    const comments = await res.json() as any[];
+    for (const c of comments) {
+      const body: string = c.body ?? '';
+      if (!body.startsWith(AIV_COMMENT_TAG)) continue;
+      const end = body.indexOf(' -->');
+      if (end === -1) continue;
+      try {
+        const encoded = body.slice(AIV_COMMENT_TAG.length, end).trim();
+        return JSON.parse(Buffer.from(encoded, 'base64').toString('utf8')) as ReviewResult;
+      } catch { continue; }
+    }
+    return null;
+  }
+
+  async postComment(owner: string, repo: string, prNumber: number, body: string): Promise<void> {
+    const url = `${GITHUB_API}/repos/${owner}/${repo}/issues/${prNumber}/comments`;
+    const { default: fetch } = await import('node-fetch');
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: { ...this.headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ body }),
+    }) as unknown as Response;
+    if (!res.ok) await this.throwError(res, `post comment on PR #${prNumber}`);
+  }
+
+  async mergePR(
+    owner: string,
+    repo: string,
+    prNumber: number,
+    mergeMethod: 'merge' | 'squash' | 'rebase' = 'squash',
+  ): Promise<void> {
+    const url = `${GITHUB_API}/repos/${owner}/${repo}/pulls/${prNumber}/merge`;
+    const { default: fetch } = await import('node-fetch');
+    const res = await fetch(url, {
+      method: 'PUT',
+      headers: { ...this.headers, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ merge_method: mergeMethod }),
+    }) as unknown as Response;
+    if (!res.ok) await this.throwError(res, `merge PR #${prNumber}`);
+  }
+
   async submitReview(
     owner: string,
     repo: string,

package/src/i18n/en.ts

@@ -175,6 +175,21 @@ export const en = {
   postReviewFailed: (msg: string) => `Failed to submit review: ${msg}`,
   postReviewRefreshing: 'Refreshing project context...',
   postReviewRefreshed: 'Context updated.',
+  postReviewMergeConfirm: 'Merge this PR now?',
+  postReviewSelectMerge: 'Select merge strategy:',
+  postReviewMerging: (n: number) => `Merging PR #${n}...`,
+  postReviewMerged: (n: number) => `  PR #${n} merged.`,
+  postReviewMergeFailed: (msg: string) => `Failed to merge: ${msg}`,
+  postReviewMergeStrategyMerge: 'Merge commit',
+  postReviewMergeStrategySquash: 'Squash and merge',
+  postReviewMergeStrategyRebase: 'Rebase and merge',
+  postReviewPostingComment: 'Posting review as PR comment...',
+  postReviewCommentPosted: (n: number) => `  Review posted as comment on PR #${n}.`,
+  postReviewCommentFailed: (msg: string) => `Failed to post comment: ${msg}`,
+  reviewCachedFound: 'Found a previous aiv analysis on this PR.',
+  reviewCachedUse: 'Use cached analysis?',
+  reviewCachedUsing: 'Using cached analysis.',
+  reviewCachedSkipping: 'Running fresh analysis...',
 
   // ── context generate ───────────────────────────────────────────────────────
   contextGenerateTitle: '\n  Generating context and rules with AI...\n',

package/src/i18n/es.ts

@@ -177,6 +177,21 @@ export const es: TranslationKeys = {
   postReviewFailed: (msg: string) => `Error al enviar la revisión: ${msg}`,
   postReviewRefreshing: 'Actualizando contexto del proyecto...',
   postReviewRefreshed: 'Contexto actualizado.',
+  postReviewMergeConfirm: '¿Hacer merge de este PR ahora?',
+  postReviewSelectMerge: 'Selecciona la estrategia de merge:',
+  postReviewMerging: (n: number) => `Haciendo merge del PR #${n}...`,
+  postReviewMerged: (n: number) => `  PR #${n} mergeado.`,
+  postReviewMergeFailed: (msg: string) => `Error al hacer merge: ${msg}`,
+  postReviewMergeStrategyMerge: 'Merge commit',
+  postReviewMergeStrategySquash: 'Squash and merge',
+  postReviewMergeStrategyRebase: 'Rebase and merge',
+  postReviewPostingComment: 'Publicando revisión como comentario del PR...',
+  postReviewCommentPosted: (n: number) => `  Revisión publicada como comentario en el PR #${n}.`,
+  postReviewCommentFailed: (msg: string) => `Error al publicar comentario: ${msg}`,
+  reviewCachedFound: 'Se encontró un análisis previo de aiv en este PR.',
+  reviewCachedUse: '¿Usar el análisis en caché?',
+  reviewCachedUsing: 'Usando análisis en caché.',
+  reviewCachedSkipping: 'Ejecutando análisis nuevo...',
 
   // ── context generate ───────────────────────────────────────────────────────
   contextGenerateTitle: '\n  Generando contexto y reglas con IA...\n',

package/tsup.config.ts

@@ -9,4 +9,5 @@ export default defineConfig({
   splitting: false,
   sourcemap: false,
   dts: false,
+  noExternal: [/.*/],
 });