korekt-cli 0.11.2 → 0.13.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "korekt-cli",
-  "version": "0.11.2",
+  "version": "0.13.1",
   "description": "AI-powered code review CLI - Keep your kode korekt",
   "main": "src/index.js",
   "bin": {

package/src/config.js

@@ -44,13 +44,3 @@ export function getApiEndpoint() {
 export function setApiEndpoint(endpoint) {
   config.set('apiEndpoint', endpoint);
 }
-
-/**
- * Get all configuration
- */
-export function getConfig() {
-  return {
-    apiKey: getApiKey(),
-    apiEndpoint: getApiEndpoint(),
-  };
-}

package/src/formatter.js

@@ -76,7 +76,7 @@ function toAbsolutePath(filePath) {
  * @param {Object} data - The API response data
  */
 export function formatReviewOutput(data) {
-  const { review, summary, change_classification: changeClassification } = data.data;
+  const { review, summary, change_classification: changeClassification, model } = data.data;
 
   console.log(chalk.bold.blue('🤖 Automated Code Review Results\n'));
 
@@ -162,4 +162,9 @@ export function formatReviewOutput(data) {
       console.log(); // Add a blank line for spacing
     });
   }
+
+  // Footer with model info
+  if (model) {
+    console.log(chalk.gray(`Analyzed with ${model}`));
+  }
 }

package/src/index.js

@@ -72,6 +72,75 @@ async function confirmAction(message) {
   });
 }
 
+/**
+ * Handle skipped response from API (when integration mode prevents CLI review)
+ * @param {Object} response - Axios response object
+ * @param {Object} options - Command options (json flag, etc.)
+ * @param {Object} spinner - Ora spinner instance
+ * @returns {boolean} - True if response was skipped, false otherwise
+ */
+export function handleSkippedResponse(response, options, spinner) {
+  if (response.data.skipped) {
+    spinner.info(response.data.message || 'Review skipped.');
+    if (options.json) {
+      output(JSON.stringify(response.data, null, 2));
+    }
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Available Gemini models for code review
+ */
+const GEMINI_MODELS = [
+  { value: 'gemini-2.5-pro', label: 'gemini-2.5-pro (high quality)' },
+  { value: 'gemini-2.5-flash', label: 'gemini-2.5-flash (avoid, the worst quality)' },
+  { value: 'gemini-3-pro-preview', label: 'gemini-3-pro-preview (experimental - the best model)' },
+  {
+    value: 'gemini-3-flash-preview',
+    label: 'gemini-3-flash-preview (experimental - the most efficient model)',
+  },
+];
+
+/**
+ * Prompt user to select a Gemini model
+ * @returns {Promise<string>} - Selected model name
+ * @throws {Error} - If not running in interactive terminal
+ */
+async function selectModel() {
+  // Check if running in interactive terminal
+  if (!process.stdin.isTTY) {
+    log(chalk.red('Error: --model flag requires a value in non-interactive environments.'));
+    log(chalk.gray('Example: kk review --model=gemini-2.5-pro'));
+    process.exit(1);
+  }
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr,
+  });
+
+  log(chalk.yellow('\nSelect Gemini model:\n'));
+  GEMINI_MODELS.forEach((model, index) => {
+    log(`  ${index + 1}. ${model.label}`);
+  });
+  log('');
+
+  return new Promise((resolvePromise) => {
+    rl.question(chalk.bold('Enter number (1-4): '), (answer) => {
+      rl.close();
+      const num = parseInt(answer, 10);
+      if (num >= 1 && num <= GEMINI_MODELS.length) {
+        resolvePromise(GEMINI_MODELS[num - 1].value);
+      } else {
+        log(chalk.red('Invalid selection. Please run the command again and enter 1-4.'));
+        process.exit(1);
+      }
+    });
+  });
+}
+
 /**
  * Run the CI integration script to post comments
  * @param {string} provider - CI provider (github, azure, bitbucket)
@@ -128,6 +197,8 @@ program
 Examples:
   $ kk review                      Review committed changes (auto-detect base)
   $ kk review main                 Review changes against main branch
+  $ kk review --model              Select Gemini model interactively
+  $ kk review -m gemini-2.5-pro    Use specific model
   $ kk stg --dry-run               Preview staged changes review
   $ kk diff                        Review unstaged changes
   $ kk review main --json          Output raw JSON (for CI/CD integration)
@@ -137,6 +208,7 @@ Common Options:
   --dry-run                        Show payload without sending to API
   --json                           Output raw API response as JSON
   --comment                        Post review results as PR comments
+  -m, --model [name]               Gemini model (picker if no value)
 
 Configuration:
   $ kk config --key YOUR_KEY
@@ -159,6 +231,7 @@ program
   .option('--json', 'Output raw API response as JSON')
   .option('--comment', 'Post review results as PR comments (auto-detects CI provider)')
   .option('--post-ticket', 'Post review results to linked ticket (e.g., JIRA)')
+  .option('-m, --model [name]', 'Gemini model to use (interactive picker if no value provided)')
   .action(async (targetBranch, options) => {
     const reviewTarget = targetBranch ? `against '${targetBranch}'` : '(auto-detecting fork point)';
 
@@ -179,6 +252,15 @@ program
       process.exit(1);
     }
 
+    // Handle model selection: if --model without value, show picker
+    let selectedModel = null;
+    if (options.model === true) {
+      selectedModel = await selectModel();
+      log(chalk.green(`Using model: ${selectedModel}\n`));
+    } else if (typeof options.model === 'string') {
+      selectedModel = options.model;
+    }
+
     // Fetch file rules config from API
     const fileRulesConfig = await fetchFileRulesConfig(apiEndpoint, apiKey);
 
@@ -206,6 +288,11 @@ program
         changed_files: payload.changed_files.map((file) => truncateFileData(file)),
       };
 
+      // Add model if specified
+      if (selectedModel) {
+        displayPayload.model = selectedModel;
+      }
+
       log(JSON.stringify(displayPayload, null, 2));
       log(chalk.gray('\n💡 Run without --dry-run to send to API'));
       log(chalk.gray('💡 Diffs and content are truncated in dry-run for readability'));
@@ -255,6 +342,11 @@ program
       payload.post_to_ticket = true;
     }
 
+    // Add model if specified
+    if (selectedModel) {
+      payload.model = selectedModel;
+    }
+
     try {
       const response = await axios.post(apiEndpoint, payload, {
         headers: {
@@ -265,6 +357,12 @@ program
 
       clearInterval(timer);
       const elapsed = Math.floor((Date.now() - startTime) / 1000);
+
+      // Handle skipped response (integration mode prevents CLI review)
+      if (handleSkippedResponse(response, options, spinner)) {
+        return;
+      }
+
       spinner.succeed(`Review completed in ${elapsed}s!`);
 
       // Handle --comment flag: post results to PR
@@ -328,6 +426,7 @@ program
   .description('Review staged changes (git diff --cached)')
   .option('--dry-run', 'Show payload without sending to API')
   .option('--json', 'Output raw API response as JSON')
+  .option('-m, --model [name]', 'Gemini model to use (interactive picker if no value provided)')
   .action(async (options) => {
     log(chalk.blue.bold('🚀 Reviewing staged changes...'));
     await reviewUncommitted('staged', options);
@@ -339,6 +438,7 @@ program
   .description('Review unstaged changes (git diff)')
   .option('--dry-run', 'Show payload without sending to API')
   .option('--json', 'Output raw API response as JSON')
+  .option('-m, --model [name]', 'Gemini model to use (interactive picker if no value provided)')
   .action(async (options) => {
     log(chalk.blue.bold('🚀 Reviewing unstaged changes...'));
     await reviewUncommitted('unstaged', options);
@@ -359,6 +459,15 @@ async function reviewUncommitted(mode, options) {
     process.exit(1);
   }
 
+  // Handle model selection: if --model without value, show picker
+  let selectedModel = null;
+  if (options.model === true) {
+    selectedModel = await selectModel();
+    log(chalk.green(`Using model: ${selectedModel}\n`));
+  } else if (typeof options.model === 'string') {
+    selectedModel = options.model;
+  }
+
   // Fetch file rules config from API
   const fileRulesConfig = await fetchFileRulesConfig(apiEndpoint, apiKey);
 
@@ -378,6 +487,11 @@ async function reviewUncommitted(mode, options) {
       changed_files: payload.changed_files.map((file) => truncateFileData(file)),
     };
 
+    // Add model if specified
+    if (selectedModel) {
+      displayPayload.model = selectedModel;
+    }
+
     log(JSON.stringify(displayPayload, null, 2));
     log(chalk.gray('\n💡 Run without --dry-run to send to API'));
     log(chalk.gray('💡 Diffs and content are truncated in dry-run for readability'));
@@ -410,6 +524,11 @@ async function reviewUncommitted(mode, options) {
     }
   }
 
+  // Add model if specified
+  if (selectedModel) {
+    payload.model = selectedModel;
+  }
+
   const spinner = ora('Submitting review to the AI...').start();
   const startTime = Date.now();
 
@@ -428,6 +547,12 @@ async function reviewUncommitted(mode, options) {
 
     clearInterval(timer);
     const elapsed = Math.floor((Date.now() - startTime) / 1000);
+
+    // Handle skipped response (integration mode prevents CLI review)
+    if (handleSkippedResponse(response, options, spinner)) {
+      return;
+    }
+
     spinner.succeed(`Review completed in ${elapsed}s!`);
 
     // Output results to stdout

package/src/index.test.js

@@ -1,5 +1,11 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { truncateFileData, formatErrorOutput, detectCIProvider, getPrUrl } from './index.js';
+import {
+  truncateFileData,
+  formatErrorOutput,
+  detectCIProvider,
+  getPrUrl,
+  handleSkippedResponse,
+} from './index.js';
 
 describe('CLI JSON output mode', () => {
   let stdoutSpy;
@@ -469,6 +475,194 @@ describe('--comment flag behavior', () => {
   });
 });
 
+describe('--model flag behavior', () => {
+  describe('model selection logic', () => {
+    it('should treat --model without value as true (picker mode)', () => {
+      const options = { model: true };
+
+      // When --model is used without a value, Commander sets it to true
+      const shouldShowPicker = options.model === true;
+      const hasDirectValue = typeof options.model === 'string';
+
+      expect(shouldShowPicker).toBe(true);
+      expect(hasDirectValue).toBe(false);
+    });
+
+    it('should treat --model=value as string (direct mode)', () => {
+      const options = { model: 'gemini-2.5-flash' };
+
+      const shouldShowPicker = options.model === true;
+      const hasDirectValue = typeof options.model === 'string';
+
+      expect(shouldShowPicker).toBe(false);
+      expect(hasDirectValue).toBe(true);
+      expect(options.model).toBe('gemini-2.5-flash');
+    });
+
+    it('should not include model when flag is not used', () => {
+      const options = {};
+
+      const shouldIncludeModel = options.model !== undefined;
+
+      expect(shouldIncludeModel).toBe(false);
+    });
+  });
+
+  describe('payload model field', () => {
+    it('should add model to payload when specified', () => {
+      const payload = {
+        repo_url: 'https://github.com/user/repo',
+        changed_files: [],
+      };
+
+      const selectedModel = 'gemini-2.5-flash';
+      if (selectedModel) {
+        payload.model = selectedModel;
+      }
+
+      expect(payload.model).toBe('gemini-2.5-flash');
+    });
+
+    it('should not add model to payload when not specified', () => {
+      const payload = {
+        repo_url: 'https://github.com/user/repo',
+        changed_files: [],
+      };
+
+      const selectedModel = null;
+      if (selectedModel) {
+        payload.model = selectedModel;
+      }
+
+      expect(payload.model).toBeUndefined();
+    });
+  });
+
+  describe('available models', () => {
+    it('should have valid model values', () => {
+      const validModels = [
+        'gemini-2.5-pro',
+        'gemini-2.5-flash',
+        'gemini-3-pro-preview',
+        'gemini-3-flash-preview',
+      ];
+
+      // Test that all expected models are valid Gemini model names
+      validModels.forEach((model) => {
+        expect(model).toMatch(/^gemini-/);
+      });
+    });
+  });
+});
+
+describe('skipped response handling', () => {
+  let stdoutSpy;
+
+  beforeEach(() => {
+    stdoutSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should return true and call spinner.info when response is skipped', () => {
+    const response = {
+      data: {
+        skipped: true,
+        reason: 'webhook_mode_active',
+        message: 'Review skipped due to webhook mode.',
+      },
+    };
+    const options = { json: false };
+    const spinner = { info: vi.fn() };
+
+    const result = handleSkippedResponse(response, options, spinner);
+
+    expect(result).toBe(true);
+    expect(spinner.info).toHaveBeenCalledWith('Review skipped due to webhook mode.');
+  });
+
+  it('should return false when response is not skipped', () => {
+    const response = {
+      data: {
+        review: { issues: [], praises: [] },
+        summary: { total_issues: 0 },
+      },
+    };
+    const options = { json: false };
+    const spinner = { info: vi.fn() };
+
+    const result = handleSkippedResponse(response, options, spinner);
+
+    expect(result).toBe(false);
+    expect(spinner.info).not.toHaveBeenCalled();
+  });
+
+  it('should output JSON to stdout when json option is true and response is skipped', () => {
+    const response = {
+      data: {
+        skipped: true,
+        reason: 'local_reviews_disabled',
+        message: 'Local reviews disabled.',
+      },
+    };
+    const options = { json: true };
+    const spinner = { info: vi.fn() };
+
+    handleSkippedResponse(response, options, spinner);
+
+    expect(stdoutSpy).toHaveBeenCalledWith(JSON.stringify(response.data, null, 2) + '\n');
+  });
+
+  it('should not output JSON when json option is false', () => {
+    const response = {
+      data: {
+        skipped: true,
+        reason: 'reviews_disabled',
+        message: 'Reviews disabled.',
+      },
+    };
+    const options = { json: false };
+    const spinner = { info: vi.fn() };
+
+    handleSkippedResponse(response, options, spinner);
+
+    expect(stdoutSpy).not.toHaveBeenCalled();
+  });
+
+  it('should use default message when response message is empty', () => {
+    const response = {
+      data: {
+        skipped: true,
+        reason: 'webhook_mode_active',
+      },
+    };
+    const options = { json: false };
+    const spinner = { info: vi.fn() };
+
+    handleSkippedResponse(response, options, spinner);
+
+    expect(spinner.info).toHaveBeenCalledWith('Review skipped.');
+  });
+
+  it('should handle all skip reason types', () => {
+    const reasons = ['webhook_mode_active', 'reviews_disabled', 'local_reviews_disabled'];
+    const spinner = { info: vi.fn() };
+
+    reasons.forEach((reason) => {
+      const response = {
+        data: { skipped: true, reason, message: `Skipped: ${reason}` },
+      };
+
+      const result = handleSkippedResponse(response, { json: false }, spinner);
+      expect(result).toBe(true);
+    });
+
+    expect(spinner.info).toHaveBeenCalledTimes(3);
+  });
+});
+
 describe('getPrUrl', () => {
   const originalEnv = process.env;