@herodevs/cli 2.0.0-beta.8 → 2.0.0

package/dist/commands/report/committers.js

@@ -0,0 +1,215 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import { Command, Flags } from '@oclif/core';
+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';
+    static enableJsonFlag = true;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --csv -s',
+        '<%= config.bin %> <%= command.id %> --json',
+        '<%= 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. Cannot be used along beforeDate and afterDate',
+            default: 12,
+            exclusive: ['beforeDate', 'afterDate', 's', 'e'],
+        }),
+        csv: Flags.boolean({
+            char: 'c',
+            description: 'Output in CSV format',
+            default: false,
+        }),
+        save: Flags.boolean({
+            char: 's',
+            description: `Save the committers report as ${filenamePrefix}.committers.<output>`,
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Committers);
+        const { afterDate, beforeDate, exclude, directory: cwd, monthly, months, csv, save } = flags;
+        const isJson = this.jsonEnabled();
+        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 {
+            const entries = this.fetchGitCommitData(afterDateStartOfDay, beforeDateEndOfDay, ignores, cwd);
+            if (entries.length === 0) {
+                return `No commits found between ${afterDate} and ${beforeDate}`;
+            }
+            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,
+                            },
+                        });
+                    }
+                    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,
+                            },
+                        });
+                    }
+                    break;
+            }
+            if (save) {
+                try {
+                    fs.writeFileSync(`${filenamePrefix}.${monthly ? 'monthly' : 'committers'}.${reportFormat}`, finalReport, {
+                        encoding: 'utf-8',
+                    });
+                    this.log(`Report written to ${reportFormat.toUpperCase()}`);
+                }
+                catch (err) {
+                    this.error(`Failed to save ${reportFormat.toUpperCase()} report: ${getErrorMessage(err)}`);
+                }
+            }
+            this.log(finalReport);
+            return finalReport;
+        }
+        catch (error) {
+            this.error(`Failed to generate report: ${getErrorMessage(error)}`);
+        }
+    }
+    /**
+     * 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, beforeDateEndOfDay, ignores, cwd) {
+        const logParameters = [
+            'log',
+            `--since="${sinceDate}"`,
+            `--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') {
+                    this.error('Git command not found. Please ensure git is installed and available in your PATH.');
+                }
+                this.error(`Git command failed: ${getErrorMessage(logProcess.error)}`);
+            }
+            this.error(`Git command failed: ${getErrorMessage(logProcess.error)}`);
+        }
+        if (logProcess.status !== 0) {
+            this.error(`Git command failed with status ${logProcess.status}: ${logProcess.stderr}`);
+        }
+        if (!logProcess.stdout) {
+            return [];
+        }
+        return parseGitLogOutput(logProcess.stdout);
+    }
+}

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

@@ -11,14 +11,21 @@ export default class ScanEol extends Command {
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         dir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         save: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         saveSbom: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        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;
     private displayResults;
     private getSbomFromScan;
     private getSbomFromFile;

package/dist/commands/scan/eol.js

@@ -1,12 +1,14 @@
 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, formatScanResults, formatWebReportUrl } from "../../service/display.svc.js";
-import { readSbomFromFile, saveReportToFile, saveSbomToFile, validateDirectory } from "../../service/file.svc.js";
+import { countComponentsByStatus, formatDataPrivacyLink, formatReportSaveHint, formatScanResults, formatWebReportUrl, } from "../../service/display.svc.js";
+import { readSbomFromFile, saveArtifactToFile, validateDirectory } from "../../service/file.svc.js";
 import { getErrorMessage } from "../../service/log.svc.js";
 export default class ScanEol extends Command {
     static description = 'Scan a given SBOM for EOL data';
@@ -30,7 +32,7 @@ export default class ScanEol extends Command {
     static flags = {
         file: Flags.string({
             char: 'f',
-            description: 'The file path of an existing cyclonedx SBOM to scan for EOL',
+            description: 'The file path of an existing SBOM to scan for EOL (supports CycloneDX and SPDX 2.3 formats)',
             exclusive: ['dir'],
         }),
         dir: Flags.string({
@@ -45,19 +47,45 @@ export default class ScanEol extends Command {
             default: false,
             description: `Save the generated report as ${filenamePrefix}.report.json in the scanned directory`,
         }),
+        output: Flags.string({
+            char: 'o',
+            description: `Save the generated report to a custom path (defaults to ${filenamePrefix}.report.json when not provided)`,
+        }),
         saveSbom: Flags.boolean({
             aliases: ['save-sbom'],
             default: false,
             description: `Save the generated SBOM as ${filenamePrefix}.sbom.json in the scanned directory`,
         }),
+        sbomOutput: Flags.string({
+            aliases: ['sbom-output'],
+            description: `Save the generated SBOM to a custom path (defaults to ${filenamePrefix}.sbom.json when not provided)`,
+        }),
+        saveTrimmedSbom: Flags.boolean({
+            aliases: ['save-trimmed-sbom'],
+            default: false,
+            description: `Save the trimmed SBOM as ${filenamePrefix}.sbom-trimmed.json in the scanned directory`,
+        }),
+        hideReportUrl: Flags.boolean({
+            aliases: ['hide-report-url'],
+            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,
-            scan_location: flags.dir,
         }));
         const sbomStartTime = performance.now();
         const sbom = await this.loadSbom();
@@ -66,22 +94,39 @@ export default class ScanEol extends Command {
             track('CLI SBOM Generated', (context) => ({
                 command: context.command,
                 command_flags: context.command_flags,
-                scan_location: flags.dir,
                 sbom_generation_time: (sbomEndTime - sbomStartTime) / 1000,
             }));
         }
+        let reportOutputPath = flags.output;
+        let sbomOutputPath = flags.sbomOutput;
+        if (flags.output && !flags.save) {
+            this.warn('--output requires --save to write the report. Run again with --save to create the file.');
+            reportOutputPath = undefined;
+        }
+        if (flags.sbomOutput && !flags.saveSbom) {
+            this.warn('--sbomOutput requires --saveSbom to write the SBOM. Run again with --saveSbom to create the file.');
+            sbomOutputPath = undefined;
+        }
+        const shouldSaveSbom = !flags.file && flags.saveSbom;
+        if (shouldSaveSbom) {
+            const sbomPath = this.saveSbom(flags.dir, sbom, sbomOutputPath);
+            this.log(`SBOM saved to ${sbomPath}`);
+            track('CLI SBOM Output Saved', (context) => ({
+                command: context.command,
+                command_flags: context.command_flags,
+                sbom_output_path: sbomPath,
+            }));
+        }
         if (!sbom.components?.length) {
             track('CLI EOL Scan Ended, No Components Found', (context) => ({
                 command: context.command,
                 command_flags: context.command_flags,
-                scan_location: flags.dir,
             }));
             this.log('No components found in scan. Report not generated.');
             return;
         }
         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,
@@ -91,13 +136,14 @@ export default class ScanEol extends Command {
             nes_available_count: componentCounts.NES_AVAILABLE,
             number_of_packages: componentCounts.TOTAL,
             sbom_created: !flags.file,
-            scan_location: flags.dir,
-            scan_load_time: (scanEndTime - scanStartTime) / 1000,
+            scan_load_time: this.getScanLoadTime(scanStartTime),
             scanned_ecosystems: componentCounts.ECOSYSTEMS,
-            web_report_link: scan.id ? `${config.eolReportUrl}/${scan.id}` : undefined,
+            web_report_link: !flags.hideReportUrl && scan.id ? `${config.eolReportUrl}/${scan.id}` : undefined,
+            web_report_hidden: flags.hideReportUrl,
         }));
-        if (flags.save) {
-            const reportPath = this.saveReport(scan, flags.dir);
+        const shouldSaveReport = flags.save;
+        if (shouldSaveReport) {
+            const reportPath = this.saveReport(scan, flags.dir, reportOutputPath);
             this.log(`Report saved to ${reportPath}`);
             track('CLI JSON Scan Output Saved', (context) => ({
                 command: context.command,
@@ -105,17 +151,8 @@ export default class ScanEol extends Command {
                 report_output_path: reportPath,
             }));
         }
-        if (flags.saveSbom && !flags.file) {
-            const sbomPath = this.saveSbom(flags.dir, sbom);
-            this.log(`SBOM saved to ${sbomPath}`);
-            track('CLI SBOM Output Saved', (context) => ({
-                command: context.command,
-                command_flags: context.command_flags,
-                sbom_output_path: sbomPath,
-            }));
-        }
         if (!this.jsonEnabled()) {
-            this.displayResults(scan);
+            this.displayResults(scan, flags.hideReportUrl, Boolean(reportOutputPath || sbomOutputPath));
         }
         return scan;
     }
@@ -132,27 +169,58 @@ export default class ScanEol extends Command {
         return sbom;
     }
     async scanSbom(sbom) {
-        const spinner = ora().start('Scanning for EOL packages');
+        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);
+        spinner.succeed('SBOM trimmed');
+        if (flags.saveTrimmedSbom) {
+            const trimmedPath = this.saveTrimmedSbom(flags.dir, trimmedSbom);
+            this.log(`Trimmed SBOM saved to ${trimmedPath}`);
+            track('CLI Trimmed SBOM Output Saved', (context) => ({
+                command: context.command,
+                command_flags: context.command_flags,
+            }));
+        }
+        spinner.start('Scanning for EOL packages');
         try {
-            const scan = await submitScan({ sbom: trimCdxBom(sbom) });
+            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_location: context.scan_location,
                 scan_failure_reason: errorMessage,
+                scan_load_time: scanLoadTime,
+                number_of_packages: numberOfPackages,
             }));
             this.error(`Failed to submit scan to NES. ${errorMessage}`);
         }
     }
-    saveReport(report, dir) {
+    getScanLoadTime(scanStartTime) {
+        return (performance.now() - scanStartTime) / 1000;
+    }
+    saveReport(report, dir, outputPath) {
         try {
-            return saveReportToFile(dir, report);
+            return saveArtifactToFile(dir, { kind: 'report', payload: report, outputPath });
         }
         catch (error) {
             const errorMessage = getErrorMessage(error);
@@ -160,9 +228,9 @@ export default class ScanEol extends Command {
             this.error(errorMessage);
         }
     }
-    saveSbom(dir, sbom) {
+    saveSbom(dir, sbom, outputPath) {
         try {
-            return saveSbomToFile(dir, sbom);
+            return saveArtifactToFile(dir, { kind: 'sbom', payload: sbom, outputPath });
         }
         catch (error) {
             const errorMessage = getErrorMessage(error);
@@ -170,17 +238,37 @@ export default class ScanEol extends Command {
             this.error(errorMessage);
         }
     }
-    displayResults(report) {
+    saveTrimmedSbom(dir, sbom) {
+        try {
+            return saveArtifactToFile(dir, { kind: 'sbomTrimmed', payload: sbom });
+        }
+        catch (error) {
+            const errorMessage = getErrorMessage(error);
+            track('CLI Error Encountered', () => ({ error: errorMessage }));
+            this.error(errorMessage);
+        }
+    }
+    displayResults(report, hideReportUrl, hasCustomOutput) {
         const lines = formatScanResults(report);
         for (const line of lines) {
             this.log(line);
         }
-        if (report.id) {
+        if (!hideReportUrl && report.id) {
             const lines = formatWebReportUrl(report.id, config.eolReportUrl);
             for (const line of lines) {
                 this.log(line);
             }
         }
+        else if (hideReportUrl && !hasCustomOutput) {
+            const lines = formatReportSaveHint();
+            for (const line of lines) {
+                this.log(line);
+            }
+        }
+        const privacyLines = formatDataPrivacyLink();
+        for (const line of privacyLines) {
+            this.log(line);
+        }
         this.log('* Use --json to output the report payload');
         this.log(`* Use --save to save the report to ${filenamePrefix}.report.json`);
         this.log('* Use --help for more commands or options');

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;
+}