codeant-cli 0.1.1 → 0.1.3

package/src/commands/staticAnalysis.js

@@ -0,0 +1,405 @@
+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 }) {
+  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);
+        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]);
+
+  // 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/components/Welcome.js

@@ -0,0 +1,143 @@
+import React, { useState, useEffect } from 'react';
+import { Text, Box, useApp } from 'ink';
+
+const logo = `
+   ___          _        _          _
+  / __\\___   __| | ___  / \\   _ __ | |_
+ / /  / _ \\ / _\` |/ _ \\/  /\\ | '_ \\| __|
+/ /__| (_) | (_| |  __/\\_/ \\ | | | | |_
+\\____/\\___/ \\__,_|\\___\\___/\\_/_| |_|\\__|
+`;
+
+const tagline = "Your AI-powered code review companion";
+
+const commands = [
+  { cmd: 'codeant secrets', desc: 'Scan for secrets in your code' },
+  { cmd: 'codeant login', desc: 'Login to CodeAnt' },
+  { cmd: 'codeant --help', desc: 'Show all commands' },
+];
+
+export default function Welcome() {
+  const { exit } = useApp();
+  const [displayedLogo, setDisplayedLogo] = useState('');
+  const [displayedTagline, setDisplayedTagline] = useState('');
+  const [showCursor, setShowCursor] = useState(true);
+  const [phase, setPhase] = useState('logo');
+  const [showCommands, setShowCommands] = useState(false);
+
+  // Typing effect for logo (fast)
+  useEffect(() => {
+    if (phase !== 'logo') return;
+
+    let i = 0;
+    const chars = logo.split('');
+    const interval = setInterval(() => {
+      if (i < chars.length) {
+        setDisplayedLogo(prev => prev + chars[i]);
+        i++;
+      } else {
+        clearInterval(interval);
+        setPhase('tagline');
+      }
+    }, 2);
+
+    return () => clearInterval(interval);
+  }, [phase]);
+
+  // Typing effect for tagline (slower, more dramatic)
+  useEffect(() => {
+    if (phase !== 'tagline') return;
+
+    let i = 0;
+    const chars = tagline.split('');
+    const interval = setInterval(() => {
+      if (i < chars.length) {
+        setDisplayedTagline(prev => prev + chars[i]);
+        i++;
+      } else {
+        clearInterval(interval);
+        setPhase('commands');
+        setShowCommands(true);
+      }
+    }, 25);
+
+    return () => clearInterval(interval);
+  }, [phase]);
+
+  // Blinking cursor
+  useEffect(() => {
+    if (phase === 'commands') {
+      setShowCursor(false);
+      return;
+    }
+    const interval = setInterval(() => {
+      setShowCursor(prev => !prev);
+    }, 400);
+    return () => clearInterval(interval);
+  }, [phase]);
+
+  // Exit after animation
+  useEffect(() => {
+    if (showCommands) {
+      const timeout = setTimeout(() => exit(), 100);
+      return () => clearTimeout(timeout);
+    }
+  }, [showCommands, exit]);
+
+  const cursor = showCursor ? '|' : ' ';
+
+  const elements = [
+    React.createElement(Text, { key: 'logo', color: 'cyan', bold: true }, displayedLogo)
+  ];
+
+  if (phase !== 'logo') {
+    elements.push(
+      React.createElement(
+        Box,
+        { key: 'tagline-box', marginTop: 0 },
+        React.createElement(
+          Text,
+          { color: 'magenta', italic: true },
+          displayedTagline,
+          React.createElement(Text, { color: 'gray' }, cursor)
+        )
+      )
+    );
+  }
+
+  if (showCommands) {
+    elements.push(
+      React.createElement(Text, { key: 'divider', color: 'gray' }, '─────────────────────────────────────────')
+    );
+
+    elements.push(
+      React.createElement(
+        Box,
+        { key: 'commands-box', marginTop: 1, flexDirection: 'column' },
+        React.createElement(Text, { color: 'yellow', bold: true }, 'Quick Start:'),
+        ...commands.map((item, idx) =>
+          React.createElement(
+            Box,
+            { key: `cmd-${idx}`, marginLeft: 2 },
+            React.createElement(Text, { color: 'green' }, `$ ${item.cmd}`),
+            React.createElement(Text, { color: 'gray' }, `  ${item.desc}`)
+          )
+        )
+      )
+    );
+
+    elements.push(
+      React.createElement(
+        Box,
+        { key: 'version-box', marginTop: 1 },
+        React.createElement(Text, { color: 'gray' }, 'v0.1.0')
+      )
+    );
+  }
+
+  return React.createElement(
+    Box,
+    { flexDirection: 'column', padding: 1 },
+    ...elements
+  );
+}

package/src/index.js

@@ -8,11 +8,18 @@ import SetBaseUrl from './commands/setBaseUrl.js';
 import GetBaseUrl from './commands/getBaseUrl.js';
 import Login from './commands/login.js';
 import Logout from './commands/logout.js';
+import StaticAnalysis from './commands/staticAnalysis.js';
+import SecurityAnalysis from './commands/securityAnalysis.js';
+import Welcome from './components/Welcome.js';
 
-program
-  .name('codeant')
-  .description('Code review CLI tool')
-  .version('0.1.0');
+// Show welcome animation if no arguments provided
+if (process.argv.length === 2) {
+  render(React.createElement(Welcome));
+} else {
+  program
+    .name('codeant')
+    .description('Code review CLI tool')
+    .version('0.1.3');
 
 program
   .command('secrets')
@@ -31,11 +38,11 @@ program
     else if (options.lastCommit) scanType = 'last-commit';
 
     const include = options.include
-      ? (Array.isArray(options.include) ? options.include : options.include.split(',')).map(s => s.trim()).filter(Boolean)
+      ? (Array.isArray(options.include) ? options.include : String(options.include).split(',')).map(s => s.trim()).filter(Boolean)
       : [];
 
     const exclude = options.exclude
-      ? (Array.isArray(options.exclude) ? options.exclude : options.exclude.split(',')).map(s => s.trim()).filter(Boolean)
+      ? (Array.isArray(options.exclude) ? options.exclude : String(options.exclude).split(',')).map(s => s.trim()).filter(Boolean)
       : [];
 
     const failOn = options.failOn?.toUpperCase() || 'HIGH';
@@ -44,31 +51,91 @@ program
   });
 
 program
-  .command('set-base-url <url>')
-  .description('Set the API base URL')
-  .action((url) => {
-    render(React.createElement(SetBaseUrl, { url }));
-  });
+  .command('static-analysis')
+  .description('Run static analysis on your code')
+  .option('--staged', 'Scan only staged files (default)')
+  .option('--all', 'Scan all changed files')
+  .option('--uncommitted', 'Scan uncommitted changes')
+  .option('--last-commit', 'Scan last commit')
+  .option('--fail-on <level>', 'Fail on issues at or above this level: BLOCKER, CRITICAL, MAJOR, MINOR, INFO (default: CRITICAL)', 'CRITICAL')
+  .option('--auto-fix', 'Automatically apply fixes when available')
+  .option('--include <paths>', 'Comma-separated list of file paths regex to include')
+  .option('--exclude <paths>', 'Comma-separated list of file paths regex to exclude')
+  .action((options) => {
+    let scanType = 'staged-only';
+    if (options.all) scanType = 'branch-diff';
+    else if (options.uncommitted) scanType = 'uncommitted';
+    else if (options.lastCommit) scanType = 'last-commit';
 
-program
-  .command('get-base-url')
-  .description('Show the current API base URL')
-  .action(() => {
-    render(React.createElement(GetBaseUrl));
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : String(options.include).split(',')).map(s => s.trim()).filter(Boolean)
+      : [];
+
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : String(options.exclude).split(',')).map(s => s.trim()).filter(Boolean)
+      : [];
+
+    const failOn = options.failOn?.toUpperCase() || 'CRITICAL';
+    const autoFix = options.autoFix || false;
+    render(React.createElement(StaticAnalysis, {scanType, failOn, include, exclude, autoFix}));
   });
 
 program
-  .command('login')
-  .description('Login to CodeAnt')
-  .action(() => {
-    render(React.createElement(Login));
+  .command('security-analysis')
+  .description('Run security analysis on your code')
+  .option('--staged', 'Scan only staged files (default)')
+  .option('--all', 'Scan all changed files')
+  .option('--uncommitted', 'Scan uncommitted changes')
+  .option('--last-commit', 'Scan last commit')
+  .option('--fail-on <level>', 'Fail on issues at or above this level: BLOCKER, CRITICAL, MAJOR, MINOR, INFO (default: CRITICAL)', 'CRITICAL')
+  .option('--include <paths>', 'Comma-separated list of file paths regex to include')
+  .option('--exclude <paths>', 'Comma-separated list of file paths regex to exclude')
+  .action((options) => {
+    let scanType = 'staged-only';
+    if (options.all) scanType = 'branch-diff';
+    else if (options.uncommitted) scanType = 'uncommitted';
+    else if (options.lastCommit) scanType = 'last-commit';
+
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : String(options.include).split(',')).map(s => s.trim()).filter(Boolean)
+      : [];
+
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : String(options.exclude).split(',')).map(s => s.trim()).filter(Boolean)
+      : [];
+
+    const failOn = options.failOn?.toUpperCase() || 'HIGH';
+
+    render(React.createElement(SecurityAnalysis, { scanType, failOn, include, exclude }));
   });
 
 program
-  .command('logout')
-  .description('Logout from CodeAnt')
-  .action(() => {
-    render(React.createElement(Logout));
+  .command('set-base-url <url>')
+  .description('Set the API base URL')
+  .action((url) => {
+    render(React.createElement(SetBaseUrl, { url }));
   });
 
-program.parse();
+  program
+    .command('get-base-url')
+    .description('Show the current API base URL')
+    .action(() => {
+      render(React.createElement(GetBaseUrl));
+    });
+
+  program
+    .command('login')
+    .description('Login to CodeAnt')
+    .action(() => {
+      render(React.createElement(Login));
+    });
+
+  program
+    .command('logout')
+    .description('Logout from CodeAnt')
+    .action(() => {
+      render(React.createElement(Logout));
+    });
+
+  program.parse();
+}