@herodevs/cli 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/commands/report/committers.js

@@ -1,9 +1,10 @@
 import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
-import path from 'node:path';
 import { Command, Flags } from '@oclif/core';
-import { filenamePrefix } from "../../config/constants.js";
-import { calculateOverallStats, formatAsCsv, formatAsText, groupCommitsByMonth, parseGitLogOutput, } from "../../service/committers.svc.js";
+import { makeTable } from '@oclif/table';
+import { endOfDay, formatDate, formatISO, parse, subMonths } from 'date-fns';
+import { DEFAULT_DATE_COMMIT_FORMAT, DEFAULT_DATE_FORMAT, filenamePrefix, GIT_OUTPUT_FORMAT, } from "../../config/constants.js";
+import { generateCommittersReport, generateMonthlyReport, parseGitLogOutput, } from "../../service/committers.svc.js";
 import { getErrorMessage, isErrnoException } from "../../service/error.svc.js";
 export default class Committers extends Command {
     static description = 'Generate report of committers to a git repository';
@@ -15,10 +16,39 @@ export default class Committers extends Command {
         '<%= config.bin %> <%= command.id %> --csv',
     ];
     static flags = {
+        beforeDate: Flags.string({
+            char: 's',
+            default: formatDate(new Date(), DEFAULT_DATE_FORMAT),
+            description: `End date (format: ${DEFAULT_DATE_FORMAT})`,
+        }),
+        afterDate: Flags.string({
+            char: 'e',
+            default: formatDate(subMonths(new Date(), 12), DEFAULT_DATE_FORMAT),
+            description: `Start date (format: ${DEFAULT_DATE_FORMAT})`,
+        }),
+        exclude: Flags.string({
+            char: 'x',
+            description: 'Path Exclusions (eg -x="./src/bin" -x="./dist")',
+            multiple: true,
+            multipleNonGreedy: true,
+        }),
+        json: Flags.boolean({
+            description: 'Output to JSON format',
+            default: false,
+        }),
+        directory: Flags.string({
+            char: 'd',
+            description: 'Directory to search',
+        }),
+        monthly: Flags.boolean({
+            description: 'Break down by calendar month.',
+            default: false,
+        }),
         months: Flags.integer({
             char: 'm',
-            description: 'The number of months of git history to review',
+            description: 'The number of months of git history to review. Cannot be used along beforeDate and afterDate',
             default: 12,
+            exclusive: ['beforeDate', 'afterDate', 's', 'e'],
         }),
         csv: Flags.boolean({
             char: 'c',
@@ -33,100 +63,138 @@ export default class Committers extends Command {
     };
     async run() {
         const { flags } = await this.parse(Committers);
-        const { months, csv, save } = flags;
+        const { afterDate, beforeDate, exclude, directory: cwd, monthly, months, csv, save } = flags;
         const isJson = this.jsonEnabled();
-        const sinceDate = `${months} months ago`;
-        this.log('Starting committers report with flags: %O', flags);
+        const reportFormat = isJson ? 'json' : csv ? 'csv' : 'txt';
+        const afterDateStartOfDay = months
+            ? `${subMonths(new Date(), months)}`
+            : `${parse(afterDate, DEFAULT_DATE_FORMAT, new Date())}`;
+        const beforeDateEndOfDay = formatISO(endOfDay(parse(beforeDate, DEFAULT_DATE_FORMAT, new Date())));
+        const ignores = exclude && exclude.length > 0 ? `. "!(${exclude.join('|')})"` : undefined;
         try {
-            // Generate structured report data
-            const entries = this.fetchGitCommitData(sinceDate);
-            this.log('Fetched %d commit entries', entries.length);
-            const reportData = this.generateReportData(entries);
-            // Handle different output scenarios
-            if (isJson) {
-                // JSON mode
-                if (save) {
-                    try {
-                        fs.writeFileSync(path.resolve(`${filenamePrefix}.committers.json`), JSON.stringify(reportData, null, 2));
-                        this.log('Report written to json');
-                    }
-                    catch (error) {
-                        this.error(`Failed to save JSON report: ${getErrorMessage(error)}`);
-                    }
-                }
-                return reportData;
+            const entries = this.fetchGitCommitData(afterDateStartOfDay, beforeDateEndOfDay, ignores, cwd);
+            if (entries.length === 0) {
+                return `No commits found between ${afterDate} and ${beforeDate}`;
             }
-            const textOutput = formatAsText(reportData);
-            if (csv) {
-                // CSV mode
-                const csvOutput = formatAsCsv(reportData);
-                if (save) {
-                    try {
-                        fs.writeFileSync(path.resolve(`${filenamePrefix}.committers.csv`), csvOutput);
-                        this.log('Report written to csv');
+            this.log('\nFetched %d commit entries\n', entries.length);
+            const reportData = monthly ? generateMonthlyReport(entries) : generateCommittersReport(entries);
+            let finalReport;
+            switch (reportFormat) {
+                case 'json':
+                    finalReport = JSON.stringify(reportData.map((row) => 'month' in row
+                        ? {
+                            month: row.month,
+                            start: row.start,
+                            end: row.end,
+                            committers: row.committers,
+                        }
+                        : {
+                            name: row.author,
+                            count: row.commits.length,
+                            lastCommitDate: formatDate(row.lastCommitOn, DEFAULT_DATE_COMMIT_FORMAT),
+                        }), null, 2);
+                    break;
+                case 'csv':
+                    finalReport = reportData
+                        .map((row, index) => 'month' in row
+                        ? `${index},${row.month},${row.start},${row.end},${row.totalCommits}`
+                        : `${index},${row.author},${row.commits.length},${formatDate(row.lastCommitOn, DEFAULT_DATE_COMMIT_FORMAT).replace(',', '')}`)
+                        .join('\n')
+                        .replace(/^/, monthly ? `(index),month,start,end,totalCommits\n` : `(index),Committer,Commits,Last Commit Date\n`);
+                    break;
+                default:
+                    if (monthly) {
+                        finalReport = makeTable({
+                            title: 'Monthly Report',
+                            data: reportData
+                                .filter((row) => 'month' in row)
+                                .map((row, index) => ({
+                                index,
+                                month: row.month,
+                                start: row.start,
+                                end: row.end,
+                                totalCommits: row.totalCommits,
+                            })),
+                            headerOptions: {
+                                color: undefined,
+                                bold: false,
+                            },
+                        });
                     }
-                    catch (error) {
-                        this.error(`Failed to save CSV report: ${getErrorMessage(error)}`);
+                    else {
+                        finalReport = makeTable({
+                            title: 'Committers Report',
+                            data: reportData
+                                .filter((row) => 'author' in row)
+                                .map((row, index) => ({
+                                index,
+                                author: row.author,
+                                commits: row.commits.length,
+                                lastCommitOn: formatDate(row.lastCommitOn, DEFAULT_DATE_COMMIT_FORMAT),
+                            })),
+                            columns: [
+                                {
+                                    key: 'index',
+                                    name: '(index)',
+                                },
+                                {
+                                    key: 'author',
+                                    name: 'Committer',
+                                },
+                                {
+                                    key: 'commits',
+                                    name: 'Commits',
+                                },
+                                {
+                                    key: 'lastCommitOn',
+                                    name: 'Last Commit Date',
+                                },
+                            ],
+                            headerOptions: {
+                                color: undefined,
+                                bold: false,
+                            },
+                        });
                     }
-                }
-                else {
-                    this.log(textOutput);
-                }
-                return csvOutput;
+                    break;
             }
             if (save) {
                 try {
-                    fs.writeFileSync(path.resolve(`${filenamePrefix}.committers.txt`), textOutput);
-                    this.log('Report written to txt');
+                    fs.writeFileSync(`${filenamePrefix}.${monthly ? 'monthly' : 'committers'}.${reportFormat}`, finalReport, {
+                        encoding: 'utf-8',
+                    });
+                    this.log(`Report written to ${reportFormat.toUpperCase()}`);
                 }
-                catch (error) {
-                    this.error(`Failed to save txt report: ${getErrorMessage(error)}`);
+                catch (err) {
+                    this.error(`Failed to save ${reportFormat.toUpperCase()} report: ${getErrorMessage(err)}`);
                 }
             }
-            else {
-                this.log(textOutput);
-            }
-            return textOutput;
+            this.log(finalReport);
+            return finalReport;
         }
         catch (error) {
             this.error(`Failed to generate report: ${getErrorMessage(error)}`);
         }
     }
-    /**
-     * Generates structured report data
-     * @param entries - parsed git log output for commits
-     */
-    generateReportData(entries) {
-        if (entries.length === 0) {
-            return { monthly: {}, overall: { total: 0 } };
-        }
-        const monthlyData = groupCommitsByMonth(entries);
-        const overallStats = calculateOverallStats(entries);
-        const grandTotal = entries.length;
-        // Format into a structured report data object
-        const report = {
-            monthly: {},
-            overall: { ...overallStats, total: grandTotal },
-        };
-        // Add monthly totals
-        for (const [month, authors] of Object.entries(monthlyData)) {
-            const monthTotal = Object.values(authors).reduce((sum, count) => sum + count, 0);
-            report.monthly[month] = { ...authors, total: monthTotal };
-        }
-        return report;
-    }
     /**
      * Fetches git commit data with month and author information
      * @param sinceDate - Date range for git log
+     * @param beforeDateEndOfDay - End date for git log
+     * @param ignores - indicate elements to exclude for git log
+     * @param cwd - directory to use for git log
      */
-    fetchGitCommitData(sinceDate) {
-        const logProcess = spawnSync('git', [
+    fetchGitCommitData(sinceDate, beforeDateEndOfDay, ignores, cwd) {
+        const logParameters = [
             'log',
-            '--all', // Include committers on all branches in the repo
-            '--format="%ad|%an"', // Format: date|author
-            '--date=format:%Y-%m', // Format date as YYYY-MM
             `--since="${sinceDate}"`,
-        ], { encoding: 'utf-8' });
+            `--until="${beforeDateEndOfDay}"`,
+            `--format=${GIT_OUTPUT_FORMAT}`,
+            ...(cwd ? ['--', cwd] : []),
+            ...(ignores ? ['--', ignores] : []),
+        ];
+        const logProcess = spawnSync('git', logParameters, {
+            encoding: 'utf-8',
+        });
         if (logProcess.error) {
             if (isErrnoException(logProcess.error)) {
                 if (logProcess.error.code === 'ENOENT') {

package/dist/commands/scan/eol.d.ts

@@ -16,11 +16,13 @@ export default class ScanEol extends Command {
         sbomOutput: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         saveTrimmedSbom: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         hideReportUrl: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        automated: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         version: import("@oclif/core/interfaces").BooleanFlag<void>;
     };
     run(): Promise<EolReport | undefined>;
     private loadSbom;
     private scanSbom;
+    private getScanLoadTime;
     private saveReport;
     private saveSbom;
     private saveTrimmedSbom;

package/dist/commands/scan/eol.js

@@ -1,9 +1,11 @@
 import { trimCdxBom } from '@herodevs/eol-shared';
 import { Command, Flags } from '@oclif/core';
 import ora from 'ora';
+import { ApiError } from "../../api/errors.js";
 import { submitScan } from "../../api/nes.client.js";
-import { config, filenamePrefix } from "../../config/constants.js";
+import { config, filenamePrefix, SCAN_ORIGIN_AUTOMATED, SCAN_ORIGIN_CLI } from "../../config/constants.js";
 import { track } from "../../service/analytics.svc.js";
+import { AUTH_ERROR_MESSAGES, getTokenForScanWithSource } from "../../service/auth.svc.js";
 import { createSbom } from "../../service/cdx.svc.js";
 import { countComponentsByStatus, formatDataPrivacyLink, formatReportSaveHint, formatScanResults, formatWebReportUrl, } from "../../service/display.svc.js";
 import { readSbomFromFile, saveArtifactToFile, validateDirectory } from "../../service/file.svc.js";
@@ -68,10 +70,19 @@ export default class ScanEol extends Command {
             default: false,
             description: 'Hide the generated web report URL for this scan',
         }),
+        automated: Flags.boolean({
+            default: false,
+            description: 'Mark scan as automated (for CI/CD pipelines)',
+        }),
         version: Flags.version(),
     };
     async run() {
         const { flags } = await this.parse(ScanEol);
+        const { source } = await getTokenForScanWithSource();
+        if (source === 'ci') {
+            this.log('CI credentials found');
+            this.log('Using CI credentials');
+        }
         track('CLI EOL Scan Started', (context) => ({
             command: context.command,
             command_flags: context.command_flags,
@@ -116,7 +127,6 @@ export default class ScanEol extends Command {
         }
         const scanStartTime = performance.now();
         const scan = await this.scanSbom(sbom);
-        const scanEndTime = performance.now();
         const componentCounts = countComponentsByStatus(scan);
         track('CLI EOL Scan Completed', (context) => ({
             command: context.command,
@@ -126,7 +136,7 @@ export default class ScanEol extends Command {
             nes_available_count: componentCounts.NES_AVAILABLE,
             number_of_packages: componentCounts.TOTAL,
             sbom_created: !flags.file,
-            scan_load_time: (scanEndTime - scanStartTime) / 1000,
+            scan_load_time: this.getScanLoadTime(scanStartTime),
             scanned_ecosystems: componentCounts.ECOSYSTEMS,
             web_report_link: !flags.hideReportUrl && scan.id ? `${config.eolReportUrl}/${scan.id}` : undefined,
             web_report_hidden: flags.hideReportUrl,
@@ -159,6 +169,8 @@ export default class ScanEol extends Command {
         return sbom;
     }
     async scanSbom(sbom) {
+        const scanStartTime = performance.now();
+        const numberOfPackages = sbom.components?.length ?? 0;
         const { flags } = await this.parse(ScanEol);
         const spinner = ora().start('Trimming SBOM');
         const trimmedSbom = trimCdxBom(sbom);
@@ -173,21 +185,39 @@ export default class ScanEol extends Command {
         }
         spinner.start('Scanning for EOL packages');
         try {
-            const scan = await submitScan({ sbom: trimmedSbom });
+            const scanOrigin = flags.automated ? SCAN_ORIGIN_AUTOMATED : SCAN_ORIGIN_CLI;
+            const scan = await submitScan({ sbom: trimmedSbom, scanOrigin });
             spinner.succeed('Scan completed');
             return scan;
         }
         catch (error) {
             spinner.fail('Scanning failed');
+            const scanLoadTime = this.getScanLoadTime(scanStartTime);
+            if (error instanceof ApiError) {
+                track('CLI EOL Scan Failed', (context) => ({
+                    command: context.command,
+                    command_flags: context.command_flags,
+                    scan_failure_reason: error.code,
+                    scan_load_time: scanLoadTime,
+                    number_of_packages: numberOfPackages,
+                }));
+                const message = AUTH_ERROR_MESSAGES[error.code] ?? error.message?.trim();
+                this.error(message);
+            }
             const errorMessage = getErrorMessage(error);
             track('CLI EOL Scan Failed', (context) => ({
                 command: context.command,
                 command_flags: context.command_flags,
                 scan_failure_reason: errorMessage,
+                scan_load_time: scanLoadTime,
+                number_of_packages: numberOfPackages,
             }));
             this.error(`Failed to submit scan to NES. ${errorMessage}`);
         }
     }
+    getScanLoadTime(scanStartTime) {
+        return (performance.now() - scanStartTime) / 1000;
+    }
     saveReport(report, dir, outputPath) {
         try {
             return saveArtifactToFile(dir, { kind: 'report', payload: report, outputPath });

package/dist/commands/tracker/init.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Init extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        overwrite: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        force: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        outputDir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        configFile: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        ignorePatterns: import("@oclif/core/interfaces").OptionFlag<string[], import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/tracker/init.js

@@ -0,0 +1,84 @@
+import { confirm } from '@inquirer/prompts';
+import { Command, Flags } from '@oclif/core';
+import { TRACKER_DEFAULT_CONFIG } from '../../config/tracker.config.js';
+import { createTrackerConfig, getRootDir } from '../../service/tracker.svc.js';
+export default class Init extends Command {
+    static description = 'Initialize the tracker configuration';
+    static enableJsonFlag = false;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> -d trackerDir',
+        '<%= config.bin %> <%= command.id %> -d trackerDir -f configFileName',
+        '<%= config.bin %> <%= command.id %> -i node_modules',
+        '<%= config.bin %> <%= command.id %> -i node_modules -i custom_modules',
+        '<%= config.bin %> <%= command.id %> -o',
+    ];
+    static flags = {
+        overwrite: Flags.boolean({
+            char: 'o',
+            description: 'Overwrites the tracker configuration file if it exists',
+        }),
+        force: Flags.boolean({
+            description: 'Force tracker configuration file creation. Use with --overwrite flag',
+            dependsOn: ['overwrite'],
+        }),
+        outputDir: Flags.string({
+            char: 'd',
+            description: 'Output directory for the tracker configuration file',
+            default: 'hd-tracker',
+        }),
+        configFile: Flags.string({
+            char: 'f',
+            description: 'Filename for the tracker configuration file',
+            default: 'config.json',
+        }),
+        ignorePatterns: Flags.string({
+            char: 'i',
+            description: 'Ignore patterns to use for the tracker configuration file',
+            multiple: true,
+            multipleNonGreedy: true,
+            default: ['node_modules'],
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        const { overwrite, outputDir, configFile, ignorePatterns, force } = flags;
+        this.log('Starting tracker init command');
+        if (overwrite) {
+            if (force) {
+                this.warn(`You're using the --force flag along the --overwrite flag.`);
+            }
+            else {
+                const response = await confirm({
+                    message: `You're using the overwrite flag. If a previous configuration file exists, it will be replaced. Do you want to continue?`,
+                    default: false,
+                });
+                this.log(response ? 'Yes' : 'No');
+                if (!response) {
+                    return;
+                }
+            }
+        }
+        try {
+            const rootDir = getRootDir(global.process.cwd());
+            const outputConfig = {
+                ...TRACKER_DEFAULT_CONFIG,
+                outputDir,
+                configFile,
+                ignorePatterns,
+            };
+            await createTrackerConfig(rootDir, outputConfig, overwrite);
+            this.log(`Tracker init command completed successfully.`);
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                this.error(err, {
+                    message: err.message,
+                });
+            }
+            else {
+                this.error('An unknown error occurred while running the tracker init command');
+            }
+        }
+    }
+}

package/dist/commands/tracker/run.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Run extends Command {
+    static description: string;
+    static enableJsonFlag: boolean;
+    static examples: string[];
+    static flags: {
+        configDir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        configFile: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+    /**
+     * Fetches Git last commit
+     */
+    private fetchGitLastCommit;
+}