korekt-cli 0.10.0 → 0.11.2

package/package.json

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

package/src/file-rules.js

@@ -0,0 +1,71 @@
+/**
+ * File processing rules for code review.
+ */
+
+/**
+ * Check if a file should be skipped entirely (binary/non-reviewable).
+ * @param {string} filePath - The file path to check
+ * @param {string[]} skipExtensions - Extensions to skip
+ * @returns {boolean} - True if the file should be skipped
+ */
+export function shouldSkip(filePath, skipExtensions) {
+  if (!skipExtensions || !Array.isArray(skipExtensions)) {
+    return false;
+  }
+
+  const lowerPath = filePath.toLowerCase();
+
+  for (const ext of skipExtensions) {
+    if (lowerPath.endsWith(ext.toLowerCase())) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if a file should only show diff (no full content).
+ * @param {string} filePath - The file path to check
+ * @param {string[]} diffOnlyExtensions - Extensions for diff-only
+ * @param {string[]} diffOnlyFiles - Specific filenames for diff-only
+ * @returns {boolean} - True if only diff should be shown
+ */
+export function isDiffOnly(filePath, diffOnlyExtensions, diffOnlyFiles) {
+  const lowerPath = filePath.toLowerCase();
+  const fileName = lowerPath.split('/').pop();
+
+  // Check exact filename matches first (lowercase comparison)
+  if (diffOnlyFiles && Array.isArray(diffOnlyFiles)) {
+    if (diffOnlyFiles.some((f) => f.toLowerCase() === fileName)) {
+      return true;
+    }
+  }
+
+  // Check extension matches
+  if (diffOnlyExtensions && Array.isArray(diffOnlyExtensions)) {
+    for (const ext of diffOnlyExtensions) {
+      if (lowerPath.endsWith(ext.toLowerCase())) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Check if content appears to be binary by looking for null bytes.
+ * @param {string} content - The content to check
+ * @returns {boolean} - True if content appears binary
+ */
+export function isBinary(content) {
+  if (!content || content.length === 0) {
+    return false;
+  }
+
+  const sample = content.slice(0, 8192);
+
+  // Check for null bytes - text files never contain them
+  return sample.includes('\0');
+}

package/src/file-rules.test.js

@@ -0,0 +1,187 @@
+import { describe, it, expect } from 'vitest';
+import { shouldSkip, isDiffOnly, isBinary } from './file-rules.js';
+
+/**
+ * Tests for file-rules helper functions.
+ * These functions take config as parameters - actual rules come from API.
+ */
+
+describe('shouldSkip', () => {
+  describe('with null/empty config', () => {
+    it('should return false when skipExtensions is null', () => {
+      expect(shouldSkip('image.png', null)).toBe(false);
+    });
+
+    it('should return false when skipExtensions is undefined', () => {
+      expect(shouldSkip('image.png', undefined)).toBe(false);
+    });
+
+    it('should return false when skipExtensions is empty array', () => {
+      expect(shouldSkip('image.png', [])).toBe(false);
+    });
+  });
+
+  describe('with extensions provided', () => {
+    const testExtensions = ['.png', '.jpg', '.exe'];
+
+    it('should skip files matching extensions', () => {
+      expect(shouldSkip('image.png', testExtensions)).toBe(true);
+      expect(shouldSkip('photo.jpg', testExtensions)).toBe(true);
+      expect(shouldSkip('program.exe', testExtensions)).toBe(true);
+    });
+
+    it('should not skip files not matching extensions', () => {
+      expect(shouldSkip('index.js', testExtensions)).toBe(false);
+      expect(shouldSkip('style.css', testExtensions)).toBe(false);
+    });
+
+    it('should be case insensitive', () => {
+      expect(shouldSkip('IMAGE.PNG', testExtensions)).toBe(true);
+      expect(shouldSkip('Photo.JPG', testExtensions)).toBe(true);
+    });
+
+    it('should handle paths with directories', () => {
+      expect(shouldSkip('assets/images/logo.png', testExtensions)).toBe(true);
+      expect(shouldSkip('src/index.js', testExtensions)).toBe(false);
+    });
+  });
+});
+
+describe('isDiffOnly', () => {
+  describe('with null/empty config', () => {
+    it('should return false when both params are null', () => {
+      expect(isDiffOnly('config.json', null, null)).toBe(false);
+    });
+
+    it('should return false when both params are empty arrays', () => {
+      expect(isDiffOnly('config.json', [], [])).toBe(false);
+    });
+  });
+
+  describe('with extensions provided', () => {
+    const testExtensions = ['.json', '.lock'];
+    const testFiles = [];
+
+    it('should match extension-based diff-only files', () => {
+      expect(isDiffOnly('config.json', testExtensions, testFiles)).toBe(true);
+      expect(isDiffOnly('composer.lock', testExtensions, testFiles)).toBe(true);
+    });
+
+    it('should not match non-diff-only files', () => {
+      expect(isDiffOnly('index.js', testExtensions, testFiles)).toBe(false);
+    });
+
+    it('should be case insensitive for extensions', () => {
+      expect(isDiffOnly('CONFIG.JSON', testExtensions, testFiles)).toBe(true);
+    });
+  });
+
+  describe('with specific filenames provided', () => {
+    const testExtensions = [];
+    const testFiles = ['package-lock.json', 'yarn.lock'];
+
+    it('should match specific filenames', () => {
+      expect(isDiffOnly('package-lock.json', testExtensions, testFiles)).toBe(true);
+      expect(isDiffOnly('yarn.lock', testExtensions, testFiles)).toBe(true);
+    });
+
+    it('should match filenames in paths', () => {
+      expect(isDiffOnly('node_modules/package-lock.json', testExtensions, testFiles)).toBe(true);
+    });
+
+    it('should be case insensitive for filenames', () => {
+      expect(isDiffOnly('PACKAGE-LOCK.JSON', testExtensions, testFiles)).toBe(true);
+    });
+  });
+
+  describe('with both extensions and filenames', () => {
+    const testExtensions = ['.json'];
+    const testFiles = ['go.sum'];
+
+    it('should work with only extensions provided', () => {
+      expect(isDiffOnly('config.json', testExtensions, null)).toBe(true);
+    });
+
+    it('should work with only files provided', () => {
+      expect(isDiffOnly('go.sum', null, testFiles)).toBe(true);
+    });
+  });
+});
+
+describe('isBinary', () => {
+  describe('empty/null content', () => {
+    it('should return false for empty string', () => {
+      expect(isBinary('')).toBe(false);
+    });
+
+    it('should return false for null', () => {
+      expect(isBinary(null)).toBe(false);
+    });
+
+    it('should return false for undefined', () => {
+      expect(isBinary(undefined)).toBe(false);
+    });
+  });
+
+  describe('text content', () => {
+    it('should return false for plain text', () => {
+      expect(isBinary('Hello, World!')).toBe(false);
+    });
+
+    it('should return false for code', () => {
+      const code = `function hello() {\n  console.log('Hello');\n}`;
+      expect(isBinary(code)).toBe(false);
+    });
+
+    it('should return false for content with whitespace', () => {
+      expect(isBinary('Line 1\n\tIndented\r\nWindows line')).toBe(false);
+    });
+
+    it('should return false for UTF-8 non-Latin text', () => {
+      // Chinese, Japanese, Cyrillic - all valid UTF-8, no null bytes
+      expect(isBinary('你好世界')).toBe(false);
+      expect(isBinary('こんにちは')).toBe(false);
+      expect(isBinary('Привет мир')).toBe(false);
+    });
+
+    it('should return false for text with control characters (non-null)', () => {
+      // Control chars like \x01-\x1F are not null bytes
+      const content = 'text\x01\x02\x03more text';
+      expect(isBinary(content)).toBe(false);
+    });
+  });
+
+  describe('binary content (null bytes)', () => {
+    it('should return true for content with null byte at start', () => {
+      expect(isBinary('\x00some text')).toBe(true);
+    });
+
+    it('should return true for content with null byte in middle', () => {
+      expect(isBinary('some\x00text')).toBe(true);
+    });
+
+    it('should return true for content with null byte at end', () => {
+      expect(isBinary('some text\x00')).toBe(true);
+    });
+
+    it('should return true for content with many null bytes', () => {
+      const binary = '\x00\x00\x00\x00some text\x00\x00\x00';
+      expect(isBinary(binary)).toBe(true);
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should only sample first 8192 characters', () => {
+      // Null byte after 8192 chars should not be detected
+      const textPart = 'a'.repeat(10000);
+      const binaryPart = '\x00';
+      expect(isBinary(textPart + binaryPart)).toBe(false);
+    });
+
+    it('should detect null byte within first 8192 characters', () => {
+      const textPart = 'a'.repeat(8000);
+      const binaryPart = '\x00';
+      expect(isBinary(textPart + binaryPart)).toBe(true);
+    });
+  });
+});

package/src/git-logic.js

@@ -1,6 +1,7 @@
 import { execa } from 'execa';
 import chalk from 'chalk';
 import { detectCIProvider, getPrUrl, getSourceBranchFromCI } from './utils.js';
+import { shouldSkip, isDiffOnly, isBinary } from './file-rules.js';
 
 /**
  * Truncate content to a maximum number of lines using "head and tail".
@@ -161,9 +162,14 @@ export function parseNameStatus(output) {
 /**
  * Analyze uncommitted changes (staged or unstaged)
  * @param {string} mode - 'staged' or 'unstaged'
+ * @param {Object} fileRulesConfig - File rules config from API (or defaults)
  * @returns {Object|null} - The payload object ready for API submission, or null on error
  */
-export async function runUncommittedReview(mode = 'unstaged') {
+export async function runUncommittedReview(mode = 'unstaged', fileRulesConfig = null) {
+  // If no config provided, use empty config (no filtering applied)
+  const config = fileRulesConfig || {};
+  const maxLines = config.max_lines ?? 2000;
+
   try {
     // 1. Get Repo URL, current branch name, and repository root
     const { stdout: repoUrl } = await execa('git', ['remote', 'get-url', 'origin']);
@@ -190,7 +196,43 @@ export async function runUncommittedReview(mode = 'unstaged') {
       console.error(chalk.gray('Analyzing unstaged changes...'));
     }
 
-    const fileList = parseNameStatus(nameStatusOutput);
+    let fileList = parseNameStatus(nameStatusOutput);
+
+    // Filter out binary/non-reviewable files (only if config has skip_extensions)
+    if (config.skip_extensions) {
+      let skippedCount = 0;
+      fileList = fileList.filter((file) => {
+        if (shouldSkip(file.path, config.skip_extensions)) {
+          skippedCount++;
+          console.error(chalk.gray(`  Skipping binary: ${file.path}`));
+          return false;
+        }
+        return true;
+      });
+
+      if (skippedCount > 0) {
+        console.error(chalk.gray(`Skipped ${skippedCount} binary file(s)\n`));
+      }
+    }
+
+    // Check if file count exceeds max_files_for_content limit
+    if (config.max_files_for_content && fileList.length > config.max_files_for_content) {
+      throw new Error(
+        `Too many files: ${fileList.length} files exceeds the limit of ${config.max_files_for_content}. ` +
+          `Please reduce the number of changed files before reviewing.`
+      );
+    }
+
+    // Check if this is a large change set (only if config has large_pr_threshold)
+    const isLargePr = config.large_pr_threshold && fileList.length > config.large_pr_threshold;
+    if (isLargePr) {
+      console.error(
+        chalk.yellow(
+          `Large change set (${fileList.length} files > ${config.large_pr_threshold}). Sending diffs only.`
+        )
+      );
+    }
+
     const changedFiles = [];
 
     for (const file of fileList) {
@@ -204,11 +246,24 @@ export async function runUncommittedReview(mode = 'unstaged') {
         diff = await git('diff', '-U15', '--', path);
       }
 
+      // Determine if we should include content for this file
+      const skipContent =
+        isLargePr ||
+        isDiffOnly(path, config.diff_only_extensions, config.diff_only_files) ||
+        status === 'A';
+
       // Get current content from HEAD (before changes)
       let content = '';
-      if (status !== 'A') {
+      if (!skipContent && status !== 'A') {
         try {
-          content = await git('show', `HEAD:${oldPath}`);
+          const originalContent = await git('show', `HEAD:${oldPath}`);
+
+          // Check if content is binary
+          if (isBinary(originalContent)) {
+            console.error(chalk.gray(`  Skipping binary content: ${path}`));
+          } else {
+            content = truncateContent(originalContent, maxLines);
+          }
         } catch {
           console.warn(
             chalk.yellow(`Could not get HEAD content for ${oldPath}. Assuming it's new.`)
@@ -216,21 +271,24 @@ export async function runUncommittedReview(mode = 'unstaged') {
         }
       }
 
-      // Truncate content
-      content = truncateContent(content);
-
       // For deleted files, truncate the diff as well
       if (status === 'D') {
-        diff = truncateContent(diff);
+        diff = truncateContent(diff, maxLines);
       }
 
-      changedFiles.push({
+      // Build the file object - only include content if we have it
+      const fileObj = {
         path: path,
         status: status,
         diff: diff,
-        content: content,
         ...((status === 'R' || status === 'C') && { old_path: oldPath }),
-      });
+      };
+
+      if (content) {
+        fileObj.content = content;
+      }
+
+      changedFiles.push(fileObj);
     }
 
     if (!nameStatusOutput.trim() && changedFiles.length === 0) {
@@ -312,9 +370,18 @@ export async function getContributors(diffRange, repoRootPath) {
  * Main function to analyze local git changes and prepare review payload
  * @param {string|null} targetBranch - The branch to compare against. If null, uses git reflog to find fork point.
  * @param {string[]|null} ignorePatterns - Array of glob patterns to ignore files
+ * @param {Object} fileRulesConfig - File rules config from API (or defaults)
  * @returns {Object|null} - The payload object ready for API submission, or null on error
  */
-export async function runLocalReview(targetBranch = null, ignorePatterns = null) {
+export async function runLocalReview(
+  targetBranch = null,
+  ignorePatterns = null,
+  fileRulesConfig = null
+) {
+  // If no config provided, use empty config (no filtering applied)
+  const config = fileRulesConfig || {};
+  const maxLines = config.max_lines ?? 2000;
+
   try {
     // 1. Get Repo URL, current branch name, commit hash, and repository root
     const { stdout: repoUrl } = await execa('git', ['remote', 'get-url', 'origin']);
@@ -454,7 +521,7 @@ export async function runLocalReview(targetBranch = null, ignorePatterns = null)
     });
     const fileList = parseNameStatus(nameStatusOutput);
 
-    // Filter out ignored files
+    // Filter out ignored files (user-specified patterns)
     let filteredFileList = fileList;
     let ignoredCount = 0;
     if (ignorePatterns && ignorePatterns.length > 0) {
@@ -472,9 +539,46 @@ export async function runLocalReview(targetBranch = null, ignorePatterns = null)
       console.error(chalk.gray(`Ignored ${ignoredCount} file(s) based on patterns\n`));
     }
 
+    // Filter out binary/non-reviewable files (only if config has skip_extensions)
+    if (config.skip_extensions) {
+      let skippedCount = 0;
+      filteredFileList = filteredFileList.filter((file) => {
+        if (shouldSkip(file.path, config.skip_extensions)) {
+          skippedCount++;
+          console.error(chalk.gray(`  Skipping binary: ${file.path}`));
+          return false;
+        }
+        return true;
+      });
+
+      if (skippedCount > 0) {
+        console.error(chalk.gray(`Skipped ${skippedCount} binary file(s)\n`));
+      }
+    }
+
+    // Check if file count exceeds max_files_for_content limit
+    if (config.max_files_for_content && filteredFileList.length > config.max_files_for_content) {
+      throw new Error(
+        `Too many files: ${filteredFileList.length} files exceeds the limit of ${config.max_files_for_content}. ` +
+          `Please split this PR into smaller reviews or use --ignore to exclude some files.`
+      );
+    }
+
+    // Check if this is a large PR (only if config has large_pr_threshold)
+    const isLargePr =
+      config.large_pr_threshold && filteredFileList.length > config.large_pr_threshold;
+    if (isLargePr) {
+      console.error(
+        chalk.yellow(
+          `Large PR detected (${filteredFileList.length} files > ${config.large_pr_threshold}). Sending diffs only.`
+        )
+      );
+    }
+
     console.error(chalk.gray(`Collecting diffs for ${filteredFileList.length} file(s)...`));
 
     const changedFiles = [];
+
     for (const file of filteredFileList) {
       const { status, path, oldPath } = file;
 
@@ -484,17 +588,30 @@ export async function runLocalReview(targetBranch = null, ignorePatterns = null)
         cwd: repoRootPath,
       });
 
-      // Get the original content from the base commit
+      // Determine if we should include content for this file
+      // Skip content for: large PRs, DIFF_ONLY files, deleted files, or added files
+      const skipContent =
+        isLargePr ||
+        isDiffOnly(path, config.diff_only_extensions, config.diff_only_files) ||
+        status === 'A';
+
+      // Get the original content from the base commit (unless we're skipping it)
       let content = '';
-      if (status !== 'A') {
-        // Added files have no original content
+      if (!skipContent && status !== 'A') {
         try {
           const { stdout: originalContent } = await execa(
             'git',
             ['show', `${mergeBase.trim()}:${oldPath}`],
             { cwd: repoRootPath }
           );
-          content = originalContent;
+
+          // Check if content is binary
+          if (isBinary(originalContent)) {
+            console.error(chalk.gray(`  Skipping binary content: ${path}`));
+            // Don't include content for binary files
+          } else {
+            content = truncateContent(originalContent, maxLines);
+          }
         } catch {
           // This can happen if a file was added and modified in the same branch
           console.warn(
@@ -503,22 +620,26 @@ export async function runLocalReview(targetBranch = null, ignorePatterns = null)
         }
       }
 
-      // Truncate content
-      content = truncateContent(content);
-
       // For deleted files, truncate the diff as well
       let truncatedDiff = diff;
       if (status === 'D') {
-        truncatedDiff = truncateContent(diff);
+        truncatedDiff = truncateContent(diff, maxLines);
       }
 
-      changedFiles.push({
+      // Build the file object - only include content if we have it
+      const fileObj = {
         path: path,
         status: status,
         diff: truncatedDiff,
-        content: content,
-        ...((status === 'R' || status === 'C') && { old_path: oldPath }), // Include old_path for renames and copies
-      });
+        ...((status === 'R' || status === 'C') && { old_path: oldPath }),
+      };
+
+      // Only include content field if we have content
+      if (content) {
+        fileObj.content = content;
+      }
+
+      changedFiles.push(fileObj);
     }
 
     // 5. Get contributors from commits

package/src/git-logic.test.js

@@ -1298,6 +1298,228 @@ describe('getSourceBranchFromCI', () => {
   });
 });
 
+describe('fileRulesConfig filtering', () => {
+  beforeEach(() => {
+    vi.mock('execa');
+    vi.mock('./utils.js', () => ({
+      detectCIProvider: vi.fn().mockReturnValue(null),
+      getPrUrl: vi.fn().mockReturnValue(null),
+      getSourceBranchFromCI: vi.fn().mockReturnValue(null),
+    }));
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('should exclude files matching skip_extensions', async () => {
+    vi.mocked(execa).mockImplementation(async (cmd, args) => {
+      const command = [cmd, ...args].join(' ');
+
+      if (command.includes('remote get-url origin')) {
+        return { stdout: 'https://github.com/user/repo.git' };
+      }
+      if (command.includes('rev-parse --abbrev-ref HEAD')) {
+        return { stdout: 'feature-branch' };
+      }
+      if (command.includes('rev-parse --show-toplevel')) {
+        return { stdout: '/fake/repo/path' };
+      }
+      if (command.includes('diff --cached --name-status')) {
+        return { stdout: 'M\tfile.js\nM\timage.png\nM\tphoto.jpg' };
+      }
+      if (command.includes('diff --cached -U15 -- file.js')) {
+        return { stdout: 'diff for file.js' };
+      }
+      if (command.includes('diff --cached -U15 -- image.png')) {
+        return { stdout: 'diff for image.png' };
+      }
+      if (command.includes('diff --cached -U15 -- photo.jpg')) {
+        return { stdout: 'diff for photo.jpg' };
+      }
+      if (command.includes('show HEAD:file.js')) {
+        return { stdout: 'js content' };
+      }
+      if (command.includes('show HEAD:image.png')) {
+        return { stdout: 'png content' };
+      }
+      if (command.includes('show HEAD:photo.jpg')) {
+        return { stdout: 'jpg content' };
+      }
+
+      throw new Error(`Unmocked command: ${command}`);
+    });
+
+    const config = {
+      skip_extensions: ['.png', '.jpg'],
+    };
+
+    const result = await runUncommittedReview('staged', config);
+
+    expect(result).toBeDefined();
+    expect(result.changed_files).toHaveLength(1);
+    expect(result.changed_files[0].path).toBe('file.js');
+  });
+
+  it('should not include content for diff_only files', async () => {
+    vi.mocked(execa).mockImplementation(async (cmd, args) => {
+      const command = [cmd, ...args].join(' ');
+
+      if (command.includes('remote get-url origin')) {
+        return { stdout: 'https://github.com/user/repo.git' };
+      }
+      if (command.includes('rev-parse --abbrev-ref HEAD')) {
+        return { stdout: 'feature-branch' };
+      }
+      if (command.includes('rev-parse --show-toplevel')) {
+        return { stdout: '/fake/repo/path' };
+      }
+      if (command.includes('diff --cached --name-status')) {
+        return { stdout: 'M\tfile.js\nM\tpackage-lock.json\nM\tconfig.yaml' };
+      }
+      if (command.includes('diff --cached -U15 -- file.js')) {
+        return { stdout: 'diff for file.js' };
+      }
+      if (command.includes('diff --cached -U15 -- package-lock.json')) {
+        return { stdout: 'diff for package-lock.json' };
+      }
+      if (command.includes('diff --cached -U15 -- config.yaml')) {
+        return { stdout: 'diff for config.yaml' };
+      }
+      if (command.includes('show HEAD:file.js')) {
+        return { stdout: 'js content' };
+      }
+      if (command.includes('show HEAD:package-lock.json')) {
+        return { stdout: 'lock content' };
+      }
+      if (command.includes('show HEAD:config.yaml')) {
+        return { stdout: 'yaml content' };
+      }
+
+      throw new Error(`Unmocked command: ${command}`);
+    });
+
+    const config = {
+      diff_only_extensions: ['.yaml'],
+      diff_only_files: ['package-lock.json'],
+    };
+
+    const result = await runUncommittedReview('staged', config);
+
+    expect(result).toBeDefined();
+    expect(result.changed_files).toHaveLength(3);
+
+    const jsFile = result.changed_files.find((f) => f.path === 'file.js');
+    const lockFile = result.changed_files.find((f) => f.path === 'package-lock.json');
+    const yamlFile = result.changed_files.find((f) => f.path === 'config.yaml');
+
+    expect(jsFile.content).toBe('js content');
+    expect(lockFile.content).toBeUndefined();
+    expect(yamlFile.content).toBeUndefined();
+  });
+
+  it('should not include content for any file when large_pr_threshold exceeded', async () => {
+    vi.mocked(execa).mockImplementation(async (cmd, args) => {
+      const command = [cmd, ...args].join(' ');
+
+      if (command.includes('remote get-url origin')) {
+        return { stdout: 'https://github.com/user/repo.git' };
+      }
+      if (command.includes('rev-parse --abbrev-ref HEAD')) {
+        return { stdout: 'feature-branch' };
+      }
+      if (command.includes('rev-parse --show-toplevel')) {
+        return { stdout: '/fake/repo/path' };
+      }
+      if (command.includes('diff --cached --name-status')) {
+        return { stdout: 'M\tfile1.js\nM\tfile2.js\nM\tfile3.js' };
+      }
+      if (command.includes('diff --cached -U15 -- file1.js')) {
+        return { stdout: 'diff for file1.js' };
+      }
+      if (command.includes('diff --cached -U15 -- file2.js')) {
+        return { stdout: 'diff for file2.js' };
+      }
+      if (command.includes('diff --cached -U15 -- file3.js')) {
+        return { stdout: 'diff for file3.js' };
+      }
+      if (command.includes('show HEAD:file1.js')) {
+        return { stdout: 'content1' };
+      }
+      if (command.includes('show HEAD:file2.js')) {
+        return { stdout: 'content2' };
+      }
+      if (command.includes('show HEAD:file3.js')) {
+        return { stdout: 'content3' };
+      }
+
+      throw new Error(`Unmocked command: ${command}`);
+    });
+
+    const config = {
+      large_pr_threshold: 2, // 3 files > 2 threshold
+    };
+
+    const result = await runUncommittedReview('staged', config);
+
+    expect(result).toBeDefined();
+    expect(result.changed_files).toHaveLength(3);
+
+    // All files should have no content due to large PR
+    for (const file of result.changed_files) {
+      expect(file.content).toBeUndefined();
+      expect(file.diff).toBeDefined();
+    }
+  });
+
+  it('should include content when below large_pr_threshold', async () => {
+    vi.mocked(execa).mockImplementation(async (cmd, args) => {
+      const command = [cmd, ...args].join(' ');
+
+      if (command.includes('remote get-url origin')) {
+        return { stdout: 'https://github.com/user/repo.git' };
+      }
+      if (command.includes('rev-parse --abbrev-ref HEAD')) {
+        return { stdout: 'feature-branch' };
+      }
+      if (command.includes('rev-parse --show-toplevel')) {
+        return { stdout: '/fake/repo/path' };
+      }
+      if (command.includes('diff --cached --name-status')) {
+        return { stdout: 'M\tfile1.js\nM\tfile2.js' };
+      }
+      if (command.includes('diff --cached -U15 -- file1.js')) {
+        return { stdout: 'diff for file1.js' };
+      }
+      if (command.includes('diff --cached -U15 -- file2.js')) {
+        return { stdout: 'diff for file2.js' };
+      }
+      if (command.includes('show HEAD:file1.js')) {
+        return { stdout: 'content1' };
+      }
+      if (command.includes('show HEAD:file2.js')) {
+        return { stdout: 'content2' };
+      }
+
+      throw new Error(`Unmocked command: ${command}`);
+    });
+
+    const config = {
+      large_pr_threshold: 5, // 2 files < 5 threshold
+    };
+
+    const result = await runUncommittedReview('staged', config);
+
+    expect(result).toBeDefined();
+    expect(result.changed_files).toHaveLength(2);
+
+    // All files should have content
+    for (const file of result.changed_files) {
+      expect(file.content).toBeDefined();
+    }
+  });
+});
+
 describe('runLocalReview - detached HEAD handling', () => {
   beforeEach(() => {
     vi.mock('execa');

package/src/index.js

@@ -22,6 +22,28 @@ export { detectCIProvider, truncateFileData, formatErrorOutput, getPrUrl } from
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
 
+/**
+ * Fetch file processing rules from the API.
+ * These rules control which files to skip, which to show diff-only, etc.
+ * @param {string} apiEndpoint - The API endpoint URL
+ * @param {string} apiKey - The API key for authentication
+ * @returns {Promise<Object|null>} - Config object or null if fetch fails
+ */
+async function fetchFileRulesConfig(apiEndpoint, apiKey) {
+  try {
+    const configEndpoint = apiEndpoint.replace(/\/review\/?$/, '/config/file-rules');
+    const response = await axios.get(configEndpoint, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      timeout: 3000,
+    });
+    return response.data;
+  } catch {
+    // Non-fatal: continue without filtering if config unavailable
+    log(chalk.yellow('Warning: Could not fetch file rules config.'));
+    return null;
+  }
+}
+
 /**
  * Helper functions for clean output separation:
  * - log() writes to stderr (progress, info, errors)
@@ -157,8 +179,11 @@ program
       process.exit(1);
     }
 
+    // Fetch file rules config from API
+    const fileRulesConfig = await fetchFileRulesConfig(apiEndpoint, apiKey);
+
     // Gather all data using our git logic module
-    const payload = await runLocalReview(targetBranch, options.ignore);
+    const payload = await runLocalReview(targetBranch, options.ignore, fileRulesConfig);
 
     if (!payload) {
       log(chalk.red('Could not proceed with review due to errors during analysis.'));
@@ -334,8 +359,11 @@ async function reviewUncommitted(mode, options) {
     process.exit(1);
   }
 
+  // Fetch file rules config from API
+  const fileRulesConfig = await fetchFileRulesConfig(apiEndpoint, apiKey);
+
   const { runUncommittedReview } = await import('./git-logic.js');
-  const payload = await runUncommittedReview(mode);
+  const payload = await runUncommittedReview(mode, fileRulesConfig);
 
   if (!payload) {
     log(chalk.red('No changes found or error occurred during analysis.'));

package/src/index.test.js

@@ -153,6 +153,36 @@ describe('CLI JSON output mode', () => {
       expect(displayFile.diff).not.toContain('truncated');
       expect(displayFile.content).not.toContain('truncated');
     });
+
+    it('should handle diff-only files without content', () => {
+      const file = {
+        path: 'test.js',
+        status: 'M',
+        diff: 'some diff here',
+        // no content field - this is a diff-only file
+      };
+
+      const displayFile = truncateFileData(file);
+
+      expect(displayFile.path).toBe('test.js');
+      expect(displayFile.status).toBe('M');
+      expect(displayFile.diff).toBe('some diff here');
+      expect(displayFile.content).toBeUndefined();
+    });
+
+    it('should handle files with neither diff nor content', () => {
+      const file = {
+        path: 'deleted.js',
+        status: 'D',
+      };
+
+      const displayFile = truncateFileData(file);
+
+      expect(displayFile.path).toBe('deleted.js');
+      expect(displayFile.status).toBe('D');
+      expect(displayFile.diff).toBeUndefined();
+      expect(displayFile.content).toBeUndefined();
+    });
   });
 
   describe('error formatting for JSON mode', () => {

package/src/utils.js

@@ -73,19 +73,27 @@ export function getPrUrl() {
  * @returns {Object} File object with truncated diff and content
  */
 export function truncateFileData(file, maxLength = 500) {
-  return {
+  const result = {
     path: file.path,
     status: file.status,
     ...(file.old_path && { old_path: file.old_path }),
-    diff:
+  };
+
+  if (file.diff) {
+    result.diff =
       file.diff.length > maxLength
         ? `${file.diff.substring(0, maxLength)}... [truncated ${file.diff.length - maxLength} chars]`
-        : file.diff,
-    content:
+        : file.diff;
+  }
+
+  if (file.content) {
+    result.content =
       file.content.length > maxLength
         ? `${file.content.substring(0, maxLength)}... [truncated ${file.content.length - maxLength} chars]`
-        : file.content,
-  };
+        : file.content;
+  }
+
+  return result;
 }
 
 /**