prsmith 1.1.0 → 2.1.0

package/src/prompts.js

@@ -1,7 +1,7 @@
-import inquirer from "inquirer";
+import inquirer from 'inquirer';
 
 export async function getReviewData(options = {}, config = {}) {
-  const defaultSeverities = ["Critical", "Major", "Minor", "Suggestion"];
+  const defaultSeverities = ['Critical', 'Major', 'Minor', 'Suggestion'];
   let severities = [...defaultSeverities];
   if (config.templates) {
     for (const key of Object.keys(config.templates)) {
@@ -11,42 +11,139 @@ export async function getReviewData(options = {}, config = {}) {
     }
   }
 
-  const questions = [];
+  // 1. Gather Core Fields
+  const coreQuestions = [];
 
   if (!options.severity) {
-    questions.push({
-      type: "select",
-      name: "severity",
-      message: "Select severity:",
+    coreQuestions.push({
+      type: 'select',
+      name: 'severity',
+      message: 'Select severity:',
       choices: severities,
     });
   }
 
   if (!options.title) {
-    questions.push({
-      type: "input",
-      name: "title",
-      message: "Review title:",
+    coreQuestions.push({
+      type: 'input',
+      name: 'title',
+      message: 'Review title:',
     });
   }
 
   if (!options.issue) {
-    questions.push({
-      type: "editor",
-      name: "issue",
-      message: "Describe the issue:",
+    coreQuestions.push({
+      type: 'editor',
+      name: 'issue',
+      message:
+        'Describe the issue (Vim: i to write, Esc then :wq to save & exit. Nano: Ctrl+O, Enter, Ctrl+X):',
     });
   }
 
   if (!options.fix) {
-    questions.push({
-      type: "editor",
-      name: "fix",
-      message: "Suggested fix:",
+    coreQuestions.push({
+      type: 'editor',
+      name: 'fix',
+      message:
+        'Suggested fix (Vim: i to write, Esc then :wq to save & exit. Nano: Ctrl+O, Enter, Ctrl+X):',
     });
   }
 
-  const answers = questions.length > 0 ? await inquirer.prompt(questions) : {};
+  const coreAnswers =
+    coreQuestions.length > 0 ? await inquirer.prompt(coreQuestions) : {};
+  const currentData = { ...options, ...coreAnswers };
 
-  return { ...options, ...answers };
+  // 2. Gather File & Line Context
+  let fileAnswers = {};
+  if (currentData.path === undefined && currentData.line === undefined) {
+    const { addContext } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'addContext',
+        message: 'Would you like to add file & line context?',
+        default: false,
+      },
+    ]);
+
+    if (addContext) {
+      fileAnswers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'path',
+          message: 'File path (relative to repo root, e.g. src/index.js):',
+        },
+        {
+          type: 'input',
+          name: 'line',
+          message: 'Line number or range (e.g. 12 or 45-50):',
+        },
+      ]);
+    }
+  }
+
+  // 3. Gather Before/After Code Snippets
+  let codeAnswers = {};
+  if (currentData.before === undefined && currentData.after === undefined) {
+    const { addSnippets } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'addSnippets',
+        message: 'Would you like to add Before/After code snippets?',
+        default: false,
+      },
+    ]);
+
+    if (addSnippets) {
+      codeAnswers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'lang',
+          message: 'Programming language (for markdown syntax highlighting):',
+          default: 'javascript',
+        },
+        {
+          type: 'editor',
+          name: 'before',
+          message:
+            'Original Code (Before) (Vim: i to write, Esc then :wq to save & exit. Nano: Ctrl+O, Enter, Ctrl+X):',
+        },
+        {
+          type: 'editor',
+          name: 'after',
+          message:
+            'Proposed Code (After) (Vim: i to write, Esc then :wq to save & exit. Nano: Ctrl+O, Enter, Ctrl+X):',
+        },
+      ]);
+    }
+  }
+
+  // 4. Gather AI Polish Toggle
+  let aiAnswers = {};
+  if (currentData.ai === undefined) {
+    const hasKey = !!(
+      config.aiApiKey ||
+      process.env.GEMINI_API_KEY ||
+      process.env.OPENAI_API_KEY ||
+      process.env.GROQ_API_KEY
+    );
+
+    const { ai } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'ai',
+        message: hasKey
+          ? 'Polish the description and fix with AI for a constructive, polite tone?'
+          : 'Polish with AI? (Note: Needs AI key configured in .prsmith.json or env)',
+        default: false,
+      },
+    ]);
+    aiAnswers = { ai };
+  }
+
+  return {
+    ...currentData,
+    ...fileAnswers,
+    ...codeAnswers,
+    ...aiAnswers,
+  };
 }

package/src/templates.js

@@ -1,13 +1,9 @@
 export const templates = {
-  Critical:
-    "The current implementation introduces a critical issue.",
+  Critical: 'The current implementation introduces a critical issue.',
 
-  Major:
-    "The current implementation introduces a significant issue.",
+  Major: 'The current implementation introduces a significant issue.',
 
-  Minor:
-    "The current implementation could be improved.",
+  Minor: 'The current implementation could be improved.',
 
-  Suggestion:
-    "The implementation works, but there may be a cleaner approach."
-};
+  Suggestion: 'The implementation works, but there may be a cleaner approach.',
+};

package/tests/features.test.js

@@ -0,0 +1,253 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import { generateMarkdown } from '../src/formatter.js';
+import { detectGithubRepo } from '../src/github.js';
+import { polishText } from '../src/ai.js';
+import { loadConfig } from '../src/config.js';
+
+describe('v2.0.0 Features Test Suite', () => {
+  let existsSyncSpy;
+  let readFileSyncSpy;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Spy on fs methods
+    existsSyncSpy = vi.spyOn(fs, 'existsSync');
+    readFileSyncSpy = vi.spyOn(fs, 'readFileSync');
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('File & Line Context Deep Links', () => {
+    it('should generate standard file path text if no githubRepo is detected', () => {
+      const data = {
+        severity: 'Suggestion',
+        title: 'Optimized Loop',
+        issue: 'Loop could be faster.',
+        fix: 'Use for-i loop.',
+        path: 'src/utils/math.js',
+        line: '15-20',
+      };
+
+      existsSyncSpy.mockReturnValue(false);
+
+      const markdown = generateMarkdown(data);
+      expect(markdown).toContain('📁 **File:** `src/utils/math.js:15-20`');
+    });
+
+    it('should generate a clickable GitHub deep link if githubRepo is provided', () => {
+      const data = {
+        severity: 'Suggestion',
+        title: 'Optimized Loop',
+        issue: 'Loop could be faster.',
+        fix: 'Use for-i loop.',
+        path: 'src/utils/math.js',
+        line: '15-20',
+      };
+
+      const config = {
+        githubRepo: { owner: 'tarunyaprogrammer', repo: 'PRSmith' },
+        defaultBranch: 'main',
+      };
+
+      const markdown = generateMarkdown(data, config);
+      expect(markdown).toContain(
+        '📁 **File:** [`src/utils/math.js:15-20`](https://github.com/tarunyaprogrammer/PRSmith/blob/main/src/utils/math.js#L15)'
+      );
+    });
+  });
+
+  describe('Before / After Code Snippet Formatting', () => {
+    it('should render collapsible before and after code blocks beautifully', () => {
+      const data = {
+        severity: 'Minor',
+        title: 'Use Strict Equality',
+        issue: 'Loose equality can lead to bugs.',
+        fix: 'Use strict equality instead.',
+        lang: 'typescript',
+        before: 'if (x == y) { return; }',
+        after: 'if (x === y) { return; }',
+      };
+
+      const markdown = generateMarkdown(data);
+      expect(markdown).toContain('<details>');
+      expect(markdown).toContain(
+        '<summary>🔍 View Code Diff / Comparison</summary>'
+      );
+      expect(markdown).toContain(
+        '**Before:**\n```typescript\nif (x == y) { return; }\n```'
+      );
+      expect(markdown).toContain(
+        '**After:**\n```typescript\nif (x === y) { return; }\n```'
+      );
+      expect(markdown).toContain('</details>');
+    });
+  });
+
+  describe('Git Config Parsing (detectGithubRepo)', () => {
+    it('should correctly parse HTTPS git urls from config file', () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSyncSpy.mockReturnValue(`
+[core]
+	repositoryformatversion = 0
+	filemode = true
+[remote "origin"]
+	url = https://github.com/tarunyaprogrammer/PRSmith.git
+	fetch = +refs/heads/*:refs/remotes/origin/*
+      `);
+
+      const repo = detectGithubRepo();
+      expect(repo).toEqual({ owner: 'tarunyaprogrammer', repo: 'PRSmith' });
+    });
+
+    it('should correctly parse SSH git urls from config file', () => {
+      existsSyncSpy.mockReturnValue(true);
+      readFileSyncSpy.mockReturnValue(`
+[remote "origin"]
+	url = git@github.com:google/antigravity.git
+      `);
+
+      const repo = detectGithubRepo();
+      expect(repo).toEqual({ owner: 'google', repo: 'antigravity' });
+    });
+  });
+
+  describe('AI Polish (polishText) HTTP mock', () => {
+    beforeEach(() => {
+      global.fetch = vi.fn();
+    });
+
+    it('should fallback to original text if no key is provided', async () => {
+      const originalText = 'This is a harsh comment!';
+      const polished = await polishText(
+        originalText,
+        'Problem Description',
+        {}
+      );
+      expect(polished).toBe(originalText);
+    });
+
+    it('should invoke Gemini API correctly and return polished content', async () => {
+      const originalText = 'Your code is slow.';
+      const responseMock = {
+        ok: true,
+        json: async () => ({
+          candidates: [
+            {
+              content: {
+                parts: [
+                  {
+                    text: 'The current implementation has room for performance optimization.',
+                  },
+                ],
+              },
+            },
+          ],
+        }),
+      };
+      global.fetch.mockResolvedValue(responseMock);
+
+      const config = {
+        aiProvider: 'gemini',
+        aiApiKey: 'mock-key',
+      };
+
+      const polished = await polishText(
+        originalText,
+        'Problem Description',
+        config
+      );
+      expect(polished).toBe(
+        'The current implementation has room for performance optimization.'
+      );
+      expect(global.fetch).toHaveBeenCalledWith(
+        expect.stringContaining('generativelanguage.googleapis.com'),
+        expect.objectContaining({
+          method: 'POST',
+          body: expect.stringContaining('Your code is slow.'),
+        })
+      );
+    });
+
+    it('should invoke OpenAI API correctly and return polished content', async () => {
+      const originalText = 'Close the resource.';
+      const responseMock = {
+        ok: true,
+        json: async () => ({
+          choices: [
+            {
+              message: {
+                content:
+                  'It is highly recommended to properly release the resource in a finally block.',
+              },
+            },
+          ],
+        }),
+      };
+      global.fetch.mockResolvedValue(responseMock);
+
+      const config = {
+        aiProvider: 'openai',
+        aiApiKey: 'mock-key-openai',
+      };
+
+      const polished = await polishText(originalText, 'Suggested Fix', config);
+      expect(polished).toBe(
+        'It is highly recommended to properly release the resource in a finally block.'
+      );
+      expect(global.fetch).toHaveBeenCalledWith(
+        'https://api.openai.com/v1/chat/completions',
+        expect.objectContaining({
+          method: 'POST',
+          headers: expect.objectContaining({
+            Authorization: 'Bearer mock-key-openai',
+          }),
+        })
+      );
+    });
+  });
+
+  describe('Editor Config Guardrails', () => {
+    it('should dynamically set process.env.EDITOR to nano on non-windows systems if not defined', () => {
+      const originalPlatform = Object.getOwnPropertyDescriptor(
+        process,
+        'platform'
+      );
+      const originalEditor = process.env.EDITOR;
+      const originalVisual = process.env.VISUAL;
+
+      delete process.env.EDITOR;
+      delete process.env.VISUAL;
+
+      Object.defineProperty(process, 'platform', {
+        value: 'darwin',
+        configurable: true,
+      });
+
+      existsSyncSpy.mockReturnValue(false);
+
+      loadConfig();
+
+      expect(process.env.EDITOR).toBe('nano');
+
+      // Restore original state
+      Object.defineProperty(process, 'platform', originalPlatform);
+      if (originalEditor !== undefined) process.env.EDITOR = originalEditor;
+      if (originalVisual !== undefined) process.env.VISUAL = originalVisual;
+    });
+
+    it('should respect editor defined in config', () => {
+      const originalEditor = process.env.EDITOR;
+      existsSyncSpy.mockReturnValue(true);
+      readFileSyncSpy.mockReturnValue(JSON.stringify({ editor: 'vim-mock' }));
+
+      loadConfig();
+
+      expect(process.env.EDITOR).toBe('vim-mock');
+
+      if (originalEditor !== undefined) process.env.EDITOR = originalEditor;
+    });
+  });
+});

package/tests/formatter.test.js

@@ -1,51 +1,55 @@
-import { describe, it, expect } from "vitest";
-import { generateMarkdown } from "../src/formatter.js";
+import { describe, it, expect } from 'vitest';
+import { generateMarkdown } from '../src/formatter.js';
 
-describe("formatter.js", () => {
-  it("should generate proper markdown for Critical severity", () => {
+describe('formatter.js', () => {
+  it('should generate proper markdown for Critical severity', () => {
     const data = {
-      severity: "Critical",
-      title: "Memory Leak",
-      issue: "The connection is never closed.",
-      fix: "Add a finally block to close the connection."
+      severity: 'Critical',
+      title: 'Memory Leak',
+      issue: 'The connection is never closed.',
+      fix: 'Add a finally block to close the connection.',
     };
 
     const markdown = generateMarkdown(data);
-    
-    expect(markdown).toContain("### Critical: Memory Leak");
-    expect(markdown).toContain("The current implementation introduces a critical issue.");
-    expect(markdown).toContain("The connection is never closed.");
-    expect(markdown).toContain("Add a finally block to close the connection.");
+
+    expect(markdown).toContain('### Critical: Memory Leak');
+    expect(markdown).toContain(
+      'The current implementation introduces a critical issue.'
+    );
+    expect(markdown).toContain('The connection is never closed.');
+    expect(markdown).toContain('Add a finally block to close the connection.');
   });
 
-  it("should fallback to a default intro if severity is unknown", () => {
+  it('should fallback to a default intro if severity is unknown', () => {
     const data = {
-      severity: "Unknown",
-      title: "Something",
-      issue: "Bad code.",
-      fix: "Fix code."
+      severity: 'Unknown',
+      title: 'Something',
+      issue: 'Bad code.',
+      fix: 'Fix code.',
     };
 
     const markdown = generateMarkdown(data);
-    expect(markdown).toContain("The current implementation requires attention.");
+    expect(markdown).toContain(
+      'The current implementation requires attention.'
+    );
   });
 
-  it("should use custom templates when passed via config", () => {
+  it('should use custom templates when passed via config', () => {
     const data = {
-      severity: "Nitpick",
-      title: "Formatting",
-      issue: "Indentation is off.",
-      fix: "Fix indentation."
+      severity: 'Nitpick',
+      title: 'Formatting',
+      issue: 'Indentation is off.',
+      fix: 'Fix indentation.',
     };
 
     const config = {
       templates: {
-        Nitpick: "This is a tiny nitpick."
-      }
+        Nitpick: 'This is a tiny nitpick.',
+      },
     };
 
     const markdown = generateMarkdown(data, config);
-    expect(markdown).toContain("### Nitpick: Formatting");
-    expect(markdown).toContain("This is a tiny nitpick.");
+    expect(markdown).toContain('### Nitpick: Formatting');
+    expect(markdown).toContain('This is a tiny nitpick.');
   });
 });