prsmith 1.1.0 → 2.1.0

package/src/ai.js

@@ -0,0 +1,118 @@
+import chalk from 'chalk';
+
+/**
+ * Polishes the provided text to be polite, constructive, and professional.
+ * Supports Gemini, OpenAI, and Groq.
+ *
+ * @param {string} text The raw text to polish (Problem or Suggested Fix)
+ * @param {string} fieldName Either "Problem Description" or "Suggested Fix" for prompt context
+ * @param {object} config Local user configuration from .prsmith.json
+ * @returns {Promise<string>} The polished text, or the original text on failure/missing keys.
+ */
+export async function polishText(text, fieldName, config = {}) {
+  if (!text || text.trim() === '') return text;
+
+  // Retrieve credentials from config or environment variables
+  const provider = (
+    config.aiProvider ||
+    process.env.AI_PROVIDER ||
+    'gemini'
+  ).toLowerCase();
+  let apiKey = config.aiApiKey || '';
+  let model = config.aiModel || '';
+
+  if (provider === 'gemini') {
+    apiKey = apiKey || process.env.GEMINI_API_KEY || '';
+    model = model || process.env.GEMINI_MODEL || 'gemini-1.5-flash';
+  } else if (provider === 'openai') {
+    apiKey = apiKey || process.env.OPENAI_API_KEY || '';
+    model = model || process.env.OPENAI_MODEL || 'gpt-4o-mini';
+  } else if (provider === 'groq') {
+    apiKey = apiKey || process.env.GROQ_API_KEY || '';
+    model = model || process.env.GROQ_MODEL || 'llama-3.3-70b-versatile';
+  } else {
+    console.warn(
+      chalk.yellow(
+        `\n⚠️ Unknown AI provider '${provider}'. Falling back to raw text.`
+      )
+    );
+    return text;
+  }
+
+  if (!apiKey) {
+    console.warn(
+      chalk.yellow(
+        `\n⚠️ No API key found for '${provider}'. Set 'aiApiKey' in .prsmith.json or the corresponding env variable (${provider.toUpperCase()}_API_KEY) to enable AI polishing.`
+      )
+    );
+    return text;
+  }
+
+  const prompt = `You are an expert senior software engineer and empathetic mentor.
+Translate the following code review comment field (${fieldName}) into a highly polite, constructive, professional, and empathetic tone, while retaining all technical correctness and details.
+Avoid sounding accusatory, patronizing, or overly verbose. Keep the polished output in standard markdown format, directly and only providing the polished content. Do not add introductory or concluding remarks.
+
+Original content to polish:
+${text}`;
+
+  try {
+    if (provider === 'gemini') {
+      const url = `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`;
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          contents: [{ parts: [{ text: prompt }] }],
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `Gemini API error: ${response.statusText} (${errorText})`
+        );
+      }
+
+      const data = await response.json();
+      const resultText = data.candidates?.[0]?.content?.parts?.[0]?.text;
+      if (resultText) return resultText.trim();
+    } else if (provider === 'openai' || provider === 'groq') {
+      const url =
+        provider === 'openai'
+          ? 'https://api.openai.com/v1/chat/completions'
+          : 'https://api.groq.com/openai/v1/chat/completions';
+
+      const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: model,
+          messages: [{ role: 'user', content: prompt }],
+          temperature: 0.2,
+        }),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(
+          `${provider.toUpperCase()} API error: ${response.statusText} (${errorText})`
+        );
+      }
+
+      const data = await response.json();
+      const resultText = data.choices?.[0]?.message?.content;
+      if (resultText) return resultText.trim();
+    }
+  } catch (error) {
+    console.warn(
+      chalk.yellow(
+        `\n⚠️ AI Polishing failed: ${error.message}. Falling back to raw text.`
+      )
+    );
+  }
+
+  return text;
+}

package/src/batch.js

@@ -0,0 +1,219 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import clipboardy from 'clipboardy';
+import fs from 'fs';
+import path from 'path';
+import { getReviewData } from './prompts.js';
+import { generateMarkdown } from './formatter.js';
+import { polishText } from './ai.js';
+import { detectGithubRepo, submitPRReview } from './github.js';
+
+/**
+ * Runs the interactive Batch Review Mode.
+ *
+ * @param {object} options CLI parsed options
+ * @param {object} config Local configurations
+ */
+export async function runBatchReview(config = {}) {
+  console.log(chalk.cyan('\n🚀 PRSmith - Starting Batch Review Mode\n'));
+
+  const comments = [];
+  let addMore = true;
+  let counter = 1;
+
+  while (addMore) {
+    console.log(chalk.blue.bold(`\n📝 Comment #${counter}:`));
+
+    // Get comment data interactively
+    // We pass empty options to ensure it prompts for everything
+    const data = await getReviewData({}, config);
+
+    // Apply AI polish if requested
+    if (data.ai) {
+      console.log(chalk.yellow('\n✨ Polishing with AI...'));
+      data.issue = await polishText(data.issue, 'Problem Description', config);
+      data.fix = await polishText(data.fix, 'Suggested Fix', config);
+    }
+
+    // Generate markdown for this individual comment
+    const commentMarkdown = generateMarkdown(data, config);
+
+    // Store in our review list
+    comments.push({
+      path: data.path || null,
+      line: data.line || null,
+      body: commentMarkdown,
+      title: data.title,
+      severity: data.severity,
+    });
+
+    console.log(chalk.green(`\n✅ Comment #${counter} added to batch!`));
+
+    const response = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'more',
+        message: 'Would you like to add another comment to this review batch?',
+        default: false,
+      },
+    ]);
+
+    addMore = response.more;
+    counter++;
+  }
+
+  // Generate unified review markdown
+  const unifiedMarkdown = generateUnifiedReport(comments);
+
+  console.log(chalk.cyan.bold('\n📦 Batch Review Compilation Successful!'));
+  console.log(chalk.gray(`Total Comments: ${comments.length}\n`));
+
+  // Options menu for export
+  let menuActive = true;
+  while (menuActive) {
+    const { action } = await inquirer.prompt([
+      {
+        type: 'select',
+        name: 'action',
+        message: 'What would you like to do with this batch review?',
+        choices: [
+          '📋 Copy entire review to clipboard',
+          '💾 Save review to a markdown file',
+          '🚀 Post review directly to a GitHub Pull Request',
+          '❌ Exit Batch Review Mode',
+        ],
+      },
+    ]);
+
+    if (action.includes('Copy')) {
+      try {
+        clipboardy.writeSync(unifiedMarkdown);
+        console.log(
+          chalk.green('\n✅ Full review successfully copied to clipboard!\n')
+        );
+      } catch (err) {
+        console.error(chalk.red(`Failed to copy to clipboard: ${err.message}`));
+      }
+    } else if (action.includes('Save')) {
+      const { outFile } = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'outFile',
+          message: 'Enter the file name to save (e.g. pr-review.md):',
+          default: 'pr-review.md',
+        },
+      ]);
+      try {
+        const outPath = path.resolve(process.cwd(), outFile);
+        fs.writeFileSync(outPath, unifiedMarkdown, 'utf8');
+        console.log(
+          chalk.green(`\n✅ Review successfully saved to ${outPath}\n`)
+        );
+      } catch (err) {
+        console.error(chalk.red(`Failed to write file: ${err.message}`));
+      }
+    } else if (action.includes('Post')) {
+      const token = config.githubToken || process.env.GITHUB_TOKEN;
+      if (!token) {
+        console.log(
+          chalk.red('\n❌ Error: GitHub Personal Access Token not found!')
+        );
+        console.log(
+          chalk.yellow(
+            "Please configure 'githubToken' in your local ~/.prsmith.json file or set the GITHUB_TOKEN environment variable.\n"
+          )
+        );
+        continue;
+      }
+
+      const repo = config.githubRepo || detectGithubRepo();
+      const defaultOwner = repo ? repo.owner : '';
+      const defaultRepo = repo ? repo.repo : '';
+
+      const prDetails = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'owner',
+          message: 'GitHub Repository Owner:',
+          default: defaultOwner,
+          validate: (val) => val.trim() !== '' || 'Owner is required.',
+        },
+        {
+          type: 'input',
+          name: 'repoName',
+          message: 'GitHub Repository Name:',
+          default: defaultRepo,
+          validate: (val) =>
+            val.trim() !== '' || 'Repository name is required.',
+        },
+        {
+          type: 'input',
+          name: 'prNumber',
+          message: 'Pull Request Number:',
+          validate: (val) =>
+            /^\d+$/.test(val.trim()) || 'PR Number must be a valid integer.',
+        },
+      ]);
+
+      console.log(chalk.yellow('\n🚀 Submitting review comments to GitHub...'));
+      try {
+        // Construct the review body listing general comments (those without path/line)
+        const generalComments = comments.filter((c) => !c.path || !c.line);
+        let reviewBody = '### 🛠️ PRSmith Unified Code Review Session\n\n';
+
+        if (generalComments.length > 0) {
+          reviewBody += '#### General Comments:\n\n';
+          generalComments.forEach((c) => {
+            reviewBody += `---\n\n${c.body}\n`;
+          });
+        } else {
+          reviewBody +=
+            'All review comments have been applied inline to their respective lines. Check the files list below!';
+        }
+
+        const inlineComments = comments.filter((c) => c.path && c.line);
+
+        const url = await submitPRReview(
+          prDetails.owner,
+          prDetails.repoName,
+          prDetails.prNumber,
+          reviewBody,
+          inlineComments,
+          config
+        );
+
+        console.log(
+          chalk.green(`\n🎉 Native Pull Request Review successfully submitted!`)
+        );
+        console.log(chalk.green(`🔗 Review link: ${url}\n`));
+      } catch (err) {
+        console.error(
+          chalk.red(`\n❌ Failed to submit PR Review: ${err.message}\n`)
+        );
+      }
+    } else {
+      menuActive = false;
+      console.log(chalk.yellow('\nExiting Batch Review Mode. Bye!\n'));
+    }
+  }
+}
+
+/**
+ * Combines all individual review comments into a single unified markdown report.
+ *
+ * @param {Array<object>} comments The compiled list of comments
+ * @returns {string} The unified markdown text
+ */
+function generateUnifiedReport(comments) {
+  let report = `# PRSmith Unified Code Review Report\n\n`;
+  report += `This review contains **${comments.length}** compiled review comment${comments.length > 1 ? 's' : ''}.\n\n`;
+
+  comments.forEach((c, idx) => {
+    report += `## Comment #${idx + 1}\n\n`;
+    report += c.body;
+    report += `\n---\n\n`;
+  });
+
+  report += `*Generated automatically with [PRSmith](https://github.com/tarunyaprogrammer/PRSmith).*`;
+  return report;
+}

package/src/config.js

@@ -5,7 +5,7 @@ import os from 'os';
 export function loadConfig() {
   const configPaths = [
     path.join(os.homedir(), '.prsmith.json'),
-    path.join(process.cwd(), '.prsmith.json')
+    path.join(process.cwd(), '.prsmith.json'),
   ];
 
   let mergedConfig = { templates: {} };
@@ -15,14 +15,43 @@ export function loadConfig() {
       try {
         const fileContent = fs.readFileSync(configPath, 'utf-8');
         const parsed = JSON.parse(fileContent);
+
         if (parsed.templates) {
-          mergedConfig.templates = { ...mergedConfig.templates, ...parsed.templates };
+          mergedConfig.templates = {
+            ...mergedConfig.templates,
+            ...parsed.templates,
+          };
+        }
+
+        if (parsed.editor) {
+          mergedConfig.editor = parsed.editor;
         }
+
+        // Also merge any other config properties (tokens, providers, etc.)
+        Object.keys(parsed).forEach((key) => {
+          if (key !== 'templates') {
+            mergedConfig[key] = parsed[key];
+          }
+        });
       } catch (err) {
-        console.warn(`Warning: Could not parse config at ${configPath} - ${err.message}`);
+        console.warn(
+          `Warning: Could not parse config at ${configPath} - ${err.message}`
+        );
       }
     }
   }
 
+  // Senior Guardrail: Prevent the general public from getting stuck in Vim (no instructions)
+  // If the user has not set EDITOR/VISUAL globally, and did not set 'editor' in .prsmith.json,
+  // we default the spawned editor in our process to 'nano' on macOS/Linux.
+  // 'nano' has friendly, visible exit instructions at the bottom of the terminal by default!
+  if (mergedConfig.editor) {
+    process.env.EDITOR = mergedConfig.editor;
+  } else if (!process.env.EDITOR && !process.env.VISUAL) {
+    if (process.platform !== 'win32') {
+      process.env.EDITOR = 'nano';
+    }
+  }
+
   return mergedConfig;
 }

package/src/formatter.js

@@ -1,21 +1,52 @@
-import { templates as defaultTemplates } from "./templates.js";
+import { templates as defaultTemplates } from './templates.js';
+import { detectGithubRepo } from './github.js';
 
 export function generateMarkdown(data, config = {}) {
   const mergedTemplates = { ...defaultTemplates, ...(config.templates || {}) };
   const intro =
     mergedTemplates[data.severity] ||
-    "The current implementation requires attention.";
+    'The current implementation requires attention.';
 
-  return `### ${data.severity}: ${data.title}
+  let markdown = `### ${data.severity}: ${data.title}\n\n${intro}\n\n`;
 
-${intro}
+  // 1. Format File & Line Context
+  if (data.path) {
+    const repo = config.githubRepo || detectGithubRepo();
+    const lineStr = data.line ? `:${data.line}` : '';
 
-**Problem**
+    if (repo && repo.owner && repo.repo) {
+      const branch = config.defaultBranch || 'main';
+      // Generate direct deep link to GitHub
+      const lineAnchor = data.line ? `#L${data.line.replace(/-.*/, '')}` : ''; // Take start of line range
+      const fileUrl = `https://github.com/${repo.owner}/${repo.repo}/blob/${branch}/${data.path}${lineAnchor}`;
+      markdown += `📁 **File:** [\`${data.path}${lineStr}\`](${fileUrl})\n\n`;
+    } else {
+      markdown += `📁 **File:** \`${data.path}${lineStr}\`\n\n`;
+    }
+  }
 
-${data.issue}
+  // 2. Format Problem/Issue
+  markdown += `**Problem**\n\n${data.issue}\n\n`;
 
-**Suggested Fix**
+  // 3. Format Suggested Fix
+  markdown += `**Suggested Fix**\n\n${data.fix}\n\n`;
 
-${data.fix}
-`;
+  // 4. Format Before / After Code Comparison
+  if (data.before || data.after) {
+    markdown += `<details>\n<summary>🔍 View Code Diff / Comparison</summary>\n\n`;
+
+    const lang = data.lang || 'javascript';
+
+    if (data.before && data.before.trim() !== '') {
+      markdown += `**Before:**\n\`\`\`${lang}\n${data.before.trim()}\n\`\`\`\n\n`;
+    }
+
+    if (data.after && data.after.trim() !== '') {
+      markdown += `**After:**\n\`\`\`${lang}\n${data.after.trim()}\n\`\`\`\n\n`;
+    }
+
+    markdown += `</details>\n`;
+  }
+
+  return markdown;
 }

package/src/github.js

@@ -0,0 +1,153 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Attempts to automatically detect the GitHub owner and repository name
+ * from the local .git/config file.
+ *
+ * @returns {{ owner: string, repo: string } | null} The detected repository or null
+ */
+export function detectGithubRepo() {
+  try {
+    const gitConfigPath = path.join(process.cwd(), '.git', 'config');
+    if (!fs.existsSync(gitConfigPath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(gitConfigPath, 'utf8');
+    // Use RegExp constructor to avoid escaping forward slashes which triggers ESLint warnings
+    const regex = new RegExp(
+      'url\\s*=\\s*(?:https://github\\.com/|git@github\\.com:)([^/\\s]+)/([^./\\s]+)(?:\\.git)?',
+      'i'
+    );
+    const match = content.match(regex);
+
+    if (match) {
+      return {
+        owner: match[1].trim(),
+        repo: match[2].trim(),
+      };
+    }
+  } catch {
+    // Fail silently, return null
+  }
+  return null;
+}
+
+/**
+ * Posts a markdown comment directly to a GitHub Pull Request discussion thread.
+ *
+ * @param {string} owner The repo owner
+ * @param {string} repo The repo name
+ * @param {number|string} prNumber The pull request number
+ * @param {string} markdown The markdown body to post
+ * @param {object} config Local configurations for tokens
+ * @returns {Promise<string>} The API response comment URL on success
+ */
+export async function postPRComment(
+  owner,
+  repo,
+  prNumber,
+  markdown,
+  config = {}
+) {
+  const token = config.githubToken || process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GitHub Personal Access Token not found. Set 'githubToken' in .prsmith.json or the GITHUB_TOKEN environment variable."
+    );
+  }
+
+  const url = `https://api.github.com/repos/${owner}/${repo}/issues/${prNumber}/comments`;
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      'User-Agent': 'PRSmith-CLI',
+    },
+    body: JSON.stringify({ body: markdown }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`GitHub API error: ${response.statusText} (${errorText})`);
+  }
+
+  const data = await response.json();
+  return data.html_url;
+}
+
+/**
+ * Submits a native GitHub PR Review session containing multiple inline and/or general comments.
+ *
+ * @param {string} owner The repo owner
+ * @param {string} repo The repo name
+ * @param {number|string} prNumber The pull request number
+ * @param {string} body The main review description/summary
+ * @param {Array<{path: string, line: number, body: string}>} comments Inline comments list
+ * @param {object} config Local configurations for tokens
+ * @returns {Promise<string>} The API response review URL or confirmation message
+ */
+export async function submitPRReview(
+  owner,
+  repo,
+  prNumber,
+  body,
+  comments = [],
+  config = {}
+) {
+  const token = config.githubToken || process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(
+      "GitHub Personal Access Token not found. Set 'githubToken' in .prsmith.json or the GITHUB_TOKEN environment variable."
+    );
+  }
+
+  const url = `https://api.github.com/repos/${owner}/${repo}/pulls/${prNumber}/reviews`;
+
+  // Format individual inline comments for the reviews API
+  // Filter out any comments that lack file path/line
+  const apiComments = comments
+    .filter((c) => c.path && c.line)
+    .map((c) => ({
+      path: c.path,
+      line: parseInt(c.line, 10),
+      body: c.body,
+      side: 'RIGHT', // Reviewing the changes in the incoming PR
+    }));
+
+  const payload = {
+    body: body,
+    event: 'COMMENT',
+  };
+
+  if (apiComments.length > 0) {
+    payload.comments = apiComments;
+  }
+
+  const response = await fetch(url, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+      Accept: 'application/vnd.github+json',
+      'X-GitHub-Api-Version': '2022-11-28',
+      'User-Agent': 'PRSmith-CLI',
+    },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`GitHub API error: ${response.statusText} (${errorText})`);
+  }
+
+  const data = await response.json();
+  return (
+    data.html_url || `https://github.com/${owner}/${repo}/pull/${prNumber}`
+  );
+}