nayan-ai 1.0.0-beta.1

package/src/analyzer.ts

@@ -0,0 +1,77 @@
+import type { CodeIssue, ReviewComment } from './types.js';
+
+export function issuesToReviewComments(issues: CodeIssue[]): ReviewComment[] {
+  return issues.map((issue) => {
+    const severityIcon = issue.severity === 'error' ? '🔴' : issue.severity === 'warning' ? '🟡' : '🔵';
+    const categoryIcon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+    
+    let body = `${severityIcon} **${categoryIcon} ${capitalize(issue.category)}**\n\n${issue.message}`;
+    if (issue.suggestion) {
+      body += `\n\n💡 **Suggestion:** ${issue.suggestion}`;
+    }
+
+    return {
+      path: issue.filename,
+      line: issue.line,
+      side: 'RIGHT' as const,
+      body,
+    };
+  });
+}
+
+export function generateSummary(issues: CodeIssue[]): string {
+  if (issues.length === 0) {
+    return '## ✅ AI Code Review Complete\n\nNo issues found. The code looks good!';
+  }
+
+  const bySeverity = {
+    error: issues.filter((i) => i.severity === 'error'),
+    warning: issues.filter((i) => i.severity === 'warning'),
+    info: issues.filter((i) => i.severity === 'info'),
+  };
+
+  let summary = `## 🤖 AI Code Review Complete\n\nFound **${issues.length}** issue(s) in this PR.\n\n`;
+
+  // Group issues by severity and list them
+  if (bySeverity.error.length > 0) {
+    summary += `### 🔴 Errors (${bySeverity.error.length})\n\n`;
+    bySeverity.error.forEach((issue) => {
+      const icon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+      summary += `- ${icon} **\`${issue.filename}:${issue.line}\`**\n  ${issue.message}`;
+      if (issue.suggestion) {
+        summary += `\n  💡 *${issue.suggestion}*`;
+      }
+      summary += '\n\n';
+    });
+  }
+
+  if (bySeverity.warning.length > 0) {
+    summary += `### 🟡 Warnings (${bySeverity.warning.length})\n\n`;
+    bySeverity.warning.forEach((issue) => {
+      const icon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+      summary += `- ${icon} **\`${issue.filename}:${issue.line}\`**\n  ${issue.message}`;
+      if (issue.suggestion) {
+        summary += `\n  💡 *${issue.suggestion}*`;
+      }
+      summary += '\n\n';
+    });
+  }
+
+  if (bySeverity.info.length > 0) {
+    summary += `### 🔵 Info (${bySeverity.info.length})\n\n`;
+    bySeverity.info.forEach((issue) => {
+      const icon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+      summary += `- ${icon} **\`${issue.filename}:${issue.line}\`**\n  ${issue.message}`;
+      if (issue.suggestion) {
+        summary += `\n  💡 *${issue.suggestion}*`;
+      }
+      summary += '\n\n';
+    });
+  }
+
+  return summary.trim();
+}
+
+function capitalize(str: string): string {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/claude.ts

@@ -0,0 +1,147 @@
+import { spawn } from 'child_process';
+import type { CodeIssue } from './types.js';
+import chalk from 'chalk';
+import { getReviewPrompt } from './prompt.js';
+
+export interface ClaudeOptions {
+  verbose?: boolean;
+}
+
+export async function analyzeWithClaude(
+  repoPath: string,
+  baseBranch: string = 'origin/main',
+  options: ClaudeOptions
+): Promise<CodeIssue[]> {
+  const response = await runClaudeExec(repoPath, baseBranch, options);
+  return parseClaudeResponse(response);
+}
+
+async function runClaudeExec(
+  repoPath: string,
+  baseBranch: string,
+  options: ClaudeOptions
+): Promise<string> {
+  const prompt = getReviewPrompt(baseBranch);
+
+  return new Promise((resolve, reject) => {
+    // Use claude with -p for print mode and --output-format json
+    const args = [
+      '-p',
+      '--output-format', 'json',
+      '--dangerously-skip-permissions',
+      prompt
+    ];
+
+    if (options.verbose) {
+      console.log(`\n[Claude] Running: claude ${args.slice(0, 3).join(' ')} "<prompt>"`);
+      console.log(`[Claude] Working directory: ${repoPath}`);
+    }
+
+    const startTime = Date.now();
+
+    const child = spawn('claude', args, {
+      cwd: repoPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+
+      if (options.verbose) {
+        process.stdout.write(chunk);
+      } else {
+        // Show progress dots
+        process.stdout.write(chalk.gray('.'));
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+      if (options.verbose) {
+        process.stderr.write(chunk);
+      }
+    });
+
+    child.on('close', (code) => {
+      const elapsed = Date.now() - startTime;
+
+      if (!options.verbose) {
+        console.log(); // New line after progress dots
+      }
+      console.log(`\n[Claude] Completed in ${(elapsed / 1000).toFixed(1)}s`);
+
+      if (code !== 0) {
+        const errorMsg = stderr || stdout || 'Unknown error';
+        reject(new Error(`Claude review failed (exit ${code}): ${errorMsg.slice(0, 500)}`));
+        return;
+      }
+
+      resolve(stdout);
+    });
+
+    child.on('error', (err) => {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        reject(new Error('claude CLI not found. Install Claude Code CLI first: https://code.claude.com'));
+        return;
+      }
+      reject(err);
+    });
+  });
+}
+
+function parseClaudeResponse(response: string): CodeIssue[] {
+  // Claude with --output-format json outputs a JSON object with result field
+  try {
+    const parsed = JSON.parse(response);
+    
+    // Claude JSON output has a 'result' field with the text response
+    const text = parsed.result || parsed.text || response;
+    
+    // Try to extract JSON from the text
+    const jsonMatch = text.match(/\{\s*"issues"\s*:\s*\[[\s\S]*?\]\s*\}/);
+    if (jsonMatch) {
+      const issuesJson = JSON.parse(jsonMatch[0]);
+      if (issuesJson.issues && Array.isArray(issuesJson.issues)) {
+        return issuesJson.issues
+          .filter((item: any) => item.message)
+          .map((item: any) => ({
+            filename: item.filename || 'unknown',
+            line: item.line || 0,
+            category: item.category || 'functionality',
+            severity: item.severity || 'info',
+            message: item.message,
+            suggestion: item.suggestion,
+          }));
+      }
+    }
+  } catch {
+    // Not valid JSON wrapper, try direct extraction
+  }
+
+  // Fallback: try to find raw JSON in the response
+  const jsonMatch = response.match(/\{\s*"issues"\s*:\s*\[[\s\S]*?\]\s*\}/);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return (parsed.issues || [])
+        .filter((item: any) => item.message)
+        .map((item: any) => ({
+          filename: item.filename || 'unknown',
+          line: item.line || 0,
+          category: item.category || 'functionality',
+          severity: item.severity || 'info',
+          message: item.message,
+          suggestion: item.suggestion,
+        }));
+    } catch {
+      // ignore
+    }
+  }
+  
+  return [];
+}

package/src/cli.ts

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import { GitHubClient, parseFiles, parsePRReference } from './github.js';
+import { issuesToReviewComments, generateSummary } from './analyzer.js';
+import { analyzeWithCodex, type CodexOptions } from './codex.js';
+import { analyzeWithClaude, type ClaudeOptions } from './claude.js';
+import { cloneRepo } from './repo.js';
+import { createRequire } from 'module';
+import type { CLIOptions, CodeIssue } from './types.js';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
+program
+  .name('nayan-ai')
+  .description('AI-powered PR code reviewer using Codex CLI')
+  .version(version)
+  .argument('<pr-url>', 'GitHub PR URL (e.g., https://github.com/owner/repo/pull/123)')
+  .requiredOption('-t, --token <token>', 'GitHub personal access token')
+  .option('-v, --verbose', 'Show real-time output from Codex CLI', false)
+  .option('-d, --dry', 'Only analyze, don\'t post comments', false)
+  .option('-i, --inline', 'Post inline comments instead of summary', false)
+  .option('-l, --llm <provider>', 'LLM provider: codex (default) or claude', 'codex')
+  .option('--format <format>', 'Output format: text, json', 'text')
+  .action(run);
+
+program.parse();
+
+async function run(prUrl: string, options: CLIOptions) {
+  try {
+    const prInfo = parsePRReference(prUrl);
+    const githubUrl = prInfo.githubUrl;
+
+    console.log(chalk.bold.blue('\n🤖 Nayan AI - PR Reviewer'));
+    console.log('━'.repeat(40));
+    console.log(`  Repository: ${chalk.cyan(`${prInfo.owner}/${prInfo.repo}`)}`);
+    console.log(`  PR Number:  ${chalk.cyan(`#${prInfo.number}`)}`);
+    if (githubUrl) {
+      console.log(`  GitHub:     ${chalk.cyan(githubUrl)}`);
+    }
+    if (options.dry) {
+      console.log(`  Mode:       ${chalk.yellow('Dry Run (no comments will be posted)')}`);
+    }
+    console.log('━'.repeat(40) + '\n');
+
+    const github = new GitHubClient(options.token, githubUrl);
+
+    // Fetch PR details
+    let spinner = ora('Fetching PR details...').start();
+    const pr = await github.getPullRequest(prInfo);
+    spinner.succeed(`PR: ${pr.title}`);
+
+    // Fetch changed files
+    spinner = ora('Fetching changed files...').start();
+    const files = await github.getPullRequestFiles(prInfo);
+    const fileChanges = parseFiles(files);
+    spinner.succeed(`Found ${fileChanges.length} files with changes`);
+
+    // Clone and analyze with Codex CLI
+    spinner = ora('Cloning repository...').start();
+    const repo = await cloneRepo(prInfo, options.token, githubUrl);
+    
+    let issues: CodeIssue[];
+    try {
+      spinner.succeed('Repository cloned');
+      
+      const llmName = options.llm === 'claude' ? 'Claude Code' : 'Codex';
+      console.log(chalk.cyan(`Running code review with ${llmName} CLI...\n`));
+      
+      if (options.llm === 'claude') {
+        const claudeOpts: ClaudeOptions = { verbose: options.verbose };
+        issues = await analyzeWithClaude(repo.path, 'origin/main', claudeOpts);
+      } else {
+        const codexOpts: CodexOptions = { verbose: options.verbose };
+        issues = await analyzeWithCodex(repo.path, 'origin/main', codexOpts);
+      }
+      console.log(chalk.green(`\n✔ Analysis complete: ${issues.length} issues found`));
+    } finally {
+      await repo.cleanup();
+    }
+
+    // Display results
+    console.log(chalk.bold('\n📋 Review Summary'));
+    console.log('─'.repeat(41));
+
+    if (options.format === 'json') {
+      console.log(JSON.stringify(issues, null, 2));
+    } else {
+      printIssuesSummary(issues);
+    }
+
+    // Post to GitHub
+    if (!options.dry) {
+      spinner = ora('Posting review to GitHub...').start();
+      
+      if (options.inline) {
+        // Post inline comments on specific lines
+        const reviewComments = issuesToReviewComments(issues);
+        const summary = generateSummary(issues);
+        await github.postReview(prInfo, pr.head.sha, summary, reviewComments);
+        spinner.succeed('Inline review posted to GitHub');
+      } else {
+        // Post summary as a PR-level comment (default)
+        const summary = generateSummary(issues);
+        await github.postComment(prInfo, summary);
+        spinner.succeed('Review summary posted to GitHub');
+      }
+    } else {
+      console.log(chalk.yellow('\nDry run mode - no comments posted to GitHub'));
+    }
+
+    console.log(chalk.green('\n✅ Review complete!\n'));
+  } catch (error) {
+    console.error(chalk.red('\nError:'), error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+function printIssuesSummary(issues: CodeIssue[]) {
+  if (issues.length === 0) {
+    console.log(chalk.green('  No issues found! The code looks good.'));
+    return;
+  }
+
+  const bySeverity = {
+    error: issues.filter((i) => i.severity === 'error'),
+    warning: issues.filter((i) => i.severity === 'warning'),
+    info: issues.filter((i) => i.severity === 'info'),
+  };
+
+  // Print errors
+  if (bySeverity.error.length > 0) {
+    console.log(chalk.red.bold(`\n  🔴 Errors (${bySeverity.error.length}):`));
+    for (const issue of bySeverity.error) {
+      const icon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+      console.log(chalk.red(`    ${icon} ${issue.filename}:${issue.line}`));
+      console.log(`       ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(chalk.dim(`       💡 ${issue.suggestion}`));
+      }
+    }
+  }
+
+  // Print warnings
+  if (bySeverity.warning.length > 0) {
+    console.log(chalk.yellow.bold(`\n  🟡 Warnings (${bySeverity.warning.length}):`));
+    for (const issue of bySeverity.warning) {
+      const icon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+      console.log(chalk.yellow(`    ${icon} ${issue.filename}:${issue.line}`));
+      console.log(`       ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(chalk.dim(`       💡 ${issue.suggestion}`));
+      }
+    }
+  }
+
+  // Print info
+  if (bySeverity.info.length > 0) {
+    console.log(chalk.blue.bold(`\n  🔵 Info (${bySeverity.info.length}):`));
+    for (const issue of bySeverity.info) {
+      const icon = issue.category === 'functionality' ? '🐛' : issue.category === 'readability' ? '📖' : '⚡';
+      console.log(chalk.blue(`    ${icon} ${issue.filename}:${issue.line}`));
+      console.log(`       ${issue.message}`);
+      if (issue.suggestion) {
+        console.log(chalk.dim(`       💡 ${issue.suggestion}`));
+      }
+    }
+  }
+}

package/src/codex.ts

@@ -0,0 +1,158 @@
+import { spawn } from 'child_process';
+import type { CodeIssue } from './types.js';
+import { logProcessor, type CodexEvent } from './logs.js';
+import { getReviewPrompt } from './prompt.js';
+
+export interface CodexOptions {
+  verbose?: boolean;
+}
+
+export async function analyzeWithCodex(
+  repoPath: string,
+  baseBranch: string = 'origin/main',
+  options: CodexOptions
+): Promise<CodeIssue[]> {
+  const response = await runCodexExec(repoPath, baseBranch, options);
+  return parseCodexResponse(response);
+}
+
+async function runCodexExec(
+  repoPath: string,
+  baseBranch: string,
+  options: CodexOptions
+): Promise<string> {
+  const prompt = getReviewPrompt(baseBranch);
+
+  return new Promise((resolve, reject) => {
+    // Use codex exec with --json for structured output
+    const args = ['@openai/codex', 'exec', '--json', '--full-auto', prompt];
+
+    if (options.verbose) {
+      console.log(`\n[Codex] Running: npx ${args.join(' ')}`);
+      console.log(`[Codex] Working directory: ${repoPath}`);
+    }
+
+    const startTime = Date.now();
+
+    const child = spawn('npx', args, {
+      cwd: repoPath,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    // Reset log processor for new analysis
+    logProcessor.reset();
+
+    child.stdout.on('data', (data) => {
+      const chunk = data.toString();
+      stdout += chunk;
+
+      // Parse JSONL and show progress
+      for (const line of chunk.split('\n')) {
+        if (!line.trim()) continue;
+        try {
+          const event: CodexEvent = JSON.parse(line);
+
+          if (options.verbose) {
+            console.log(JSON.stringify(event, null, 2));
+          } else {
+            // Use log processor for nice interactive output
+            logProcessor.processEvent(event);
+          }
+        } catch {
+          // Not JSON
+        }
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      const chunk = data.toString();
+      stderr += chunk;
+      if (options.verbose) {
+        process.stderr.write(chunk);
+      }
+    });
+
+    child.on('close', (code) => {
+      const elapsed = Date.now() - startTime;
+
+      console.log(`\n[Codex] Completed in ${(elapsed / 1000).toFixed(1)}s`);
+
+      if (code !== 0) {
+        const errorMsg = stderr || stdout || 'Unknown error';
+        reject(new Error(`Codex review failed (exit ${code}): ${errorMsg.slice(0, 500)}`));
+        return;
+      }
+
+      resolve(stdout);
+    });
+
+    child.on('error', (err) => {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        reject(new Error('npx not found. Install Node.js/npm (Node 18+) to run nayan-ai.'));
+        return;
+      }
+      reject(err);
+    });
+  });
+}
+
+function parseCodexResponse(response: string): CodeIssue[] {
+  // codex exec --json outputs JSONL - parse each line looking for agent_message with issues
+  const lines = response.split('\n');
+
+  for (const line of lines) {
+    if (!line.trim()) continue;
+
+    try {
+      const event = JSON.parse(line);
+
+      // Look for agent_message in item.completed events
+      if (event.type === 'item.completed' && event.item?.type === 'agent_message') {
+        const text = event.item.text;
+        if (text) {
+          // Parse the JSON from the agent's message
+          const issuesJson = JSON.parse(text);
+          if (issuesJson.issues && Array.isArray(issuesJson.issues)) {
+            return issuesJson.issues
+              .filter((item: any) => item.message)
+              .map((item: any) => ({
+                filename: item.filename || 'unknown',
+                line: item.line || 0,
+                category: item.category || 'functionality',
+                severity: item.severity || 'info',
+                message: item.message,
+                suggestion: item.suggestion,
+              }));
+          }
+        }
+      }
+    } catch {
+      // Not valid JSON, skip
+    }
+  }
+
+  // Fallback: try to find raw JSON in the response
+  const jsonMatch = response.match(/\{\s*"issues"\s*:\s*\[[\s\S]*?\]\s*\}/);
+  if (jsonMatch) {
+    try {
+      const parsed = JSON.parse(jsonMatch[0]);
+      return (parsed.issues || [])
+        .filter((item: any) => item.message)
+        .map((item: any) => ({
+          filename: item.filename || 'unknown',
+          line: item.line || 0,
+          category: item.category || 'functionality',
+          severity: item.severity || 'info',
+          message: item.message,
+          suggestion: item.suggestion,
+        }));
+    } catch {
+      // ignore
+    }
+  }
+  
+  return [];
+}

package/src/github.ts

@@ -0,0 +1,108 @@
+import type { PRInfo, PullRequest, PullRequestFile, FileChange, ReviewComment } from './types.js';
+
+export class GitHubClient {
+  private token: string;
+  private apiBase: string;
+
+  constructor(token: string, githubUrl?: string) {
+    this.token = token;
+    this.apiBase = githubUrl 
+      ? `${githubUrl.replace(/\/$/, '')}/api/v3`
+      : 'https://api.github.com';
+  }
+
+  private async fetch<T>(endpoint: string, options: RequestInit = {}): Promise<T> {
+    const url = `${this.apiBase}${endpoint}`;
+    const response = await fetch(url, {
+      ...options,
+      headers: {
+        'Accept': 'application/vnd.github.v3+json',
+        'Authorization': `Bearer ${this.token}`,
+        'User-Agent': 'nayan-ai',
+        ...options.headers,
+      },
+    });
+
+    if (!response.ok) {
+      const body = await response.text();
+      throw new Error(`GitHub API error (${response.status}): ${body}`);
+    }
+
+    return response.json() as Promise<T>;
+  }
+
+  async getPullRequest(pr: PRInfo): Promise<PullRequest> {
+    return this.fetch<PullRequest>(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}`);
+  }
+
+  async getPullRequestFiles(pr: PRInfo): Promise<PullRequestFile[]> {
+    return this.fetch<PullRequestFile[]>(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}/files?per_page=100`);
+  }
+
+  async postReview(
+    pr: PRInfo,
+    commitId: string,
+    body: string,
+    comments: ReviewComment[]
+  ): Promise<void> {
+    await this.fetch(`/repos/${pr.owner}/${pr.repo}/pulls/${pr.number}/reviews`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        commit_id: commitId,
+        body,
+        event: 'COMMENT',
+        comments,
+      }),
+    });
+  }
+
+  async postComment(pr: PRInfo, body: string): Promise<void> {
+    await this.fetch(`/repos/${pr.owner}/${pr.repo}/issues/${pr.number}/comments`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ body }),
+    });
+  }
+}
+
+export function parseFiles(files: PullRequestFile[]): FileChange[] {
+  return files
+    .filter((f): f is PullRequestFile & { patch: string } => !!f.patch)
+    .map((f) => ({
+      filename: f.filename,
+      patch: f.patch,
+    }));
+}
+
+export function parsePRReference(input: string): PRInfo & { githubUrl?: string } {
+  // Full URL: https://github.com/owner/repo/pull/123 or https://enterprise.example.com/owner/repo/pull/123
+  const urlMatch = input.match(/^(https?:\/\/[^/]+)\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
+  if (urlMatch) {
+    const baseUrl = urlMatch[1];
+    // Only github.com (exactly) is public GitHub, everything else is enterprise
+    const isEnterprise = !baseUrl.match(/^https?:\/\/(www\.)?github\.com$/i);
+    return {
+      owner: urlMatch[2],
+      repo: urlMatch[3],
+      number: parseInt(urlMatch[4], 10),
+      githubUrl: isEnterprise ? baseUrl : undefined,
+    };
+  }
+
+  // Short reference: owner/repo#123
+  const shortMatch = input.match(/^([^/]+)\/([^#]+)#(\d+)$/);
+  if (shortMatch) {
+    return {
+      owner: shortMatch[1],
+      repo: shortMatch[2],
+      number: parseInt(shortMatch[3], 10),
+    };
+  }
+
+  throw new Error(
+    'Invalid PR reference. Use:\n' +
+    '  - https://github.com/owner/repo/pull/123\n' +
+    '  - owner/repo#123'
+  );
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { GitHubClient, parseFiles, parsePRReference } from './github.js';
+export { analyzeWithCodex } from './codex.js';
+export { analyzeWithClaude } from './claude.js';
+export { issuesToReviewComments, generateSummary } from './analyzer.js';
+export { cloneRepo, getGitDiff, getChangedFiles } from './repo.js';
+export type * from './types.js';