codeant-cli 0.1.1 → 0.1.3

package/src/utils/commonApiHelper.js

@@ -0,0 +1,84 @@
+import GitDiffHelper from './gitDiffHelper.js';
+
+/**
+ * Common base class for API helpers that transform git diff data
+ * Contains shared functionality for filtering and retrieving files
+ */
+class CommonApiHelper {
+  constructor(workspacePath) {
+    this.workspacePath = workspacePath;
+    this.gitHelper = new GitDiffHelper(workspacePath);
+  }
+
+  async init() {
+    await this.gitHelper.init();
+  }
+
+  /**
+   * Get staged files formatted for the API
+   * This is used for pre-commit hooks
+   */
+  async getStagedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'staged-only' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get all changed files formatted for the API
+   */
+  async getChangedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'branch-diff' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get uncommitted files formatted for the API
+   */
+  async getUncommittedFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'uncommitted' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Get last commit files formatted for the API
+   */
+  async getLastCommitFilesForApi() {
+    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'last-commit' });
+    return this._transformDiffsToApiFormat(diffs);
+  }
+
+  /**
+   * Transform diff info array to API format
+   * Must be implemented by subclasses
+   */
+  _transformDiffsToApiFormat(diffs) {
+    throw new Error('_transformDiffsToApiFormat must be implemented by subclass');
+  }
+
+
+  /**
+   * Get files based on scan type
+   * Returns the raw array - child classes handle filtering and wrapping
+   * @param {string} type - Type of scan (staged-only, branch-diff, etc.)
+   */
+  async getFilesForType(type = 'staged-only') {
+    switch (type) {
+      case 'staged-only':
+        return await this.getStagedFilesForApi();
+      case 'branch-diff':
+        return await this.getChangedFilesForApi();
+      case 'uncommitted':
+        return await this.getUncommittedFilesForApi();
+      case 'last-commit':
+        return await this.getLastCommitFilesForApi();
+      default:
+        return await this.getStagedFilesForApi();
+    }
+  }
+
+  getGitRoot() {
+    return this.gitHelper.getGitRoot();
+  }
+}
+
+export default CommonApiHelper;

package/src/utils/secretsApiHelper.js

@@ -1,4 +1,4 @@
-import GitDiffHelper from './gitDiffHelper.js';
+import CommonApiHelper from './commonApiHelper.js';
 import { minimatch } from 'minimatch';
 
 /**
@@ -15,49 +15,7 @@ import { minimatch } from 'minimatch';
  *   ]
  * }
  */
-class SecretsApiHelper {
-  constructor(workspacePath) {
-    this.workspacePath = workspacePath;
-    this.gitHelper = new GitDiffHelper(workspacePath);
-  }
-
-  async init() {
-    await this.gitHelper.init();
-  }
-
-  /**
-   * Get staged files formatted for the secrets API
-   * This is used for pre-commit hooks
-   */
-  async getStagedFilesForApi() {
-    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'staged-only' });
-    return this._transformDiffsToApiFormat(diffs);
-  }
-
-  /**
-   * Get all changed files formatted for the secrets API
-   */
-  async getChangedFilesForApi() {
-    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'branch-diff' });
-    return this._transformDiffsToApiFormat(diffs);
-  }
-
-  /**
-   * Get uncommitted files formatted for the secrets API
-   */
-  async getUncommittedFilesForApi() {
-    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'uncommitted' });
-    return this._transformDiffsToApiFormat(diffs);
-  }
-
-  /**
-   * Get last commit files formatted for the secrets API
-   */
-  async getLastCommitFilesForApi() {
-    const diffs = await this.gitHelper.getDiffBasedOnReviewConfig({ type: 'last-commit' });
-    return this._transformDiffsToApiFormat(diffs);
-  }
-
+class SecretsApiHelper extends CommonApiHelper {
   /**
    * Transform diff info array to API format
    * Groups by file and extracts diff ranges
@@ -69,6 +27,11 @@ class SecretsApiHelper {
     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,
@@ -96,24 +59,21 @@ class SecretsApiHelper {
 
   /**
    * Filter files based on include and exclude glob patterns
-   * @param {Array} files - Array of file objects with file_path property
+   * @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;
+    return files.filter(fileObj => {
+      const filePath = fileObj.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);
@@ -130,11 +90,9 @@ class SecretsApiHelper {
       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);
@@ -158,23 +116,11 @@ class SecretsApiHelper {
    * @param {Array} excludePatterns - Optional array of glob patterns to exclude files
    */
   async buildSecretsApiRequest(type = 'staged-only', includePatterns = [], excludePatterns = []) {
-    let files;
-
-    switch (type) {
-      case 'staged-only':
-        files = await this.getStagedFilesForApi();
-        break;
-      case 'branch-diff':
-        files = await this.getChangedFilesForApi();
-        break;
-      case 'uncommitted':
-        files = await this.getUncommittedFilesForApi();
-        break;
-      case 'last-commit':
-        files = await this.getLastCommitFilesForApi();
-        break;
-      default:
-        files = await this.getStagedFilesForApi();
+    let files = await this.getFilesForType(type);
+
+    // Handle null/undefined return
+    if (!files || !Array.isArray(files)) {
+      files = [];
     }
 
     // Apply include/exclude filters
@@ -182,10 +128,6 @@ class SecretsApiHelper {
 
     return { files };
   }
-
-  getGitRoot() {
-    return this.gitHelper.getGitRoot();
-  }
 }
 
 export default SecretsApiHelper;

package/src/utils/securityAnalysisApiHelper.js

@@ -0,0 +1,118 @@
+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
+   */
+  async buildSecurityAnalysisApiRequest(type = 'staged-only', includePatterns = [], excludePatterns = []) {
+    let files = await this.getFilesForType(type);
+
+    // 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

@@ -0,0 +1,118 @@
+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
+   */
+  async buildStaticAnalysisApiRequest(type = 'staged-only', includePatterns = [], excludePatterns = []) {
+    let files = await this.getFilesForType(type);
+
+    // 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;