@create-mastery/cli 0.1.0

package/README.md

@@ -0,0 +1,9 @@
+<div align=center>
+
+# Create Mastery CLI
+
+</div>
+
+The official Create Mastery CLI, created for enhancing DX
+
+Run `cm --help` for all available commands

package/biome.json

@@ -0,0 +1,6 @@
+{
+  "extends": [
+    "../biome.json"
+  ],
+  "root": false
+}

package/cli.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env tsx
+
+import { program } from 'commander'
+import gradient from 'gradient-string'
+import addComponent from './commands/add/component'
+import addLanguage from './commands/add/language'
+import { genSchema } from './commands/generate-schema'
+import printScripts from './commands/scripts'
+import printVersion from './commands/version'
+import cliInfo from './package.json'
+import { createMasteryASCIIArtBig } from './utils/arts'
+import { execSync } from 'node:child_process'
+import chalk from 'chalk'
+
+const add = program.command('add').description('add a language or component')
+const gen = program.command('gen').description('generate the dictionary schema')
+
+program.version(cliInfo.version)
+program.name('cm')
+
+program.addHelpText(
+  'beforeAll',
+  gradient([
+    '#8dc4ff',
+    '#bddaff',
+  ]).multiline(createMasteryASCIIArtBig)
+)
+
+// I know this may look silly, but it's for creating space between the prompt and the help message
+program.addHelpText('afterAll', ' ')
+
+program.description(cliInfo.description)
+
+program
+  .command('version')
+  .description(
+    'display the version of the Create Mastery website and some other useful information'
+  )
+  .option('-v, --verbose', 'verbose output of version command', false)
+  .action((options) => printVersion(options.verbose))
+
+program
+  .command('scripts')
+  .description('display all the available scripts in package.json')
+  .action(() => printScripts())
+
+program
+  .command('clone')
+  .description('clone the Create Mastery repo')
+  .argument('<destination>', 'the directory where the repo will be cloned')
+  .action((destination) => {
+    try {
+      execSync(
+        `git clone https://github.com/Create-Mastery/website.git ${destination}`
+      )
+
+      console.log(chalk.blue('repo cloned in:'), destination)
+      console.log(
+        chalk.blue('now run `npm install` to install all the dependencies')
+      )
+    } catch (err) {
+      console.error('an error has occurred:', err)
+    }
+  })
+
+gen
+  .command('schema')
+  .description('generates the schema for the dictionaries')
+  .action(() => genSchema())
+
+add
+  .command('component')
+  .description('creates a new component (in the src/app/components/ directory)')
+  .argument('<name>', 'component to add')
+  .option('-p, --props', 'the component is generated with props', false)
+  .option('-c, --client', 'the component is a client component', false)
+  .action((name, options) => addComponent(name, options.props, options.client))
+
+add
+  .command('language')
+  .description('creates a new language for i18n')
+  .argument('<language>', 'language to add')
+  .action((language) => addLanguage(language))
+
+program.parse()

package/commands/add/component.ts

@@ -0,0 +1,73 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import chalk from 'chalk'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const componentsDir = path.resolve(__dirname, '../../../src/components/')
+
+export default function addComponent(
+  componentName: string,
+  props: boolean,
+  client: boolean
+) {
+  const filePath = path.resolve(componentsDir, `${componentName}.tsx`)
+  const dirPath = path.dirname(filePath)
+
+  const rawName = componentName.trim()
+
+  if (!rawName) {
+    throw new Error('Component name cannot be empty')
+  }
+
+  const fileName = rawName.split('/').pop()
+
+  if (!fileName) {
+    throw new Error('Invalid component name')
+  }
+
+  const finalName = fileName
+    .replace(/[-_](\w)/g, (_, c) => c.toUpperCase())
+    .replace(/^\w/, (c) => c.toUpperCase())
+
+  let content: string = ''
+
+  if (fs.existsSync(filePath)) {
+    console.log(
+      chalk.red('The component'),
+      chalk.reset(`${rawName}.tsx`),
+      chalk.red('already exists')
+    )
+
+    return
+  }
+
+  if (client) {
+    content += `'use client'\n\n`
+  }
+
+  if (props) {
+    content += `type Props = {\n\n}\n\n`
+  }
+
+  content += `const ${finalName} = (${props ? '{  }: Props' : ''}) => {
+  return (
+    <div></div>
+  )
+}
+
+export default ${finalName}`
+
+  fs.mkdirSync(dirPath, {
+    recursive: true,
+  })
+  fs.writeFileSync(filePath, content)
+
+  console.log(
+    chalk.blue('Component created -'),
+    chalk.reset(`${componentName}.tsx`)
+  )
+  console.log(chalk.blue('Props             -'), chalk.reset(props))
+  console.log(chalk.blue('Client            -'), chalk.reset(client))
+}

package/commands/add/language.ts

@@ -0,0 +1,126 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import chalk from 'chalk'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const dictionarieDir = path.resolve(__dirname, '../../../src/i18n/dictionaries')
+
+type Json =
+  | string
+  | number
+  | boolean
+  | null
+  | Json[]
+  | {
+      [key: string]: Json
+    }
+
+function stripValues(obj: Json): Json {
+  if (obj === '$schema') return obj
+  if (typeof obj === 'string') return ''
+  if (Array.isArray(obj)) return obj.map(stripValues)
+  if (typeof obj === 'object' && obj !== null) {
+    return Object.fromEntries(
+      Object.entries(obj).map(([k, v]) => [
+        k,
+        k === '$schema' ? v : stripValues(v),
+      ])
+    ) as Json
+  }
+  return obj
+}
+
+function genLocales(files: string[]) {
+  const locales = files.map((f) => `'${f.replace('.json', '')}'`).join(' | ')
+  const content = `export type locales = ${locales}\n`
+
+  fs.writeFileSync(
+    path.resolve(__dirname, '../../../src/i18n/types/locales.ts'),
+    content
+  )
+}
+
+function genI18n(files: string[]) {
+  const locales = files
+    .map((f) => `'${f.replace('.json', '')}'`)
+    .join(',\n\t\t')
+  const content = `export const i18n = {
+  defaultLocale: 'en',
+  locales: [
+\t\t${locales}
+  ],
+}`
+
+  fs.writeFileSync(
+    path.resolve(__dirname, '../../../src/i18n/i18n.ts'),
+    content
+  )
+}
+
+function genDictionaryLoaders(files: string[]) {
+  const dictionaries = files.map((f) => f.replace('.json', ''))
+
+  let dictionariesLoaders: string = `import { type Locale } from '../config'\n\nexport const dictionariesLoaders: Locale = {\n`
+
+  for (const dictionary of dictionaries) {
+    dictionariesLoaders += `\t${dictionary}: () => import('./${dictionary}.json').then((module) => module.default),\n`
+  }
+
+  dictionariesLoaders += '}'
+
+  fs.writeFileSync(
+    path.resolve(
+      __dirname,
+      '../../../src/i18n/dictionaries/dictionaries-loaders.ts'
+    ),
+    dictionariesLoaders
+  )
+}
+
+export default function addLanguage(language: string) {
+  const input = JSON.parse(fs.readFileSync(`${dictionarieDir}/en.json`, 'utf8'))
+  const output = stripValues(input)
+
+  let files: string[]
+
+  files = fs
+    .readdirSync(dictionarieDir)
+    .filter((f) => f.endsWith('.json') && f !== 'schema.schema.json')
+
+  if (files.includes(`${language}.json`)) {
+    console.log(
+      chalk.red('This language:'),
+      chalk.reset(language),
+      chalk.red('already exists')
+    )
+
+    return
+  }
+
+  fs.writeFileSync(
+    `${dictionarieDir}/${language}.json`,
+    JSON.stringify(output, null, 2)
+  )
+
+  files = fs
+    .readdirSync(dictionarieDir)
+    .filter((f) => f.endsWith('.json') && f !== 'schema.schema.json')
+
+  genDictionaryLoaders(files)
+  genLocales(files)
+  genI18n(files)
+
+  console.log(chalk.blue('Language       - '), chalk.reset(language))
+  console.log(
+    chalk.blue('File Create at - '),
+    chalk.reset(`@/i18n/dictionaries/${language}.json`)
+  )
+  console.log(chalk.blue('Regenerated files:'))
+  console.log('  @/src/i18n/i18n.ts')
+  console.log('  @/src/i18n/types/locales.ts')
+  console.log('  @/src/i18n/dictionaries/dictionaries-loaders.ts')
+  console.log()
+  console.log(chalk.blue('Now you need to add the actual values to the file!'))
+}

package/commands/generate-schema.ts

@@ -0,0 +1,56 @@
+import * as GenerateSchema from 'generate-schema'
+
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import chalk from 'chalk'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const dictionarieDir = path.resolve(__dirname, '../../src/i18n/dictionaries/')
+const dictionary = JSON.parse(
+  fs.readFileSync(`${dictionarieDir}/en.json`, 'utf8')
+)
+const schemaPath = path.resolve(
+  __dirname,
+  `${dictionarieDir}/schema.schema.json`
+)
+
+interface JsonSchema {
+  type: string
+  properties?: {
+    [key: string]: JsonSchema
+  }
+  required?: string[]
+}
+
+function addRequiredRecursively(
+  schemaNode: JsonSchema,
+  dataNode: Record<string, unknown>
+) {
+  if (
+    schemaNode.type === 'object'
+    && dataNode
+    && typeof dataNode === 'object'
+  ) {
+    schemaNode.required = Object.keys(dataNode).filter((k) => k !== '$schema')
+    if (schemaNode.properties) {
+      for (const key of Object.keys(schemaNode.properties || {})) {
+        addRequiredRecursively(
+          schemaNode.properties[key],
+          dataNode[key] as Record<string, unknown>
+        )
+      }
+    }
+  }
+}
+
+export function genSchema() {
+  const schema = GenerateSchema.json('dictionary schema', dictionary)
+
+  addRequiredRecursively(schema, dictionary)
+
+  fs.writeFileSync(schemaPath, JSON.stringify(schema, null, 2), 'utf8')
+
+  console.log(chalk.blue('Schema generated successfully'))
+}

package/commands/scripts.ts

@@ -0,0 +1,15 @@
+import chalk from 'chalk'
+import siteInfo from '../../package.json'
+import { createMasteryASCIIArtSmall } from '../utils/arts'
+
+export default function printScripts() {
+  console.log(chalk.blue(createMasteryASCIIArtSmall))
+  console.log(chalk.blue('Available scripts:'))
+  console.log(chalk.blue('──────────────────────────────────────────'))
+  Object.entries(siteInfo.scripts).forEach(([key, value]) => {
+    console.log(
+      `${chalk.blue(key.padEnd(10))} ${chalk.blue('─')} ${chalk.reset(value)}`
+    )
+  })
+  console.log()
+}

package/commands/version.ts

@@ -0,0 +1,38 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import chalk from 'chalk'
+import { globSync } from 'glob'
+import siteInfo from '../../package.json'
+import { createMasteryASCIIArtSmall } from '../utils/arts'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export default function printVersion(verbose: boolean) {
+  const dictionarieDir = path.resolve(__dirname, '../../src/i18n/dictionaries')
+  const guideDirectory = path.resolve(__dirname, '../../src/app/**/guide')
+
+  // since schema.schema.json is also counted we decrement the value by 1 to get the actual number of languages
+  const getLanguages = () =>
+    fs.readdirSync(dictionarieDir).filter((f) => f.endsWith('.json')).length - 1
+
+  const deps = Object.keys(siteInfo.dependencies).length
+  const devDeps = Object.keys(siteInfo.devDependencies).length
+
+  const languages: number = getLanguages()
+  const guides: number = globSync(`${guideDirectory}/**/*.tsx`).length
+
+  console.log(chalk.blue(createMasteryASCIIArtSmall))
+  console.log(chalk.blue('VERSION   ─'), chalk.reset(siteInfo.version))
+  console.log(chalk.blue('GUIDES    ─'), chalk.reset(guides))
+  console.log(chalk.blue('LANGUAGES ─'), chalk.reset(languages))
+
+  if (verbose) {
+    console.log(chalk.blue('──────────────────────────────────────────'))
+    console.log(chalk.blue('DEPENDENCIES     ─'), chalk.reset(deps))
+    console.log(chalk.blue('DEV DEPENDENCIES ─'), chalk.reset(devDeps))
+  }
+
+  console.log()
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@create-mastery/cli",
+  "version": "0.1.0",
+  "description": "The official Create Website CLI, created to enhance the DX",
+  "homepage": "https://github.com/Create-Mastery/website/tree/main/cli#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Create-Mastery/website.git#readme"
+  },
+  "license": "GPL-3.0-only",
+  "author": "Create Mastery",
+  "type": "module",
+  "main": "./cli.ts",
+  "bin": {
+    "cm": "cli.ts"
+  },
+  "dependencies": {
+    "gradient-string": "^3.0.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "generate-schema": "^2.6.0",
+    "glob": "^13.0.0",
+    "tsx": "^4.21.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.11"
+  },
+  "keywords": [
+    "cli"
+  ]
+}

package/utils/arts.ts

@@ -0,0 +1,14 @@
+export const createMasteryASCIIArtSmall: string = `
+┏━╸┏━┓┏━╸┏━┓╺┳╸┏━╸   ┏┳┓┏━┓┏━┓╺┳╸┏━╸┏━┓╻ ╻
+┃  ┣┳┛┣╸ ┣━┫ ┃ ┣╸    ┃┃┃┣━┫┗━┓ ┃ ┣╸ ┣┳┛┗┳┛
+┗━╸╹┗╸┗━╸╹ ╹ ╹ ┗━╸   ╹ ╹╹ ╹┗━┛ ╹ ┗━╸╹┗╸ ╹
+──────────────────────────────────────────`
+
+export const createMasteryASCIIArtBig: string = `
+ ██████╗██████╗ ███████╗ █████╗ ████████╗███████╗    ███╗   ███╗ █████╗ ███████╗████████╗███████╗██████╗ ██╗   ██╗
+██╔════╝██╔══██╗██╔════╝██╔══██╗╚══██╔══╝██╔════╝    ████╗ ████║██╔══██╗██╔════╝╚══██╔══╝██╔════╝██╔══██╗╚██╗ ██╔╝
+██║     ██████╔╝█████╗  ███████║   ██║   █████╗      ██╔████╔██║███████║███████╗   ██║   █████╗  ██████╔╝ ╚████╔╝
+██║     ██╔══██╗██╔══╝  ██╔══██║   ██║   ██╔══╝      ██║╚██╔╝██║██╔══██║╚════██║   ██║   ██╔══╝  ██╔══██╗  ╚██╔╝
+╚██████╗██║  ██║███████╗██║  ██║   ██║   ███████╗    ██║ ╚═╝ ██║██║  ██║███████║   ██║   ███████╗██║  ██║   ██║
+ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝   ╚═╝   ╚══════╝    ╚═╝     ╚═╝╚═╝  ╚═╝╚══════╝   ╚═╝   ╚══════╝╚═╝  ╚═╝   ╚═╝
+──────────────────────────────────────────────────────────────────────────────────────────────────────────────────`