@brickflow/cli 0.0.5 → 0.0.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @brickflow/cli
 
+## 0.0.7
+
+### Patch Changes
+
+- CLI command base
+
+## 0.0.6
+
+### Patch Changes
+
+- -
+
 ## 0.0.5
 
 ### Patch Changes

package/index.mjs

@@ -1,109 +1,60 @@
 #!/usr/bin/env node
 
-import { execFile } from 'node:child_process'
-import { readdir, readFile, writeFile } from 'node:fs/promises'
+import { access, readdir } from 'node:fs/promises'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import { promisify } from 'node:util'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 
-const execFileAsync = promisify(execFile)
 const cliDir = path.dirname(fileURLToPath(import.meta.url))
-const repoRoot = path.resolve(cliDir, '../..')
-const workspaceRoots = ['apps', 'packages']
+const commandsDir = path.join(cliDir, 'src')
 
-async function getWorkspacePackageJsonPaths() {
-  const packagePaths = []
+async function getAvailableCommands() {
+  const entries = await readdir(commandsDir, { withFileTypes: true })
 
-  for (const workspaceRoot of workspaceRoots) {
-    const rootPath = path.join(repoRoot, workspaceRoot)
-    const entries = await readdir(rootPath, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) {
-        continue
-      }
-
-      packagePaths.push(path.join(rootPath, entry.name, 'package.json'))
-    }
-  }
+  return entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort()
+}
 
-  return packagePaths
+function isValidCommandName(command) {
+  return typeof command === 'string' && /^[a-z0-9-]+$/i.test(command)
 }
 
 async function main() {
   const [command] = process.argv.slice(2)
+  const commands = await getAvailableCommands()
 
-  switch (command) {
-    case 'latest':
-      await runLatest()
-      return
-    default:
-      printHelp()
-      process.exitCode = 1
+  if (!command || !(await runCommand(command))) {
+    printHelp(commands)
+    process.exitCode = 1
   }
 }
 
-function printHelp() {
+function printHelp(commands) {
   console.log(`brick cli
 
 Usage:
-  brick latest`)
-}
+  brick <command>
 
-function renderProgress(percent) {
-  const completed = Math.round(percent / 10)
-  return `${'#'.repeat(completed)}${'.'.repeat(10 - completed)}`
+Commands:
+  ${commands.join('\n  ')}`)
 }
 
-async function runLatest() {
-  console.log('\x1b[32mPackage update')
-
-  const packagePaths = await getWorkspacePackageJsonPaths()
-  let index = 0
-
-  for (const packagePath of packagePaths) {
-    index += 1
-
-    const packageJson = JSON.parse(await readFile(packagePath, 'utf8'))
-    await updatePackageVersions(packageJson)
-    await writeFile(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`)
-
-    const percent = Math.round((index * 100) / packagePaths.length)
-    process.stdout.write(`\rUpdating: [${renderProgress(percent)}] ${percent}%`)
+async function runCommand(command) {
+  if (!isValidCommandName(command)) {
+    return false
   }
 
-  process.stdout.write('\n')
-  console.log('\x1b[0m')
-}
-
-async function updatePackageVersions(packageJson) {
-  const dependencyEntries = [
-    ...Object.entries(packageJson.dependencies || {}).map(([name, version]) => ({
-      group: 'dependencies',
-      name,
-      version,
-    })),
-    ...Object.entries(packageJson.devDependencies || {}).map(([name, version]) => ({
-      group: 'devDependencies',
-      name,
-      version,
-    })),
-  ]
+  const commandEntry = path.join(commandsDir, command, 'index.js')
 
-  await Promise.all(
-    dependencyEntries.map(async ({ group, name, version }) => {
-      if (version === 'workspace:*' || version === 'workspace: *') {
-        return
-      }
+  try {
+    await access(commandEntry)
+  } catch {
+    return false
+  }
 
-      try {
-        const { stdout } = await execFileAsync('npm', ['view', name, 'version'])
-        packageJson[group][name] = stdout.trim()
-      } catch (error) {
-        console.info(error instanceof Error ? error.message : String(error))
-      }
-    }),
-  )
+  await import(pathToFileURL(commandEntry).href)
+  return true
 }
 
 await main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brickflow/cli",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "",
   "type": "module",
   "main": "index.mjs",
@@ -14,6 +14,18 @@
     "format": "pnpm exec prettier . --ignore-path ../../.prettierignore --write",
     "format:check": "pnpm exec prettier . --ignore-path ../../.prettierignore --check"
   },
+  "dependencies": {
+    "@babel/parser": "^7.29.7",
+    "@babel/traverse": "^7.29.7",
+    "@babel/types": "^7.29.7",
+    "@google/genai": "^2.6.0",
+    "@vue/compiler-sfc": "^3.5.35",
+    "fantasticon": "^4.1.0",
+    "glob": "^13.0.6",
+    "looks-same": "^10.0.1",
+    "sharp": "^0.34.5",
+    "svgo": "^4.0.1"
+  },
   "publishConfig": {
     "access": "public"
   },

package/src/avif/index.js

@@ -0,0 +1,79 @@
+import fs from 'fs'
+import { globSync } from 'glob'
+import path from 'path'
+
+const args = process.argv.slice(3)
+const extensions = '.{png,jpg,jpeg,webp}'
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (!args[0]) {
+  printHelp()
+  process.exit(1)
+}
+
+console.log('\x1b[32m', '\rIMG Optimize')
+
+const patternPrefix = resolvePatternPrefix(args[0])
+const searchPattern = `${patternPrefix}${extensions}`
+const imgList = globSync(searchPattern)
+
+if (imgList.length === 0) {
+  console.log(`\nNothing found for pattern: ${searchPattern}`)
+  console.log('\x1b[0m', '')
+  process.exit(0)
+}
+
+const { default: sharp } = await import('sharp')
+
+for (let i = 0; i < imgList.length; i++) {
+  const imgPath = imgList[i]
+  await sharp(imgPath)
+    .avif({
+      effort: 7,
+      quality: 70,
+    })
+    .toFile(`${imgPath.replace(/\.(png|jpg|jpeg|webp)$/i, '')}.avif`)
+
+  const percent = Math.round(((i + 1) * 100) / imgList.length)
+  fs.unlinkSync(imgPath)
+  process.stdout.write(`\r💎 Optimizing: [${'🌹'.repeat((percent * 10) / 100)}]  ${percent}%`)
+}
+
+console.log('\x1b[0m', '')
+
+function printHelp() {
+  console.log(`brick avif <pattern>
+
+Usage:
+  brick avif ../brick/public/**/*
+  brick avif ./src/assets/**/*
+  brick avif ./src/assets
+
+Notes:
+  The command always searches only for ${extensions}
+  Pass a directory or a glob prefix without the extension part`)
+}
+
+function resolvePatternPrefix(input) {
+  if (/[?*[\]{}]/.test(input)) {
+    return stripTrailingExtensionGroup(input)
+  }
+
+  if (/[\\/]$/.test(input)) {
+    return `${input}**/*`
+  }
+
+  if (fs.existsSync(input) && fs.statSync(input).isDirectory()) {
+    return path.join(input, '**/*').replace(/\\/g, '/')
+  }
+
+  return stripTrailingExtensionGroup(input)
+}
+
+function stripTrailingExtensionGroup(input) {
+  return input.replace(/\.\{png,jpg,jpeg,webp\}$/i, '')
+}

package/src/filename/index.js

@@ -0,0 +1,70 @@
+import fs from 'fs'
+import { globSync } from 'glob'
+
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (args.length > 0) {
+  printHelp()
+  process.exit(1)
+}
+
+console.log('\x1b[32m', '\rFilename analyse')
+const dsStore = globSync('./**/.DS_Store')
+if (dsStore.length > 0) {
+  console.log('\x1b[0m', '')
+  dsStore.forEach((item) => {
+    fs.unlinkSync(item)
+    console.log(item)
+  })
+
+  throw `🥌 Remove .DS_Store ${dsStore[0]}`
+}
+
+const allFile = globSync('./**/*.*')
+
+let errorFilename = ''
+allFile.forEach((path) => {
+  if (/\.md/.test(path)) {
+    return
+  }
+  if (/node_modules/.test(path)) {
+    return
+  }
+  const filename = path.match(/([^/\\]+).[a-z\d]$/)?.[0]
+  if (!filename) {
+    console.warn(path)
+  }
+  if (/[A-Z]{3}.svg/.test(filename)) {
+    return
+  }
+  const isKebabCase = !/[^a-z./\d_-]/.test(filename)
+  if (!isKebabCase) {
+    errorFilename = `${errorFilename}
+      🍖 No Kebab  🗺️ ${path} | ${filename}
+    `
+  }
+})
+
+if (errorFilename.length > 0) {
+  console.log('\x1b[0m', '')
+  throw errorFilename
+}
+
+console.log('\x1b[0m', '')
+
+function printHelp() {
+  console.log(`brick filename
+
+Usage:
+  brick filename
+
+Notes:
+  Scans files under the current working directory
+  Removes .DS_Store files and fails on non-kebab-case filenames
+  Ignores markdown files and node_modules`)
+}

package/src/graph/index.js

@@ -0,0 +1,78 @@
+import fs from 'fs'
+import { globSync } from 'glob'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (args.length > 0) {
+  printHelp()
+  process.exit(1)
+}
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const workspaceRoot = path.resolve(currentDir, '../../../..')
+const packageJsonPaths = globSync('**/package.json', {
+  absolute: true,
+  cwd: workspaceRoot,
+  ignore: ['**/node_modules/**'],
+}).sort()
+
+const dependenciesMap = new Map()
+
+for (const packageJsonPath of packageJsonPaths) {
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+  const packageLabel = getPackageLabel(packageJsonPath)
+
+  addDependencies(packageLabel, packageJson.dependencies)
+  addDependencies(packageLabel, packageJson.devDependencies)
+}
+
+const table = {}
+
+for (const [dependencyName, versionsByPackage] of dependenciesMap) {
+  const uniqueVersions = new Set(Object.values(versionsByPackage))
+
+  if (uniqueVersions.size > 1) {
+    table[dependencyName] = versionsByPackage
+  }
+}
+
+console.table(table)
+
+function addDependencies(packageLabel, dependencyGroup) {
+  if (!dependencyGroup) {
+    return
+  }
+
+  for (const [dependencyName, version] of Object.entries(dependencyGroup)) {
+    const currentVersions = dependenciesMap.get(dependencyName) ?? {}
+    dependenciesMap.set(dependencyName, {
+      ...currentVersions,
+      [packageLabel]: version,
+    })
+  }
+}
+
+function getPackageLabel(packageJsonPath) {
+  const relativePath = path.relative(workspaceRoot, packageJsonPath).replace(/\\/g, '/')
+  const packageDir = path.dirname(relativePath)
+
+  return packageDir === '.' ? 'root' : packageDir
+}
+
+function printHelp() {
+  console.log(`brick graph
+
+Usage:
+  brick graph
+
+Notes:
+  Scans all package.json files in the repository, including the root one
+  Prints only dependencies that have different versions across packages`)
+}

package/src/icon/index.js

@@ -0,0 +1,162 @@
+import { FontAssetType, generateFonts, OtherAssetType } from 'fantasticon'
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const workspaceRoot = path.resolve(currentDir, '../../../..')
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+const options = parseArgs(args)
+
+if (!options.path) {
+  printHelp()
+  process.exit(1)
+}
+
+const inputDir = path.resolve(process.cwd(), options.path)
+const iconName = options.name || path.basename(inputDir)
+const outputDir = options.output
+  ? path.resolve(process.cwd(), options.output)
+  : path.resolve(workspaceRoot, `brick/assets/icons/${iconName}`)
+
+if (!fs.existsSync(inputDir)) {
+  throw new Error(`Icon input directory is not found: ${inputDir}`)
+}
+
+if (!fs.statSync(inputDir).isDirectory()) {
+  throw new Error(`Icon input path must be a directory: ${inputDir}`)
+}
+
+if (/[\\/]/.test(iconName)) {
+  throw new Error(`Icon name must not contain path separators: ${iconName}`)
+}
+
+fs.mkdirSync(outputDir, { recursive: true })
+
+await generateFonts({
+  assetTypes: [OtherAssetType.CSS, OtherAssetType.JSON],
+  fontsUrl: '.',
+  fontTypes: [FontAssetType.EOT, FontAssetType.WOFF2, FontAssetType.WOFF],
+  formatOptions: {
+    json: {
+      indent: 2,
+    },
+  },
+  inputDir,
+  name: iconName,
+  normalize: true,
+  outputDir,
+})
+
+const cssSourceFile = [`${iconName}.css`, 'icons.css', 'icon.css'].find((file) =>
+  fs.existsSync(path.join(outputDir, file)),
+)
+
+if (!cssSourceFile) {
+  throw new Error(`CSS output file was not generated for icon set "${iconName}"`)
+}
+
+const cssPath = path.join(outputDir, cssSourceFile)
+const minifiedCssPath = path.join(outputDir, `${path.parse(cssSourceFile).name}.minify.css`)
+const cssContent = fs.readFileSync(cssPath, 'utf8')
+const normalizedCssContent = normalizeGeneratedCss(cssContent)
+
+if (normalizedCssContent !== cssContent) {
+  fs.writeFileSync(cssPath, normalizedCssContent)
+}
+
+fs.writeFileSync(minifiedCssPath, minifyCss(normalizedCssContent))
+
+console.log(`✅ Icons generated for ${iconName}`)
+console.log(`   input:  ${inputDir}`)
+console.log(`   output: ${outputDir}`)
+
+function minifyCss(css) {
+  return css
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    .replace(/\s+/g, ' ')
+    .replace(/\s*([{}:;,>+~])\s*/g, '$1')
+    .replace(/;\}/g, '}')
+    .trim()
+}
+
+function normalizeGeneratedCss(css) {
+  return `${css
+    .replace(/"/g, "'")
+    .replace(/^ {4}/gm, '  ')
+    .replace(/src: ([^\n]+),\n([^\n]+),\n([^\n]+);/, 'src:\n    $1,\n    $2,\n    $3;')
+    .replace(
+      /i\[class\^='icon-'\]:before, i\[class\*=' icon-'\]:before \{/,
+      "i[class^='icon-']:before,\ni[class*=' icon-']:before {",
+    )
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()}\n`
+}
+
+function parseArgs(rawArgs) {
+  const parsedOptions = {
+    name: null,
+    output: null,
+    path: null,
+  }
+  const positional = []
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const value = rawArgs[index]
+
+    if (value === '--path') {
+      parsedOptions.path = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--name') {
+      parsedOptions.name = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--output') {
+      parsedOptions.output = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    positional.push(value)
+  }
+
+  if (!parsedOptions.path) {
+    parsedOptions.path = positional[0] ?? null
+  }
+
+  if (!parsedOptions.name) {
+    parsedOptions.name = positional[1] ?? null
+  }
+
+  if (!parsedOptions.output) {
+    parsedOptions.output = positional[2] ?? null
+  }
+
+  return parsedOptions
+}
+
+function printHelp() {
+  console.log(`brick icon <path> [name] [output]
+
+Usage:
+  brick icon ./path/to/svg-icons
+  brick icon ./path/to/svg-icons marketing
+  brick icon ./path/to/svg-icons marketing ./path/to/output
+  brick icon --path ./path/to/svg-icons --name marketing --output ./path/to/output
+
+Notes:
+  path: directory with source .svg icons
+  name: icon set name and generated asset prefix
+  output: directory for generated files; default is brick/assets/icons/<name>`)
+}