codeant-cli 0.2.3 → 0.2.5

package/src/commands/staticAnalysis.js

@@ -1,405 +0,0 @@
-import React, { useEffect, useState } from 'react';
-import { Box, Text, useApp } from 'ink';
-import { getConfigValue } from '../utils/config.js';
-import { fetchApi } from '../utils/fetchApi.js';
-import StaticAnalysisApiHelper from '../utils/staticAnalysisApiHelper.js';
-import fs from 'fs/promises';
-import path from 'path';
-
-export default function StaticAnalysis({ scanType = 'staged-only', failOn = 'CRITICAL', include = [], exclude = [], autoFix = false, lastNCommits = 1 }) {
-  const { exit } = useApp();
-  const [status, setStatus] = useState('initializing');
-  const [issues, setIssues] = useState([]);
-  const [error, setError] = useState(null);
-  const [fileCount, setFileCount] = useState(0);
-  const [fixedFiles, setFixedFiles] = useState([]);
-  const apiKey = getConfigValue('apiKey');
-
-  // Handle not logged in state
-  useEffect(() => {
-    if (!apiKey) {
-      const id = setTimeout(() => exit(new Error('Not logged in')), 0);
-      return () => clearTimeout(id);
-    }
-  }, [apiKey, exit]);
-
-  // Check if logged in
-  if (!apiKey) {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'red' }, '✗ Not logged in.'),
-      React.createElement(Text, { color: 'gray' }, 'Run "codeant login" to authenticate.'),
-    );
-  }
-
-  // Helper to check if an issue should cause failure based on failOn level
-  const shouldFailOn = (issueType) => {
-    const type = issueType?.toUpperCase();
-    const failOnUpper = failOn?.toUpperCase();
-    if (!failOnUpper || failOnUpper === 'NONE') return false;
-    if (failOnUpper === 'BLOCKER') return type === 'BLOCKER';
-    if (failOnUpper === 'CRITICAL') return type === 'BLOCKER' || type === 'CRITICAL';
-    if (failOnUpper === 'MAJOR') return type === 'BLOCKER' || type === 'CRITICAL' || type === 'MAJOR';
-    if (failOnUpper === 'MINOR') return type === 'BLOCKER' || type === 'CRITICAL' || type === 'MAJOR' || type === 'MINOR';
-    return true; // 'INFO' or 'ALL' - fail on any issue
-  };
-
-  useEffect(() => {
-    let cancelled = false;
-
-    async function scanCode() {
-      try {
-        if (cancelled) return;
-        setStatus('scanning');
-
-        // Initialize git helper and get files
-        const helper = new StaticAnalysisApiHelper(process.cwd());
-        await helper.init();
-
-        if (cancelled) return;
-        const requestBody = await helper.buildStaticAnalysisApiRequest(scanType, include, exclude, { lastNCommits });
-        setFileCount(requestBody.filesData.length);
-
-        if (requestBody.filesData.length === 0) {
-          if (!cancelled) setStatus('no_files');
-          return;
-        }
-
-        // Call the static analysis API
-        const response = await fetchApi(
-          '/extension/prReview/static-analysis',
-          'POST',
-          requestBody,
-        );
-
-        if (cancelled) return;
-        const codeSuggestions = response.codeSuggestions || [];
-
-        // Filter to only include files with actual issues
-        const filesWithIssues = codeSuggestions.filter(
-          file => file.issues && file.issues.length > 0,
-        );
-
-        // Auto-fix issues if enabled
-        const fixedFilesList = [];
-        if (autoFix && filesWithIssues.length > 0) {
-          const gitRoot = helper.getGitRoot();
-
-          for (const fileData of filesWithIssues) {
-            const fixableIssues = fileData.issues.filter(
-              issue => issue.fixAvailable && issue.fix?.inputFileEdits?.length > 0
-            );
-
-            if (fixableIssues.length > 0) {
-              try {
-                const filePath = path.join(gitRoot, fileData.file);
-                let fileContent = await fs.readFile(filePath, 'utf8');
-                const lines = fileContent.split('\n');
-
-                // Collect all text edits from all issues
-                const allEdits = [];
-                for (const issue of fixableIssues) {
-                  for (const fileEdit of issue.fix.inputFileEdits) {
-                    if (fileEdit.target === fileData.file) {
-                      for (const textEdit of fileEdit.textEdits) {
-                        allEdits.push({
-                          textRange: textEdit.textRange,
-                          newText: textEdit.newText,
-                        });
-                      }
-                    }
-                  }
-                }
-
-                // Sort edits by position (descending) to avoid offset issues
-                allEdits.sort((a, b) => {
-                  if (b.textRange.startLine !== a.textRange.startLine) {
-                    return b.textRange.startLine - a.textRange.startLine;
-                  }
-                  if (b.textRange.startLineOffset !== a.textRange.startLineOffset) {
-                    return b.textRange.startLineOffset - a.textRange.startLineOffset;
-                  }
-                  if (b.textRange.endLine !== a.textRange.endLine) {
-                    return b.textRange.endLine - a.textRange.endLine;
-                  }
-                  return b.textRange.endLineOffset - a.textRange.endLineOffset;
-                });
-
-                // Apply each edit
-                for (const edit of allEdits) {
-                  const { startLine, startLineOffset, endLine, endLineOffset } = edit.textRange;
-
-                  if (startLine === endLine) {
-                    // Single line edit
-                    const line = lines[startLine - 1];
-                    lines[startLine - 1] =
-                      line.substring(0, startLineOffset) +
-                      edit.newText +
-                      line.substring(endLineOffset);
-                  } else {
-                    // Multi-line edit
-                    const firstLine = lines[startLine - 1];
-                    const lastLine = lines[endLine - 1];
-
-                    const newContent =
-                      firstLine.substring(0, startLineOffset) +
-                      edit.newText +
-                      lastLine.substring(endLineOffset);
-
-                    // Replace the lines
-                    lines.splice(startLine - 1, endLine - startLine + 1, newContent);
-                  }
-                }
-
-                await fs.writeFile(filePath, lines.join('\n'), 'utf8');
-                fixedFilesList.push({
-                  file: fileData.file,
-                  fixedCount: fixableIssues.length,
-                });
-              } catch (err) {
-                console.error(`Failed to fix ${fileData.file}: ${err.message}`);
-              }
-            }
-          }
-        }
-
-        if (!cancelled) {
-          setFixedFiles(fixedFilesList);
-          setIssues(filesWithIssues);
-          setStatus('done');
-        }
-      } catch (err) {
-        if (!cancelled) {
-          setError(err.message);
-          setStatus('error');
-        }
-      }
-    }
-
-    scanCode();
-
-    return () => {
-      cancelled = true;
-    };
-  }, [scanType, include, exclude, autoFix, lastNCommits]);
-
-  // Handle exit after status changes
-  useEffect(() => {
-    if (status === 'done') {
-      // Check if any issues should cause failure based on failOn level
-      const hasBlockingIssues = issues.some(file =>
-        file.issues.some(issue => shouldFailOn(issue.type)),
-      );
-
-      if (hasBlockingIssues) {
-        setTimeout(() => {
-          process.exitCode = 1;
-          exit(new Error('Code issues detected'));
-        }, 100);
-      } else {
-        setTimeout(() => exit(), 100);
-      }
-    } else if (status === 'no_files') {
-      setTimeout(() => exit(), 100);
-    } else if (status === 'error') {
-      setTimeout(() => exit(new Error(error)), 100);
-    }
-  }, [status, issues, failOn, exit, shouldFailOn, error]);
-
-  // Render: Initializing
-  if (status === 'initializing') {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'cyan' }, 'Initializing...'),
-    );
-  }
-
-  // Render: Scanning
-  if (status === 'scanning') {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'cyan' }, `Analyzing ${fileCount} file(s)...`),
-    );
-  }
-
-  // Render: No files to scan
-  if (status === 'no_files') {
-    const noFilesMessages = {
-      'staged-only': 'Stage some changes first with "git add".',
-      'branch-diff': 'No changes found compared to the base branch.',
-      'uncommitted': 'No uncommitted changes found.',
-      'last-commit': 'No files found in the last commit.',
-    };
-
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'yellow' }, 'No files to scan.'),
-      React.createElement(Text, { color: 'gray' }, noFilesMessages[scanType] || 'No files found.'),
-    );
-  }
-
-  // Render: Error
-  if (status === 'error') {
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      React.createElement(Text, { color: 'red' }, '✗ Error: ', error),
-    );
-  }
-
-  // Render: Done with issues found
-  if (status === 'done' && issues.length > 0) {
-    const allIssues = issues.flatMap(file =>
-      file.issues.map(i => ({ ...i, file_path: file.file })),
-    );
-
-    const blockingIssues = allIssues.filter(i => shouldFailOn(i.type));
-    const nonBlockingIssues = allIssues.filter(i => !shouldFailOn(i.type));
-
-    const hasBlockingIssues = blockingIssues.length > 0;
-
-    // Group by file for display
-    const groupByFile = (issuesList) => {
-      const grouped = Object.create(null);
-      issuesList.forEach(i => {
-        if (!grouped[i.file_path]) grouped[i.file_path] = [];
-        grouped[i.file_path].push(i);
-      });
-      return grouped;
-    };
-
-    const blockingByFile = groupByFile(blockingIssues);
-    const nonBlockingByFile = groupByFile(nonBlockingIssues);
-
-    // Helper to get color based on issue type
-    const getIssueColor = (type) => {
-      const t = type?.toUpperCase();
-      if (t === 'BLOCKER') return 'red';
-      if (t === 'CRITICAL') return 'red';
-      if (t === 'MAJOR') return 'red';
-      if (t === 'MINOR') return 'yellow';
-      return 'gray';
-    };
-
-    const elements = [
-      // Header
-      React.createElement(
-        Text,
-        { key: 'header', color: hasBlockingIssues ? 'red' : 'yellow', bold: true },
-        hasBlockingIssues
-          ? `✗ ${blockingIssues.length} issue(s) found!`
-          : `⚠ ${nonBlockingIssues.length} issue(s) found (not blocking)`,
-      ),
-      React.createElement(Text, { key: 'spacer1' }, ''),
-    ];
-
-    // Blocking issues
-    if (blockingIssues.length > 0) {
-      Object.entries(blockingByFile).forEach(([filePath, fileIssues]) => {
-        elements.push(
-          React.createElement(Text, { key: `file-${filePath}`, color: 'yellow', bold: true }, filePath),
-        );
-        fileIssues.forEach((issue, idx) => {
-          const color = getIssueColor(issue.type);
-          elements.push(
-            React.createElement(
-              Text,
-              { key: `issue-${filePath}-${idx}`, color },
-              `  Line ${issue.line_number}: ${issue.issue_text} (${issue.type})`,
-            ),
-          );
-          // Show fix suggestion if available
-          if (issue.fixAvailable && issue.fix?.message) {
-            elements.push(
-              React.createElement(
-                Text,
-                { key: `fix-${filePath}-${idx}`, color: 'green', dimColor: true },
-                `    💡 ${issue.fix.message}`,
-              ),
-            );
-          }
-        });
-      });
-    }
-
-    // Non-blocking issues
-    if (nonBlockingIssues.length > 0) {
-      if (blockingIssues.length > 0) {
-        elements.push(React.createElement(Text, { key: 'spacer2' }, ''));
-      }
-      elements.push(
-        React.createElement(Text, { key: 'nb-header', color: 'gray' }, 'Additional issues (not blocking):')
-      );
-      Object.entries(nonBlockingByFile).forEach(([filePath, fileIssues]) => {
-        elements.push(
-          React.createElement(Text, { key: `nb-file-${filePath}`, color: 'gray' }, `  ${filePath}`)
-        );
-        fileIssues.forEach((issue, idx) => {
-          elements.push(
-            React.createElement(
-              Text,
-              { key: `nb-issue-${filePath}-${idx}`, color: 'gray', dimColor: true },
-              `    Line ${issue.line_number}: ${issue.issue_text} (${issue.type})`
-            )
-          );
-        });
-      });
-    }
-
-    elements.push(React.createElement(Text, { key: 'spacer3' }, ''));
-
-    // Show auto-fix summary
-    if (fixedFiles.length > 0) {
-      const totalFixed = fixedFiles.reduce((sum, f) => sum + f.fixedCount, 0);
-      elements.push(
-        React.createElement(Text, { key: 'autofix', color: 'green' }, `✓ Auto-fixed ${totalFixed} issue(s) in ${fixedFiles.length} file(s)`)
-      );
-      elements.push(React.createElement(Text, { key: 'spacer4' }, ''));
-    }
-
-    if (hasBlockingIssues) {
-      // TODO: change message based on whether auto-fix fixed some issues or not
-      const message = (fixedFiles.length > 0)
-        ? `✓ Fixed issues automatically. Please review changes before committing.`
-        : `Fix issues before committing.`;
-      elements.push(
-        React.createElement(Text, { key: 'footer', color: 'red' }, message)
-      );
-    } else {
-      elements.push(
-        React.createElement(Text, { key: 'footer', color: 'green' }, '✓ Commit allowed (no blocking issues)')
-      );
-    }
-
-    return React.createElement(
-      Box,
-      { flexDirection: 'column', padding: 1 },
-      ...elements
-    );
-  }
-
-  // Render: Done with no issues
-  const elements = [];
-
-  if (fixedFiles.length > 0) {
-    const totalFixed = fixedFiles.reduce((sum, f) => sum + f.fixedCount, 0);
-    elements.push(
-      React.createElement(Text, { key: 'autofix', color: 'green' }, `✓ Auto-fixed ${totalFixed} issue(s) in ${fixedFiles.length} file(s)`)
-    );
-    elements.push(React.createElement(Text, { key: 'spacer' }, ''));
-  }
-
-  elements.push(
-    React.createElement(Text, { key: 'no-issues', color: 'green' }, '✓ No issues found')
-  );
-
-  return React.createElement(
-    Box,
-    { flexDirection: 'column', padding: 1 },
-    ...elements
-  );
-}

package/src/utils/securityAnalysisApiHelper.js

@@ -1,119 +0,0 @@
-import CommonApiHelper from './commonApiHelper.js';
-import { minimatch } from 'minimatch';
-
-/**
- * Transforms git diff data into the format expected by the static analysis API
- *
- * API Input Format:
- * {
- *   "filesData": [
- *     {
- *       "file": str,
- *       "code": str
- *     }
- *   ]
- * }
- */
-class SecurityAnalysisApiHelper extends CommonApiHelper {
-  /**
-   * Transform diff info array to API format
-   * Groups by file (without diff ranges for static analysis)
-   */
-  _transformDiffsToApiFormat(diffs) {
-    // Group diffs by filename
-    const fileMap = new Map();
-
-    for (const diff of diffs) {
-      const filePath = diff.filename_str;
-
-      // Skip diffs with missing or invalid filename
-      if (!filePath) {
-        continue;
-      }
-
-      if (!fileMap.has(filePath)) {
-        fileMap.set(filePath, {
-          file_path: filePath,
-          code: diff.head_file_str || ''
-        });
-      }
-    }
-
-    return Array.from(fileMap.values());
-  }
-
-  /**
-   * Filter files based on include and exclude glob patterns
-   * @param {Array} files - Array of file objects with 'file' property
-   * @param {Array} includePatterns - Array of glob pattern strings to include
-   * @param {Array} excludePatterns - Array of glob pattern strings to exclude
-   */
-  _filterFiles(files, includePatterns = [], excludePatterns = []) {
-    return files.filter(fileObj => {
-      const filePath = fileObj.file;
-
-      // If include patterns are specified, file must match at least one
-      if (includePatterns.length > 0) {
-        const matchesInclude = includePatterns.some(pattern => {
-          try {
-            if (pattern instanceof RegExp) {
-              return pattern.test(filePath);
-            }
-            return minimatch(filePath, pattern, { matchBase: true });
-          } catch (e) {
-            console.warn(`Invalid include pattern: ${pattern}`, e.message);
-            return false;
-          }
-        });
-
-        if (!matchesInclude) {
-          return false;
-        }
-      }
-
-      // If exclude patterns are specified, file must not match any
-      if (excludePatterns.length > 0) {
-        const matchesExclude = excludePatterns.some(pattern => {
-          try {
-            if (pattern instanceof RegExp) {
-              return pattern.test(filePath);
-            }
-            return minimatch(filePath, pattern, { matchBase: true });
-          } catch (e) {
-            console.warn(`Invalid exclude pattern: ${pattern}`, e.message);
-            return false;
-          }
-        });
-
-        if (matchesExclude) {
-          return false;
-        }
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Build the complete request body for the static analysis API
-   * @param {string} type - Type of scan (staged-only, branch-diff, etc.)
-   * @param {Array} includePatterns - Optional array of glob patterns to include files
-   * @param {Array} excludePatterns - Optional array of glob patterns to exclude files
-   * @param {Object} options - Additional options like lastNCommits
-   */
-  async buildSecurityAnalysisApiRequest(type = 'staged-only', includePatterns = [], excludePatterns = [], options = {}) {
-    let files = await this.getFilesForType(type, options);
-
-    // Handle null/undefined return
-    if (!files || !Array.isArray(files)) {
-      files = [];
-    }
-
-    // Apply include/exclude filters
-    files = this._filterFiles(files, includePatterns, excludePatterns);
-
-    return { files };
-  }
-}
-
-export default SecurityAnalysisApiHelper;

package/src/utils/staticAnalysisApiHelper.js

@@ -1,119 +0,0 @@
-import CommonApiHelper from './commonApiHelper.js';
-import { minimatch } from 'minimatch';
-
-/**
- * Transforms git diff data into the format expected by the static analysis API
- *
- * API Input Format:
- * {
- *   "filesData": [
- *     {
- *       "file": str,
- *       "code": str
- *     }
- *   ]
- * }
- */
-class StaticAnalysisApiHelper extends CommonApiHelper {
-  /**
-   * Transform diff info array to API format
-   * Groups by file (without diff ranges for static analysis)
-   */
-  _transformDiffsToApiFormat(diffs) {
-    // Group diffs by filename
-    const fileMap = new Map();
-
-    for (const diff of diffs) {
-      const filePath = diff.filename_str;
-
-      // Skip diffs with missing or invalid filename
-      if (!filePath) {
-        continue;
-      }
-
-      if (!fileMap.has(filePath)) {
-        fileMap.set(filePath, {
-          file: filePath,
-          code: diff.head_file_str || ''
-        });
-      }
-    }
-
-    return Array.from(fileMap.values());
-  }
-
-  /**
-   * Filter files based on include and exclude glob patterns
-   * @param {Array} files - Array of file objects with 'file' property
-   * @param {Array} includePatterns - Array of glob pattern strings to include
-   * @param {Array} excludePatterns - Array of glob pattern strings to exclude
-   */
-  _filterFiles(files, includePatterns = [], excludePatterns = []) {
-    return files.filter(fileObj => {
-      const filePath = fileObj.file;
-
-      // If include patterns are specified, file must match at least one
-      if (includePatterns.length > 0) {
-        const matchesInclude = includePatterns.some(pattern => {
-          try {
-            if (pattern instanceof RegExp) {
-              return pattern.test(filePath);
-            }
-            return minimatch(filePath, pattern, { matchBase: true });
-          } catch (e) {
-            console.warn(`Invalid include pattern: ${pattern}`, e.message);
-            return false;
-          }
-        });
-
-        if (!matchesInclude) {
-          return false;
-        }
-      }
-
-      // If exclude patterns are specified, file must not match any
-      if (excludePatterns.length > 0) {
-        const matchesExclude = excludePatterns.some(pattern => {
-          try {
-            if (pattern instanceof RegExp) {
-              return pattern.test(filePath);
-            }
-            return minimatch(filePath, pattern, { matchBase: true });
-          } catch (e) {
-            console.warn(`Invalid exclude pattern: ${pattern}`, e.message);
-            return false;
-          }
-        });
-
-        if (matchesExclude) {
-          return false;
-        }
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Build the complete request body for the static analysis API
-   * @param {string} type - Type of scan (staged-only, branch-diff, etc.)
-   * @param {Array} includePatterns - Optional array of glob patterns to include files
-   * @param {Array} excludePatterns - Optional array of glob patterns to exclude files
-   * @param {Object} options - Additional options like lastNCommits
-   */
-  async buildStaticAnalysisApiRequest(type = 'staged-only', includePatterns = [], excludePatterns = [], options = {}) {
-    let files = await this.getFilesForType(type, options);
-
-    // Handle null/undefined return
-    if (!files || !Array.isArray(files)) {
-      files = [];
-    }
-
-    // Apply include/exclude filters
-    files = this._filterFiles(files, includePatterns, excludePatterns);
-
-    return { filesData: files };
-  }
-}
-
-export default StaticAnalysisApiHelper;