codeant-cli 0.1.0 → 0.1.2

package/README.md

@@ -68,6 +68,8 @@ codeant secrets [options]
 | `--uncommitted` | Scan all uncommitted changes |
 | `--last-commit` | Scan files from the last commit |
 | `--fail-on <level>` | Fail only on HIGH, MEDIUM, or all (default: HIGH) |
+| `--include <patterns>` | Comma-separated glob patterns to include files |
+| `--exclude <patterns>` | Comma-separated glob patterns to exclude files |
 
 **Examples:**
 
@@ -89,8 +91,21 @@ codeant secrets --fail-on MEDIUM
 
 # Fail on all secrets (except false positives)
 codeant secrets --fail-on all
+
+# Filter files using glob patterns
+codeant secrets --include '**/*.js'                           # Only JS files
+codeant secrets --exclude 'node_modules/**,*.test.js'         # Exclude patterns
+codeant secrets --include 'src/**' --exclude '*.test.*'       # Combine both
 ```
 
+**File Filtering:**
+
+Use `--include` and `--exclude` with glob patterns to filter files:
+- `*` matches any characters except `/`
+- `**` matches any characters including `/`
+- `*.{js,ts}` matches multiple extensions
+- Comma-separated for multiple patterns: `--exclude 'test/**,dist/**'`
+
 **Exit codes:**
 - `0` - No blocking secrets found (or only false positives)
 - `1` - Secrets detected that match the `--fail-on` threshold

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeant-cli",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Code review CLI tool",
   "type": "module",
   "bin": {
@@ -9,7 +9,11 @@
   "scripts": {
     "start": "node src/index.js"
   },
-  "keywords": ["cli", "code-review", "secrets"],
+  "keywords": [
+    "cli",
+    "code-review",
+    "secrets"
+  ],
   "author": "",
   "license": "MIT",
   "repository": {
@@ -22,6 +26,7 @@
   "dependencies": {
     "commander": "^12.1.0",
     "ink": "^5.0.1",
+    "minimatch": "^10.1.1",
     "open": "^10.1.0",
     "react": "^18.3.1"
   }

package/src/commands/secrets.js

@@ -4,7 +4,7 @@ import { getConfigValue } from '../utils/config.js';
 import { fetchApi } from '../utils/fetchApi.js';
 import SecretsApiHelper from '../utils/secretsApiHelper.js';
 
-export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH' }) {
+export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH', include = [], exclude = [] }) {
   const { exit } = useApp();
   const [status, setStatus] = useState('initializing');
   const [secrets, setSecrets] = useState([]);
@@ -13,12 +13,16 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH' }) {
 
   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) {
-    useEffect(() => {
-      exit(new Error('Not logged in'));
-    }, []);
-
     return React.createElement(
       Box,
       { flexDirection: 'column', padding: 1 },
@@ -37,19 +41,23 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH' }) {
   };
 
   useEffect(() => {
+    let cancelled = false;
+
     async function scanSecrets() {
       try {
+        if (cancelled) return;
         setStatus('scanning');
 
         // Initialize git helper and get staged files
         const helper = new SecretsApiHelper(process.cwd());
         await helper.init();
 
-        const requestBody = await helper.buildSecretsApiRequest(scanType);
-        setFileCount(requestBody.files.length);
+        if (cancelled) return;
+        const requestBody = await helper.buildSecretsApiRequest(scanType, include, exclude);
+        if (cancelled) return;
 
         if (requestBody.files.length === 0) {
-          setStatus('no_files');
+          if (!cancelled) setStatus('no_files');
           return;
         }
 
@@ -60,6 +68,7 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH' }) {
           requestBody
         );
 
+        if (cancelled) return;
         const detectedSecrets = response.secretsDetected || [];
 
         // Filter to only include files with actual secrets
@@ -67,16 +76,24 @@ export default function Secrets({ scanType = 'staged-only', failOn = 'HIGH' }) {
           file => file.secrets && file.secrets.length > 0
         );
 
-        setSecrets(filesWithSecrets);
-        setStatus('done');
+        if (!cancelled) {
+          setSecrets(filesWithSecrets);
+          setStatus('done');
+        }
       } catch (err) {
-        setError(err.message);
-        setStatus('error');
+        if (!cancelled) {
+          setError(err.message);
+          setStatus('error');
+        }
       }
     }
 
     scanSecrets();
-  }, []);
+
+    return () => {
+      cancelled = true;
+    };
+  }, [scanType, include, exclude]);
 
   // Handle exit after status changes
   useEffect(() => {

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,16 @@ 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 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.0');
 
 program
   .command('secrets')
@@ -22,41 +27,54 @@ program
   .option('--uncommitted', 'Scan uncommitted changes')
   .option('--last-commit', 'Scan last commit')
   .option('--fail-on <level>', 'Fail only on HIGH, MEDIUM, or all (default: HIGH)', 'HIGH')
+  .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';
 
-    render(React.createElement(Secrets, { scanType, failOn: options.failOn }));
-  });
+    const include = options.include
+      ? (Array.isArray(options.include) ? options.include : options.include.split(',')).map(s => s.trim()).filter(Boolean)
+      : [];
 
-program
-  .command('set-base-url <url>')
-  .description('Set the API base URL')
-  .action((url) => {
-    render(React.createElement(SetBaseUrl, { url }));
-  });
+    const exclude = options.exclude
+      ? (Array.isArray(options.exclude) ? options.exclude : options.exclude.split(',')).map(s => s.trim()).filter(Boolean)
+      : [];
 
-program
-  .command('get-base-url')
-  .description('Show the current API base URL')
-  .action(() => {
-    render(React.createElement(GetBaseUrl));
-  });
+    const failOn = options.failOn?.toUpperCase() || 'HIGH';
 
-program
-  .command('login')
-  .description('Login to CodeAnt')
-  .action(() => {
-    render(React.createElement(Login));
+    render(React.createElement(Secrets, { scanType, failOn, include, exclude }));
   });
 
-program
-  .command('logout')
-  .description('Logout from CodeAnt')
-  .action(() => {
-    render(React.createElement(Logout));
-  });
+  program
+    .command('set-base-url <url>')
+    .description('Set the API base URL')
+    .action((url) => {
+      render(React.createElement(SetBaseUrl, { url }));
+    });
+
+  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();
+  program.parse();
+}

package/src/utils/secretsApiHelper.js

@@ -1,4 +1,5 @@
 import GitDiffHelper from './gitDiffHelper.js';
+import { minimatch } from 'minimatch';
 
 /**
  * Transforms git diff data into the format expected by the secrets detection API
@@ -93,10 +94,70 @@ class SecretsApiHelper {
     return Array.from(fileMap.values());
   }
 
+  /**
+   * Filter files based on include and exclude glob patterns
+   * @param {Array} files - Array of file objects with file_path property
+   * @param {Array} includePatterns - Array of glob pattern strings to include
+   * @param {Array} excludePatterns - Array of glob pattern strings to exclude
+   * @returns {Array} Filtered array of files
+   */
+  _filterFiles(files, includePatterns = [], excludePatterns = []) {
+    return files.filter(file => {
+      const filePath = file.file_path;
+
+      // If include patterns are specified, file must match at least one
+      if (includePatterns.length > 0) {
+        const matchesInclude = includePatterns.some(pattern => {
+          try {
+            // If pattern is a RegExp, test it directly against the file path.
+            if (pattern instanceof RegExp) {
+              return pattern.test(filePath);
+            }
+            // Use matchBase option to match basename patterns like '*.js' for glob strings
+            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 is a RegExp, test it directly against the file path.
+            if (pattern instanceof RegExp) {
+              return pattern.test(filePath);
+            }
+            // Use matchBase option to match basename patterns like '*.js' for glob strings
+            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 secrets 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
    */
-  async buildSecretsApiRequest(type = 'staged-only') {
+  async buildSecretsApiRequest(type = 'staged-only', includePatterns = [], excludePatterns = []) {
     let files;
 
     switch (type) {
@@ -116,6 +177,9 @@ class SecretsApiHelper {
         files = await this.getStagedFilesForApi();
     }
 
+    // Apply include/exclude filters
+    files = this._filterFiles(files, includePatterns, excludePatterns);
+
     return { files };
   }