@spark-ui/cli-utils 2.14.0 → 2.15.1

package/CHANGELOG.md

@@ -3,6 +3,32 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.15.1](https://github.com/adevinta/spark/compare/@spark-ui/cli-utils@2.15.0...@spark-ui/cli-utils@2.15.1) (2024-07-03)
+
+**Note:** Version bump only for package @spark-ui/cli-utils
+
+# [2.15.0](https://github.com/adevinta/spark/compare/@spark-ui/cli-utils@2.14.0...@spark-ui/cli-utils@2.15.0) (2024-07-03)
+
+### Bug Fixes
+
+- **cli-utils:** add some feedback when not loading a given config file ([1231fe6](https://github.com/adevinta/spark/commit/1231fe6cb94c15643a11278c3210836e81059364))
+- **cli-utils:** fix config merge method to allow proper option override ([8b6a124](https://github.com/adevinta/spark/commit/8b6a124c6e70f05769305bf6ca84137c7a05510c))
+- **cli-utils:** fix logger issue on generate script after changes ([083c9b0](https://github.com/adevinta/spark/commit/083c9b043d1837a807b159a8143fd16bf8d7087e))
+- **cli-utils:** merge values ([a7e8129](https://github.com/adevinta/spark/commit/a7e81292d452d4ee026f3d4705198ac4ecc6363e))
+- **cli-utils:** merging configs ([aeb6251](https://github.com/adevinta/spark/commit/aeb6251d23bc506674e4545ebad928081292f520))
+- **cli-utils:** missalignment on the default config values nesting ([79729f7](https://github.com/adevinta/spark/commit/79729f722f4ecf6f0c671e2c1c1d5929a87d98c9))
+- **cli-utils:** output file creates new content ([973ffa8](https://github.com/adevinta/spark/commit/973ffa85e6987dbd87a119e9253db57556a705d4))
+- **cli-utils:** remove betta tagging ([96cafae](https://github.com/adevinta/spark/commit/96cafae45e4a4759ef9ff4a763963f26cb898cb6))
+- **cli-utils:** remove extra logs ([f588649](https://github.com/adevinta/spark/commit/f588649eb299fc42ef9d6dbf8f8f4eebd0cfd6a9))
+- **cli-utils:** remove unnecesary log ([614d834](https://github.com/adevinta/spark/commit/614d834d5d7a0f3084b3097e2dee5436b369fbb6))
+- log config setted ([190a058](https://github.com/adevinta/spark/commit/190a0581ab6219591c5d3a3ecde2ee46d504d7ca))
+- priority of commands ([ed178a5](https://github.com/adevinta/spark/commit/ed178a51a8cea0255c96467b0d8760daf8f851dd))
+
+### Features
+
+- **cli-utils:** exoposes all configuration parameters as a build argument ([3e88a99](https://github.com/adevinta/spark/commit/3e88a998c05da026cd196b3dd54a2ad50506266c))
+- mixing parameters ([da1bf1d](https://github.com/adevinta/spark/commit/da1bf1d838df2c577755eb3c651cd0bba8d07203))
+
 # [2.14.0](https://github.com/adevinta/spark/compare/@spark-ui/cli-utils@2.13.8...@spark-ui/cli-utils@2.14.0) (2024-06-14)
 
 ### Features

package/bin/spark-generate.mjs

@@ -6,7 +6,7 @@ import { TemplateGenerator } from '../src/generate/generators/index.mjs'
 import { Logger, System } from '../src/core/index.mjs'
 import { DescriptionValidator, NameValidator } from '../src/generate/validators/index.mjs'
 
-const logger = new Logger()
+const logger = new Logger({ verbose: true })
 const system = new System({ logger })
 const generator = new TemplateGenerator({ system })
 

package/bin/spark-scan.mjs

@@ -1,15 +1,21 @@
 #! /usr/bin/env node
 
 import { Command } from 'commander'
-import { adoption } from '../src/scan/index.mjs'
+import { adoption, config } from '../src/scan/index.mjs'
 
 const program = new Command()
 
 program
   .command('adoption')
   .description('Scan @spark-ui adoption for .tsx files with given imports')
-  .option('-c, --configuration <path>', 'configuration file route', '.spark-ui.cjs')
-  .option('-o, --output <path>', 'output file route')
+  .option('-c, --configuration <config>', 'configuration file route')
+  .option('-o, --output <output>', 'output file route')
+  .option('-v, --verbose', 'output log information', false)
+  .option('-d, --details', 'output information about each match', config.details)
+  .option('-s, --sort <sort>', 'sort results (count or alphabetical)', config.sort)
+  .option('-dir, --directory <directory>', 'directory to parse', config.directory)
+  .option('-ext, --extensions <extensions...>', 'file extensions to parse', config.extensions)
+  .option('-i, --imports <imports...>', 'import patterns to identify', config.imports)
   .action(adoption)
 
 program.parse(process.argv)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spark-ui/cli-utils",
-  "version": "2.14.0",
+  "version": "2.15.1",
   "description": "Spark CLI utils",
   "publishConfig": {
     "access": "public"
@@ -45,5 +45,5 @@
   "devDependencies": {
     "@types/fs-extra": "11.0.4"
   },
-  "gitHead": "70cbe1732252c1a1eac56af3d212fe2d33e4dcdc"
+  "gitHead": "89a5654b5e5b02d911e40ead40c608617b5bd44b"
 }

package/src/core/Logger.mjs

@@ -1,20 +1,50 @@
-/* eslint-disable no-console */
 import chalk from 'chalk'
 
 export class Logger {
-  success(message) {
-    console.log(chalk.green(message))
+  #force = false
+
+  constructor({ verbose } = {}) {
+    this.verbose = verbose
+
+    if (typeof Logger.instance === 'object') {
+      return Logger.instance
+    }
+
+    Logger.instance = this
+
+    return this
+  }
+
+  #log({ type = v => v, force, verbose }, ...args) {
+    if (force || verbose) {
+      console.log(type(...args)) // eslint-disable-line no-console
+    }
+    this.#force = false
+  }
+
+  force() {
+    this.#force = true
+
+    return this
+  }
+
+  error(...args) {
+    this.#log({ type: chalk.red, force: this.#force, verbose: this.verbose }, ...args)
+  }
+
+  warning(...args) {
+    this.#log({ type: chalk.yellow, force: this.#force, verbose: this.verbose }, ...args)
   }
 
-  error(message) {
-    console.log(chalk.red(message))
+  info(...args) {
+    this.#log({ type: chalk.cyan, force: this.#force, verbose: this.verbose }, ...args)
   }
 
-  info(message) {
-    console.log(chalk.yellow(message))
+  success(...args) {
+    this.#log({ type: chalk.green, force: this.#force, verbose: this.verbose }, ...args)
   }
 
-  warning(message) {
-    console.log(chalk.green(message))
+  break() {
+    this.#log({ type: chalk.green, force: this.#force, verbose: this.verbose }, '')
   }
 }

package/src/scan/config.cjs

@@ -0,0 +1,37 @@
+module.exports = {
+  adoption: {
+    /**
+     * Shows (or not) details about each package adoption
+     * @param {boolean}
+     * @default false
+     */
+    details: false,
+    /**
+     * Sorts packages list, based on count or alphabetical order
+     * @param {'count'|'alphabetical'}
+     * @default 'count'
+     */
+    sort: 'count',
+    /**
+     * Packages pattern to be scanned
+     * @params {string[]}
+     */
+    imports: ['@spark-ui'],
+    /**
+     * File extensions to be scanned
+     * @params {string[]}
+     */
+    extensions: ['.tsx', '.ts'],
+    /**
+     * Directory to be scanned
+     * @param {string}
+     * @default '.''
+     */
+    directory: '.',
+    /**
+     * Output file path to export the results
+     * @param {string}
+     */
+    output: null,
+  },
+}

package/src/scan/index.mjs

@@ -1,49 +1,41 @@
+/* eslint-disable complexity */
+/* eslint-disable max-lines-per-function */
 import * as process from 'node:process'
 
-import { appendFileSync, existsSync } from 'fs'
+import { existsSync, mkdirSync, writeFileSync } from 'fs'
 import path from 'path'
 
+import { Logger } from '../core/index.mjs'
+import defaultConfig from './config.cjs'
+import { loadConfig } from './loadConfig.mjs'
 import { scanCallback } from './scanCallback.mjs'
-import { logger, scanDirectories } from './utils/index.mjs'
+import { scanDirectories } from './utils/index.mjs'
 
-const DEFAULT_CONFIG = {
-  adoption: {
-    details: false,
-    sort: 'count',
-    imports: ['@spark-ui'],
-    extensions: ['.tsx', '.ts'],
-    directory: '.',
-  },
-}
+export async function adoption(options = {}) {
+  const { configuration, ...optionsConfig } = options
 
-export async function adoption(options) {
-  let config = DEFAULT_CONFIG
+  const logger = new Logger({ verbose: optionsConfig.verbose })
+  let config = await loadConfig(configuration, { logger })
 
-  const configFileRoute = path.join(process.cwd(), options.configuration || '.spark-ui.cjs')
-  try {
-    if (existsSync(configFileRoute)) {
-      logger.info('ℹ️ Loading spark-ui custom configuration file')
-      const { default: customConfig } = await import(
-        path.join(process.cwd(), options.configuration)
-      )
-      config = structuredClone(customConfig, DEFAULT_CONFIG)
-    } else {
-      logger.warn('⚠️ No custom configuration file found')
-      logger.info('ℹ️ Loading default configuration')
-    }
-  } catch (error) {
-    logger.error('💥 Something went wrong loading the custom configuration file')
+  config = {
+    adoption: {
+      ...config.adoption,
+      ...optionsConfig,
+      imports: optionsConfig.imports || config.adoption.imports,
+      extensions: optionsConfig.extensions || config.adoption.extensions,
+    },
   }
 
-  const extensions = config.adoption.extensions
-
   let importCount = 0
   const importResults = {}
   let importsUsed = {}
   let importsCount = {}
-  config.adoption.imports.forEach(moduleName => {
+
+  const { details, directory, extensions, imports, sort, output } = config.adoption
+
+  imports.forEach(moduleName => {
     logger.info(`ℹ️ Scanning adoption for ${moduleName}`)
-    const directoryPath = path.join(process.cwd(), config.adoption.directory)
+    const directoryPath = path.join(process.cwd(), directory)
 
     const response = scanDirectories(directoryPath, moduleName, extensions, scanCallback, {
       importCount,
@@ -56,7 +48,7 @@ export async function adoption(options) {
         `🎉 Found ${response.importCount - importCount} imports with "${moduleName}" modules across directory ${directoryPath}.`
       )
     } else {
-      logger.warn(
+      logger.warning(
         `⚠️ No files found with "${moduleName}" imports across directory ${directoryPath}.`
       )
     }
@@ -64,7 +56,7 @@ export async function adoption(options) {
   })
 
   // Sort importsUsed by alphabet
-  if (config.adoption.sort === 'alphabetical') {
+  if (sort === 'alphabetical') {
     importsUsed = Object.fromEntries(
       Object.entries(importsUsed)
         .sort(([pkgNameA], [pkgNameB]) => pkgNameA.localeCompare(pkgNameB))
@@ -83,7 +75,7 @@ export async function adoption(options) {
           ]
         })
     )
-  } else if (config.adoption.sort === 'count') {
+  } else if (sort === 'count') {
     // Sort importsUsed by most used
     importsUsed = Object.fromEntries(
       Object.entries(importsUsed)
@@ -110,17 +102,25 @@ export async function adoption(options) {
   const result = Object.fromEntries(
     Object.entries(importsUsed).map(([pkgName, value]) => [
       pkgName,
-      { ...value, ...(config.adoption.details && { results: importResults[pkgName] }) },
+      { ...value, ...(details && { results: importResults[pkgName] }) },
     ])
   )
 
-  if (options.output) {
+  if (output) {
     try {
-      appendFileSync(`${options.output}`, JSON.stringify(result, null, 2))
-    } catch (err) {
-      logger.error(`💥 Error writing file: ${err}`)
+      const { dir } = path.parse(path.join(process.cwd(), output))
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true })
+      }
+      writeFileSync(`${path.join(process.cwd(), output)}`, JSON.stringify(result, null, 2))
+    } catch (error) {
+      logger.error(`💥 Error writing file: ${error}`)
+      process.exit(1)
     }
   } else {
-    logger.info(JSON.stringify(result, null, 2))
+    logger.force().info(JSON.stringify(result, null, 2))
+    process.exit(0)
   }
 }
+
+export const config = { ...defaultConfig }

package/src/scan/index.test.ts

@@ -0,0 +1,157 @@
+import path from 'node:path'
+
+import fse from 'fs-extra'
+import { fileURLToPath } from 'url'
+import { beforeEach, describe, expect, it } from 'vitest'
+
+import cmd, { ENTER } from '../../test/utils/cmd'
+
+const __dirname = fileURLToPath(import.meta.url)
+const cliPath = path.join(__dirname, '../../../bin/spark.mjs')
+
+const cliProcess = cmd.create(cliPath)
+
+describe('CLI `spark scan`', () => {
+  const OUTPUT_FILE = 'report.json'
+
+  const EXT_CONFIG_FILE_PATH = 'packages/utils/cli/test/stubs/scanConfigWithCustomExtensions.js'
+  const SORT_CONFIG_FILE_PATH = 'packages/utils/cli/test/stubs/scanConfigWithCustomSorting.js'
+  const DETAILED_OUTPUT_CONFIG_FILE_PATH =
+    'packages/utils/cli/test/stubs/scanConfigWithDetailedOutput.js'
+  const IMPORTS_CONFIG_FILE_PATH = 'packages/utils/cli/test/stubs/scanConfigWithCustomImports.js'
+
+  const adoptionCommand = async (args: string[] = []) => {
+    /**
+     * We define here some common options such as custom directory (for performance reasons).
+     */
+    return await cliProcess.execute(
+      ['scan', 'adoption', '-dir', './packages/components', ...args],
+      [ENTER]
+    )
+  }
+
+  beforeEach(() => {
+    if (fse.existsSync(OUTPUT_FILE)) fse.removeSync(OUTPUT_FILE)
+  })
+
+  afterAll(() => {
+    if (fse.existsSync(OUTPUT_FILE)) fse.removeSync(OUTPUT_FILE)
+  })
+
+  describe('Adoption (components adoption)', () => {
+    it('should execute command with default config', async () => {
+      const response = await adoptionCommand(['-v'])
+
+      expect(response).toMatch(/Loading default configuration/i)
+      expect(response).toMatch(/Scanning adoption for @spark-ui/i)
+
+      expect(response).toMatch(/Found/i)
+
+      /**
+       * With no output option the adoption report will be simply logged
+       */
+      expect(
+        response.filter(
+          (entry: string | Record<string, unknown>) =>
+            entry['@spark-ui/button' as keyof typeof entry]
+        )
+      ).toBeDefined()
+    })
+
+    describe('Results details with output', () => {
+      it('should output results with packages details from command option', async () => {
+        await adoptionCommand(['-d', '-o', OUTPUT_FILE])
+
+        expect(fse.pathExistsSync(OUTPUT_FILE)).toBe(true)
+
+        const outputContent = JSON.parse(fse.readFileSync(OUTPUT_FILE, 'utf-8'))
+
+        Object.keys(outputContent).forEach(outputItem => {
+          expect(Object.keys(outputContent[outputItem]).includes('results')).toBeTruthy()
+        })
+      })
+
+      it('should output results with packages details from configuration file', async () => {
+        await adoptionCommand(['-c', DETAILED_OUTPUT_CONFIG_FILE_PATH])
+
+        expect(fse.pathExistsSync(OUTPUT_FILE)).toBe(true)
+
+        const outputContent = JSON.parse(fse.readFileSync(OUTPUT_FILE, 'utf-8'))
+
+        Object.keys(outputContent).forEach(outputItem => {
+          expect(Object.keys(outputContent[outputItem]).includes('results')).toBeTruthy()
+        })
+      })
+    })
+
+    describe('Results sorting', () => {
+      it('should sort results alphabetically from command option', async () => {
+        const response = await adoptionCommand(['-v', '-s', 'alphabetical'])
+
+        expect(response).toMatch(/Loading default configuration/i)
+        expect(response).toMatch(/Scanning adoption for @spark-ui/i)
+
+        const pkgList = Object.keys(
+          response.filter((entry: string | Record<string, unknown>) => typeof entry !== 'string')[0]
+        )
+
+        const sparkInputIndex = pkgList.indexOf('@spark-ui/input')
+        const sparkFormFieldIndex = pkgList.indexOf('@spark-ui/form-field')
+
+        expect(sparkInputIndex).toBeGreaterThan(sparkFormFieldIndex)
+      })
+
+      it('should sort results alphabetically from configuration file', async () => {
+        const response = await adoptionCommand(['-v', '-c', SORT_CONFIG_FILE_PATH])
+
+        expect(response).toMatch(/Loading spark-ui custom configuration file/i)
+        expect(response).toMatch(/Scanning adoption for @spark-ui/i)
+
+        const pkgList = Object.keys(
+          response.filter((entry: string | Record<string, unknown>) => typeof entry !== 'string')[0]
+        )
+
+        const sparkInputIndex = pkgList.indexOf('@spark-ui/input')
+        const sparkFormFieldIndex = pkgList.indexOf('@spark-ui/form-field')
+
+        expect(sparkInputIndex).toBeGreaterThan(sparkFormFieldIndex)
+      })
+    })
+
+    describe('File extensions', () => {
+      it('should execute command with custom extensions from command option', async () => {
+        const response = await adoptionCommand(['-v', '-ext', '.css'])
+
+        expect(response).toMatch(/Loading default configuration/i)
+        expect(response).toMatch(/Scanning adoption for @spark-ui/i)
+
+        expect(response).toMatch(/No files found with "@spark-ui" imports across directory/i)
+      })
+
+      it('should execute command with custom extensions from configuration file', async () => {
+        const response = await adoptionCommand(['-v', '-c', EXT_CONFIG_FILE_PATH])
+
+        expect(response).toMatch(/Loading spark-ui custom configuration file/i)
+        expect(response).toMatch(/Scanning adoption for @spark-ui/i)
+
+        expect(response).toMatch(/No files found with "@spark-ui" imports across directory/i)
+      })
+    })
+
+    describe('Imports patterns', () => {
+      it('should execute command for custom import patterns from command option', async () => {
+        const response = await adoptionCommand(['-v', '-i', '@react-aria', '@react-stately'])
+
+        expect(response).toMatch(/Scanning adoption for @react-aria/i)
+        expect(response).toMatch(/Scanning adoption for @react-stately/i)
+      })
+
+      it('should execute command for custom import patterns from configuration file', async () => {
+        const response = await adoptionCommand(['-v', '-c', IMPORTS_CONFIG_FILE_PATH])
+
+        expect(response).toMatch(/Scanning adoption for @react-aria/i)
+        expect(response).toMatch(/Scanning adoption for @react-stately/i)
+      })
+    })
+  })
+})

package/src/scan/loadConfig.mjs

@@ -0,0 +1,41 @@
+import process from 'node:process'
+
+import { existsSync } from 'fs'
+import path from 'path'
+
+import defaultConfig from './config.cjs'
+
+export async function loadConfig(configuration, { logger }) {
+  try {
+    const configFileRoute = path.join(process.cwd(), configuration || '.spark-ui.cjs')
+
+    if (existsSync(configFileRoute)) {
+      logger.info('ℹ️ Loading spark-ui custom configuration file')
+      const { default: customConfig } = await import(configFileRoute)
+
+      const config = {
+        adoption: {
+          ...defaultConfig.adoption,
+          ...customConfig.adoption,
+          imports: customConfig.adoption.imports || defaultConfig.adoption.imports,
+          extensions: customConfig.adoption.extensions || defaultConfig.adoption.extensions,
+        },
+      }
+
+      return config
+    } else {
+      if (configuration) {
+        logger.error('⚠️ No custom configuration file found:', configFileRoute)
+        process.exit(1)
+      }
+      logger.warning('⚠️ No custom configuration file found')
+      logger.info('ℹ️ Loading default configuration')
+
+      return { ...defaultConfig }
+    }
+  } catch (error) {
+    logger.error('💥 Something went wrong loading the custom configuration file', error)
+
+    return { ...defaultConfig }
+  }
+}

package/src/scan/utils/index.mjs

@@ -1,5 +1,4 @@
 export { extractImports } from './extract-imports.mjs'
 export { fileContainsImport } from './file-contains-import.mjs'
 export { getFormatedTimestamp } from './get-formated-timestamp.mjs'
-export { logger } from './logger.mjs'
 export { scanDirectories } from './scan-directories.mjs'

package/test/spark-generate.test.ts

@@ -12,21 +12,28 @@ const cliPath = path.join(__dirname, '../../bin/spark.mjs')
 const cliProcess = cmd.create(cliPath)
 
 describe('CLI `spark generate` (component package)', () => {
-  it('should properly generate package from CLI when arguments are valid', async () => {
-    // GIVEN a package definition
-    const packageName = 'bar'
-    const packageType = 'component'
+  const packageType = 'component'
+
+  const contextPath = TemplateGenerator.CONTEXTS[packageType] as string
+
+  const packagePath = path.join(process.cwd(), 'packages', contextPath, 'bar')
+  const invalidPackagePath = path.join(process.cwd(), 'packages', contextPath, '123')
+
+  beforeEach(() => {
+    if (fse.existsSync(packagePath)) fse.removeSync(packagePath)
+  })
+
+  afterAll(() => {
+    if (fse.existsSync(packagePath)) fse.removeSync(packagePath)
+  })
 
-    // WHEN we execute the `spark generate` command
+  it('should properly generate package from CLI when arguments are valid', async () => {
     const response = await cliProcess.execute(
       ['generate'],
-      [packageName, ENTER, packageType, ENTER, 'This is my foo component', ENTER]
+      ['bar', ENTER, packageType, ENTER, 'This is my foo component', ENTER]
     )
-    const contextPath = TemplateGenerator.CONTEXTS[packageType] as string
-    const packagePath = path.join(process.cwd(), 'packages', contextPath, packageName)
 
-    // THEN each file is created and the user is informed about it
-    const expectedFiles = [
+    ;[
       '/.npmignore',
       '/package.json',
       '/src/index.ts',
@@ -37,33 +44,19 @@ describe('CLI `spark generate` (component package)', () => {
       '/src/Bar.test.tsx',
       '/src/Bar.stories.tsx',
       '/tsconfig.json',
-    ]
-
-    const assertExpectedFiles = (filePath: string) => {
-      expect(response).toContain(`Created ${packagePath}${filePath}`)
+    ].forEach((filePath: string) => {
+      expect(response.toString()).toContain(`Created ${packagePath}${filePath}`)
       expect(fse.pathExistsSync(`${packagePath}${filePath}`)).toBe(true)
-    }
-
-    expectedFiles.forEach(assertExpectedFiles)
-
-    // Finally we clean up the generated component package
-    fse.removeSync(packagePath)
+    })
   })
 
   it('should prevent generating package when argument are invalid', async () => {
-    // GIVEN the package name is not using kebab-case notation
-    const packageName = '123'
-    const packageType = 'component'
-
-    // WHEN we try to create it
-    const response = await cliProcess.execute(['generate'], [packageName, ENTER])
-    const contextPath = TemplateGenerator.CONTEXTS[packageType] as string
-    const packagePath = path.join(process.cwd(), 'packages', contextPath, packageName)
+    const response = await cliProcess.execute(['generate'], ['123', ENTER])
 
-    // THEN it throws an error and fails to create files for this package
-    expect(response).toContain(
+    expect(response.toString()).toContain(
       'Name name must contain letters and dash symbols only (ex: "my-package")'
     )
-    expect(fse.pathExistsSync(packagePath)).toBe(false)
+
+    expect(fse.pathExistsSync(invalidPackagePath)).toBe(false)
   })
 })

package/test/stubs/scanConfigWithCustomExtensions.js

@@ -0,0 +1,10 @@
+export default {
+  adoption: {
+    details: false,
+    sort: 'count',
+    imports: ['@spark-ui'],
+    extensions: ['.css'],
+    directory: '.',
+    output: null,
+  },
+}

package/test/stubs/scanConfigWithCustomImports.js

@@ -0,0 +1,10 @@
+export default {
+  adoption: {
+    details: false,
+    sort: 'count',
+    imports: ['@react-aria', '@react-stately'],
+    extensions: ['.tsx', '.ts'],
+    directory: '.',
+    output: null,
+  },
+}

package/test/stubs/scanConfigWithCustomSorting.js

@@ -0,0 +1,10 @@
+export default {
+  adoption: {
+    details: false,
+    sort: 'alphabetical',
+    imports: ['@spark-ui'],
+    extensions: ['.tsx', '.ts'],
+    directory: '.',
+    output: null,
+  },
+}

package/test/stubs/scanConfigWithDetailedOutput.js

@@ -0,0 +1,10 @@
+export default {
+  adoption: {
+    details: true,
+    sort: 'count',
+    imports: ['@spark-ui'],
+    extensions: ['.tsx', '.ts'],
+    directory: '.',
+    output: 'report.json',
+  },
+}

package/test/utils/cmd.js

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 /**
  * CLI Integration Test Helper
  * @author Andrés Zorro <zorrodg@gmail.com>
@@ -11,11 +12,30 @@ import { constants } from 'os'
 
 const PATH = process.env.PATH
 
+/**
+ * Format CMD response as a JSON object
+ */
+function getReportFromData(data) {
+  const regex = /({[\s\S]*})/ // Regular expression to match object type
+  const match = data.match(regex)
+
+  const messages = data
+    .slice(0, match?.index ?? undefined)
+    .trim()
+    .split('\n')
+    .map(line => line.trim())
+    .filter(line => line)
+
+  const json = match ? JSON.parse(match[0]) : undefined
+
+  return [...messages, json]
+}
+
 /**
  * Creates a child process with script path
- * @param processPath Path of the process to execute
- * @param args Arguments to the command
- * @param env (optional) Environment variables
+ * @param {string} processPath Path of the process to execute
+ * @param {Array} args Arguments to the command
+ * @param {Object} env (optional) Environment variables
  */
 function createProcess(processPath, args = [], env = null) {
   // Ensure that path exists
@@ -44,18 +64,18 @@ function createProcess(processPath, args = [], env = null) {
  * Creates a command and executes inputs (user responses) to the stdin
  * Returns a promise that resolves when all inputs are sent
  * Rejects the promise if any error
- * @param processPath Path of the process to execute
- * @param args Arguments to the command
- * @param inputs (Optional) Array of inputs (user responses)
- * @param opts (optional) Environment variables
+ * @param {string} processPath Path of the process to execute
+ * @param {Array} args Arguments to the command
+ * @param {Array} inputs (Optional) Array of inputs (user responses)
+ * @param {Object} opts (optional) Environment variables
  */
-function executeWithInput(processPath, args, inputs, opts = {}) {
+function executeWithInput(processPath, args = [], inputs = [], opts = {}) {
   if (!Array.isArray(inputs)) {
     opts = inputs
     inputs = []
   }
 
-  const { env = null, timeout = 100, maxTimeout = 10000 } = opts
+  const { env = null, timeout = 250, maxTimeout = 10000 } = opts
   const childProcess = createProcess(processPath, args, env)
   childProcess.stdin.setEncoding('utf-8')
 
@@ -64,12 +84,12 @@ function executeWithInput(processPath, args, inputs, opts = {}) {
   // Creates a loop to feed user inputs to the child process in order to get results from the tool
   // This code is heavily inspired (if not blantantly copied) from inquirer-test:
   // https://github.com/ewnd9/inquirer-test/blob/6e2c40bbd39a061d3e52a8b1ee52cdac88f8d7f7/index.js#L14
-  const loop = ins => {
+  const loop = inputs => {
     if (killIOTimeout) {
       clearTimeout(killIOTimeout)
     }
 
-    if (!ins.length) {
+    if (!inputs.length) {
       childProcess.stdin.end()
 
       // Set a timeout to wait for CLI response. If CLI takes longer than
@@ -83,12 +103,12 @@ function executeWithInput(processPath, args, inputs, opts = {}) {
     }
 
     currentInputTimeout = setTimeout(() => {
-      childProcess.stdin.write(ins[0])
+      childProcess.stdin.write(inputs[0])
       // Log debug I/O statements on tests
       if (env && env.DEBUG) {
-        console.log('input:', ins[0]) // eslint-disable-line no-console
+        console.log('input:', inputs[0])
       }
-      loop(ins.slice(1))
+      loop(inputs.slice(1))
     }, timeout)
   }
 
@@ -97,7 +117,7 @@ function executeWithInput(processPath, args, inputs, opts = {}) {
     childProcess.stderr.on('data', data => {
       // Log debug I/O statements on tests
       if (env && env.DEBUG) {
-        console.log('error:', data.toString()) // eslint-disable-line no-console
+        console.log('error:', data.toString())
       }
     })
 
@@ -105,7 +125,7 @@ function executeWithInput(processPath, args, inputs, opts = {}) {
     childProcess.stdout.on('data', data => {
       // Log debug I/O statements on tests
       if (env && env.DEBUG) {
-        console.log('output:', data.toString()) // eslint-disable-line no-console
+        console.log('output:', data.toString())
       }
     })
 
@@ -130,7 +150,7 @@ function executeWithInput(processPath, args, inputs, opts = {}) {
           clearTimeout(killIOTimeout)
         }
 
-        resolve(result.toString())
+        resolve(getReportFromData(result.toString()))
       })
     )
   })

package/src/scan/utils/logger.mjs

@@ -1,19 +0,0 @@
-import chalk from 'chalk'
-
-export const logger = {
-  error(...args) {
-    console.log(chalk.red(...args))
-  },
-  warn(...args) {
-    console.log(chalk.yellow(...args))
-  },
-  info(...args) {
-    console.log(chalk.cyan(...args))
-  },
-  success(...args) {
-    console.log(chalk.green(...args))
-  },
-  break() {
-    console.log('')
-  },
-}